lazy_record 0.1.0

data/vendor/bundle/gems/i18n-0.8.1/test/backend/interpolation_compiler_test.rb

@@ -0,0 +1,118 @@
+require 'test_helper'
+
+class InterpolationCompilerTest < I18n::TestCase
+  Compiler = I18n::Backend::InterpolationCompiler::Compiler
+
+  def compile_and_interpolate(str, values = {})
+    Compiler.compile_if_an_interpolation(str).i18n_interpolate(values)
+  end
+
+  def assert_escapes_interpolation_key(expected, malicious_str)
+    assert_equal(expected, Compiler.send(:escape_key_sym, malicious_str))
+  end
+
+  def test_escape_key_properly_escapes
+    assert_escapes_interpolation_key ':"\""',       '"'
+    assert_escapes_interpolation_key ':"\\\\"',     '\\'
+    assert_escapes_interpolation_key ':"\\\\\""',   '\\"'
+    assert_escapes_interpolation_key ':"\#{}"',     '#{}'
+    assert_escapes_interpolation_key ':"\\\\\#{}"', '\#{}'
+  end
+
+  def assert_escapes_plain_string(expected, plain_str)
+    assert_equal expected, Compiler.send(:escape_plain_str, plain_str)
+  end
+
+  def test_escape_plain_string_properly_escapes
+    assert_escapes_plain_string '\\"',    '"'
+    assert_escapes_plain_string '\'',     '\''
+    assert_escapes_plain_string '\\#',    '#'
+    assert_escapes_plain_string '\\#{}',  '#{}'
+    assert_escapes_plain_string '\\\\\\"','\\"'
+  end
+
+  def test_non_interpolated_strings_or_arrays_dont_get_compiled
+    ['abc', '\\{a}}', '{a}}', []].each do |obj|
+      Compiler.compile_if_an_interpolation(obj)
+      assert_equal false, obj.respond_to?(:i18n_interpolate)
+    end
+  end
+
+  def test_interpolated_string_gets_compiled
+    assert_equal '-A-', compile_and_interpolate('-%{a}-', :a => 'A')
+  end
+
+  def assert_handles_key(str, key)
+    assert_equal 'A', compile_and_interpolate(str, key => 'A')
+  end
+
+  def test_compiles_fancy_keys
+    assert_handles_key('%{\}',       :'\\'    )
+    assert_handles_key('%{#}',       :'#'     )
+    assert_handles_key('%{#{}',      :'#{'    )
+    assert_handles_key('%{#$SAFE}',  :'#$SAFE')
+    assert_handles_key('%{\000}',    :'\000'  )
+    assert_handles_key('%{\'}',      :'\''    )
+    assert_handles_key('%{\'\'}',    :'\'\''  )
+    assert_handles_key('%{a.b}',     :'a.b'   )
+    assert_handles_key('%{ }',       :' '     )
+    assert_handles_key('%{:}',       :':'     )
+    assert_handles_key("%{:''}",     :":''"   )
+    assert_handles_key('%{:"}',      :':"'    )
+  end
+
+  def test_str_containing_only_escaped_interpolation_is_handled_correctly
+    assert_equal 'abc %{x}', compile_and_interpolate('abc %%{x}')
+  end
+
+  def test_handles_weird_strings
+    assert_equal '#{} a',         compile_and_interpolate('#{} %{a}',         :a    => 'a')
+    assert_equal '"#{abc}"',      compile_and_interpolate('"#{ab%{a}c}"',     :a    => '' )
+    assert_equal 'a}',            compile_and_interpolate('%{{a}}',           :'{a' => 'a')
+    assert_equal '"',             compile_and_interpolate('"%{a}',            :a    => '' )
+    assert_equal 'a%{a}',         compile_and_interpolate('%{a}%%{a}',        :a    => 'a')
+    assert_equal '%%{a}',         compile_and_interpolate('%%%{a}')
+    assert_equal '\";eval("a")',  compile_and_interpolate('\";eval("%{a}")',  :a    => 'a')
+    assert_equal '\";eval("a")',  compile_and_interpolate('\";eval("a")%{a}', :a    => '' )
+    assert_equal "\na",           compile_and_interpolate("\n%{a}",           :a    => 'a')
+  end
+
+  def test_raises_exception_when_argument_is_missing
+    assert_raise(I18n::MissingInterpolationArgument) do
+      compile_and_interpolate('%{first} %{last}', :first => 'first')
+    end
+  end
+
+  def test_custom_missing_interpolation_argument_handler
+    old_handler = I18n.config.missing_interpolation_argument_handler
+    I18n.config.missing_interpolation_argument_handler = lambda do |key, values, string|
+      "missing key is #{key}, values are #{values.inspect}, given string is '#{string}'"
+    end
+    assert_equal %|first missing key is last, values are {:first=>"first"}, given string is '%{first} %{last}'|,
+        compile_and_interpolate('%{first} %{last}', :first => 'first')
+  ensure
+    I18n.config.missing_interpolation_argument_handler = old_handler
+  end
+end
+
+class I18nBackendInterpolationCompilerTest < I18n::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::InterpolationCompiler
+  end
+
+  include I18n::Tests::Interpolation
+
+  def setup
+    I18n.backend = Backend.new
+    super
+  end
+
+  # pre-compile default strings to make sure we are testing I18n::Backend::InterpolationCompiler
+  def interpolate(*args)
+    options = args.last.kind_of?(Hash) ? args.last : {}
+    if default_str = options[:default]
+      I18n::Backend::InterpolationCompiler::Compiler.compile_if_an_interpolation(default_str)
+    end
+    super
+  end
+end

data/vendor/bundle/gems/i18n-0.8.1/test/backend/key_value_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class I18nBackendKeyValueTest < I18n::TestCase
+  def setup_backend!(subtree=true)
+    I18n.backend = I18n::Backend::KeyValue.new({}, subtree)
+    store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
+  end
+
+  def assert_flattens(expected, nested, escape=true, subtree=true)
+    assert_equal expected, I18n.backend.flatten_translations("en", nested, escape, subtree)
+  end
+
+  test "hash flattening works" do
+    setup_backend!
+    assert_flattens(
+      {:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}, :"b.f" => {:x=>"x"}, :"b.c"=>"c", :"b.f.x"=>"x", :"b.d"=>"d"},
+      {:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}}
+    )
+    assert_flattens({:a=>{:b =>['a', 'b']}, :"a.b"=>['a', 'b']}, {:a=>{:b =>['a', 'b']}})
+    assert_flattens({:"a\001b" => "c"}, {:"a.b" => "c"})
+    assert_flattens({:"a.b"=>['a', 'b']}, {:a=>{:b =>['a', 'b']}}, true, false)
+    assert_flattens({:"a.b" => "c"}, {:"a.b" => "c"}, false)
+  end
+
+  test "store_translations handle subtrees by default" do
+    setup_backend!
+    assert_equal({ :bar => 'bar', :baz => 'baz' }, I18n.t("foo"))
+  end
+
+  test "store_translations merge subtrees accordingly" do
+    setup_backend!
+    store_translations(:en, :foo => { :baz => "BAZ"})
+    assert_equal('BAZ', I18n.t("foo.baz"))
+    assert_equal({ :bar => 'bar', :baz => 'BAZ' }, I18n.t("foo"))
+  end
+
+  test "store_translations does not handle subtrees if desired" do
+    setup_backend!(false)
+    assert_raise I18n::MissingTranslationData do
+      I18n.t("foo", :raise => true)
+    end
+  end
+end if I18n::TestCase.key_value?

data/vendor/bundle/gems/i18n-0.8.1/test/backend/memoize_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+# TODO: change back to "require 'backend/simple'" when dropping support to Ruby 1.8.7.
+require File.expand_path('../simple_test', __FILE__)
+
+class I18nBackendMemoizeTest < I18nBackendSimpleTest
+  module MemoizeSpy
+    attr_accessor :spy_calls
+
+    def available_locales
+      self.spy_calls = (self.spy_calls || 0) + 1
+      super
+    end
+  end
+
+  class MemoizeBackend < I18n::Backend::Simple
+    include MemoizeSpy
+    include I18n::Backend::Memoize
+  end
+
+  def setup
+    super
+    I18n.backend = MemoizeBackend.new
+  end
+
+  def test_memoizes_available_locales
+    I18n.backend.spy_calls = 0
+    assert_equal I18n.available_locales, I18n.available_locales
+    assert_equal 1, I18n.backend.spy_calls
+  end
+
+  def test_resets_available_locales_on_reload!
+    I18n.available_locales
+    I18n.backend.spy_calls = 0
+    I18n.reload!
+    assert_equal I18n.available_locales, I18n.available_locales
+    assert_equal 1, I18n.backend.spy_calls
+  end
+
+  def test_resets_available_locales_on_store_translations
+    I18n.available_locales
+    I18n.backend.spy_calls = 0
+    I18n.backend.store_translations(:copa, :ca => :bana)
+    assert_equal I18n.available_locales, I18n.available_locales
+    assert I18n.available_locales.include?(:copa)
+    assert_equal 1, I18n.backend.spy_calls
+  end
+end

data/vendor/bundle/gems/i18n-0.8.1/test/backend/metadata_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class I18nBackendMetadataTest < I18n::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Metadata
+  end
+
+  def setup
+    super
+    I18n.backend = Backend.new
+    store_translations(:en, :foo => 'Hi %{name}')
+  end
+
+  test "translation strings carry metadata" do
+    translation = I18n.t(:foo, :name => 'David')
+    assert translation.respond_to?(:translation_metadata)
+    assert translation.translation_metadata.is_a?(Hash)
+  end
+
+  test "translate adds the locale to metadata on Strings" do
+    assert_equal :en, I18n.t(:foo, :name => 'David', :locale => :en).translation_metadata[:locale]
+  end
+
+  test "translate adds the key to metadata on Strings" do
+    assert_equal :foo, I18n.t(:foo, :name => 'David').translation_metadata[:key]
+  end
+
+  test "translate adds the default to metadata on Strings" do
+    assert_equal 'bar', I18n.t(:foo, :default => 'bar', :name => '').translation_metadata[:default]
+  end
+
+  test "translation adds the interpolation values to metadata on Strings" do
+    assert_equal({:name => 'David'}, I18n.t(:foo, :name => 'David').translation_metadata[:values])
+  end
+
+  test "interpolation adds the original string to metadata on Strings" do
+    assert_equal('Hi %{name}', I18n.t(:foo, :name => 'David').translation_metadata[:original])
+  end
+
+  test "pluralization adds the count to metadata on Strings" do
+    assert_equal(1, I18n.t(:missing, :count => 1, :default => { :one => 'foo' }).translation_metadata[:count])
+  end
+
+  test "metadata works with frozen values" do
+    assert_equal(1, I18n.t(:missing, :count => 1, :default => 'foo'.freeze).translation_metadata[:count])
+  end
+end
+

data/vendor/bundle/gems/i18n-0.8.1/test/backend/pluralization_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class I18nBackendPluralizationTest < I18n::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Pluralization
+    include I18n::Backend::Fallbacks
+  end
+
+  def setup
+    super
+    I18n.backend = Backend.new
+    @rule = lambda { |n| n == 1 ? :one : n == 0 || (2..10).include?(n % 100) ? :few : (11..19).include?(n % 100) ? :many : :other }
+    store_translations(:xx, :i18n => { :plural => { :rule => @rule } })
+    @entry = { :zero => 'zero', :one => 'one', :few => 'few', :many => 'many', :other => 'other' }
+  end
+
+  test "pluralization picks a pluralizer from :'i18n.pluralize'" do
+    assert_equal @rule, I18n.backend.send(:pluralizer, :xx)
+  end
+
+  test "pluralization picks :one for 1" do
+    assert_equal 'one', I18n.t(:count => 1, :default => @entry, :locale => :xx)
+  end
+
+  test "pluralization picks :few for 2" do
+    assert_equal 'few', I18n.t(:count => 2, :default => @entry, :locale => :xx)
+  end
+
+  test "pluralization picks :many for 11" do
+    assert_equal 'many', I18n.t(:count => 11, :default => @entry, :locale => :xx)
+  end
+
+  test "pluralization picks zero for 0 if the key is contained in the data" do
+    assert_equal 'zero', I18n.t(:count => 0, :default => @entry, :locale => :xx)
+  end
+
+  test "pluralization picks few for 0 if the key is not contained in the data" do
+    @entry.delete(:zero)
+    assert_equal 'few', I18n.t(:count => 0, :default => @entry, :locale => :xx)
+  end
+
+  test "Fallbacks can pick up rules from fallback locales, too" do
+    assert_equal @rule, I18n.backend.send(:pluralizer, :'xx-XX')
+  end
+end

data/vendor/bundle/gems/i18n-0.8.1/test/backend/simple_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+class I18nBackendSimpleTest < I18n::TestCase
+  def setup
+    super
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.load_path = [locales_dir + '/en.yml']
+  end
+
+  # useful because this way we can use the backend with no key for interpolation/pluralization
+  test "simple backend translate: given nil as a key it still interpolations the default value" do
+    assert_equal "Hi David", I18n.t(nil, :default => "Hi %{name}", :name => "David")
+  end
+
+  # loading translations
+  test "simple load_translations: given an unknown file type it raises I18n::UnknownFileType" do
+    assert_raise(I18n::UnknownFileType) { I18n.backend.load_translations("#{locales_dir}/en.xml") }
+  end
+
+  test "simple load_translations: given a Ruby file name it does not raise anything" do
+    assert_nothing_raised { I18n.backend.load_translations("#{locales_dir}/en.rb") }
+  end
+
+  test "simple load_translations: given no argument, it uses I18n.load_path" do
+    I18n.backend.load_translations
+    assert_equal({ :en => { :foo => { :bar => 'baz' } } }, I18n.backend.send(:translations))
+  end
+
+  test "simple load_rb: loads data from a Ruby file" do
+    data = I18n.backend.send(:load_rb, "#{locales_dir}/en.rb")
+    assert_equal({ :en => { :fuh => { :bah => 'bas' } } }, data)
+  end
+
+  test "simple load_yml: loads data from a YAML file" do
+    data = I18n.backend.send(:load_yml, "#{locales_dir}/en.yml")
+    assert_equal({ 'en' => { 'foo' => { 'bar' => 'baz' } } }, data)
+  end
+
+  test "simple load_translations: loads data from known file formats" do
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend.load_translations("#{locales_dir}/en.rb", "#{locales_dir}/en.yml")
+    expected = { :en => { :fuh => { :bah => "bas" }, :foo => { :bar => "baz" } } }
+    assert_equal expected, translations
+  end
+
+  test "simple load_translations: given file names as array it does not raise anything" do
+    assert_nothing_raised { I18n.backend.load_translations(["#{locales_dir}/en.rb", "#{locales_dir}/en.yml"]) }
+  end
+
+  # storing translations
+
+  test "simple store_translations: stores translations, ... no, really :-)" do
+    store_translations :'en', :foo => 'bar'
+    assert_equal Hash[:'en', {:foo => 'bar'}], translations
+  end
+
+  test "simple store_translations: deep_merges with existing translations" do
+    store_translations :'en', :foo => {:bar => 'bar'}
+    store_translations :'en', :foo => {:baz => 'baz'}
+    assert_equal Hash[:'en', {:foo => {:bar => 'bar', :baz => 'baz'}}], translations
+  end
+
+  test "simple store_translations: converts the given locale to a Symbol" do
+    store_translations 'en', :foo => 'bar'
+    assert_equal Hash[:'en', {:foo => 'bar'}], translations
+  end
+
+  test "simple store_translations: converts keys to Symbols" do
+    store_translations 'en', 'foo' => {'bar' => 'bar', 'baz' => 'baz'}
+    assert_equal Hash[:'en', {:foo => {:bar => 'bar', :baz => 'baz'}}], translations
+  end
+
+  # reloading translations
+
+  test "simple reload_translations: unloads translations" do
+    I18n.backend.reload!
+    assert_nil translations
+  end
+
+  test "simple reload_translations: uninitializes the backend" do
+    I18n.backend.reload!
+    assert_equal false, I18n.backend.initialized?
+  end
+end

data/vendor/bundle/gems/i18n-0.8.1/test/backend/transliterator_test.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+require 'test_helper'
+
+class I18nBackendTransliterator < I18n::TestCase
+  def setup
+    super
+    I18n.backend = I18n::Backend::Simple.new
+    @proc = lambda { |n| n.upcase }
+    @hash = { "ü" => "ue", "ö" => "oe", "a" => "a" }
+    @transliterator = I18n::Backend::Transliterator.get
+  end
+
+  test "transliteration rule can be a proc" do
+    store_translations(:xx, :i18n => {:transliterate => {:rule => @proc}})
+    assert_equal "HELLO", I18n.backend.transliterate(:xx, "hello")
+  end
+
+  test "transliteration rule can be a hash" do
+    store_translations(:xx, :i18n => {:transliterate => {:rule => @hash}})
+    assert_equal "ue", I18n.backend.transliterate(:xx, "ü")
+  end
+
+  test "transliteration rule must be a proc or hash" do
+    store_translations(:xx, :i18n => {:transliterate => {:rule => ""}})
+    assert_raise I18n::ArgumentError do
+      I18n.backend.transliterate(:xx, "ü")
+    end
+  end
+
+  test "transliterator defaults to latin => ascii when no rule is given" do
+    assert_equal "AEroskobing", I18n.backend.transliterate(:xx, "Ærøskøbing")
+  end
+
+  test "default transliterator should not modify ascii characters" do
+    (0..127).each do |byte|
+      char = [byte].pack("U")
+      assert_equal char, @transliterator.transliterate(char)
+    end
+  end
+
+  test "default transliterator correctly transliterates latin characters" do
+    # create string with range of Unicode's western characters with
+    # diacritics, excluding the division and multiplication signs which for
+    # some reason or other are floating in the middle of all the letters.
+    string = (0xC0..0x17E).to_a.reject {|c| [0xD7, 0xF7].include? c}.pack("U*")
+    string.split(//) do |char|
+      assert_match %r{^[a-zA-Z']*$}, @transliterator.transliterate(string)
+    end
+  end
+
+  test "should replace non-ASCII chars not in map with a replacement char" do
+    assert_equal "abc?", @transliterator.transliterate("abcſ")
+  end
+
+  test "can replace non-ASCII chars not in map with a custom replacement string" do
+    assert_equal "abc#", @transliterator.transliterate("abcſ", "#")
+  end
+
+  test "default transliterator raises errors for invalid UTF-8" do
+    assert_raise ArgumentError do
+      @transliterator.transliterate("a\x92b")
+    end
+  end
+
+  test "I18n.transliterate should transliterate using a default transliterator" do
+    assert_equal "aeo", I18n.transliterate("áèö")
+  end
+
+  test "I18n.transliterate should transliterate using a locale" do
+    store_translations(:xx, :i18n => {:transliterate => {:rule => @hash}})
+    assert_equal "ue", I18n.transliterate("ü", :locale => :xx)
+  end
+
+  test "default transliterator fails with custom rules with uncomposed input" do
+    char = [117, 776].pack("U*") # "ü" as ASCII "u" plus COMBINING DIAERESIS
+    transliterator = I18n::Backend::Transliterator.get(@hash)
+    assert_not_equal "ue", transliterator.transliterate(char)
+  end
+
+  test "DEFAULT_APPROXIMATIONS is frozen to prevent concurrency issues" do
+    assert I18n::Backend::Transliterator::HashTransliterator::DEFAULT_APPROXIMATIONS.frozen?
+  end
+
+end