twitter_cldr 1.5.0 → 1.6.0

data/spec/collation/trie_with_fallback_spec.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Collation
+
+describe TrieWithFallback do
+
+  let(:fallback) { Trie.new }
+  let(:trie)     { TrieWithFallback.new(fallback) }
+
+  before(:each) { trie.add([1, 2, 3], 'value') }
+
+  describe '#get' do
+    it 'returns result if the key is present' do
+      dont_allow(fallback).get
+      trie.get([1, 2, 3]).should == 'value'
+    end
+
+    it 'resorts to the fallback if the key is not present' do
+      mock(fallback).get([3, 2, 1]) { 'fallback-value' }
+      trie.get([3, 2, 1]).should == 'fallback-value'
+    end
+  end
+
+  describe '#find_prefix' do
+    it 'returns result if the key is present' do
+      dont_allow(fallback).find_prefix
+      trie.find_prefix([1, 2, 3, 4]).first(2).should == ['value', 3]
+    end
+
+    it 'resorts to the fallback if the key is not present' do
+      mock(fallback).find_prefix([3, 2, 1]) { 'fallback-result' }
+      trie.find_prefix([3, 2, 1]).should == 'fallback-result'
+    end
+  end
+
+end

data/spec/core_ext/array_spec.rb

@@ -8,9 +8,52 @@ require 'spec_helper'
 include TwitterCldr
 
 describe LocalizedArray do
-  describe "#code_points_to_string" do
-    it "transforms an array of code points into a string" do
-      ["0074", "0077", "0069", "0074", "0074", "0065", "0072"].localize.code_points_to_string.should == "twitter"
+  describe '#code_points_to_string' do
+    it 'transforms an array of code points into a string' do
+      %w[0074 0077 0069 0074 0074 0065 0072].localize.code_points_to_string.should == 'twitter'
     end
   end
+
+  describe 'strings sorting' do
+    let(:locale)    { :da }
+    let(:array)     { %w[bca aaa abc] }
+    let(:sorted)    { %w[aaa abc bca] }
+    let(:localized) { array.localize(locale) }
+
+    before(:each) { mock(TwitterCldr::Collation::Collator).new(locale) { FakeCollator.new } }
+
+    describe '#sort' do
+      it 'returns a new LocalizedArray' do
+        localized.sort.should be_instance_of(LocalizedArray)
+      end
+
+      it 'does not change the original array' do
+        lambda { localized.sort }.should_not change { localized.base_obj }
+      end
+
+      it 'sorts strings in the array with corresponding collator' do
+        localized.sort.base_obj.should == sorted
+      end
+    end
+
+    describe '#sort!' do
+      it 'returns self' do
+        localized.sort!.object_id.should == localized.object_id
+      end
+
+      it 'sorts the array in-place' do
+        localized.sort!.base_obj.should == sorted
+      end
+    end
+  end
+end
+
+class FakeCollator
+  def sort(array)
+    array.sort
+  end
+
+  def sort!(array)
+    array.sort!
+  end
 end

data/spec/core_ext/calendars/date_spec.rb

@@ -47,41 +47,41 @@ describe Date do
     it "should ago-ify from now when no base_time given" do
       stub(Time).now { Time.gm(2010,8,6,12,12,30) }
       loc_date = date.localize(:ko)
-      loc_date.ago(:unit => :hour).should == "756시간 전"
+      loc_date.ago.to_s(:unit => :hour).should match_normalized("756시간 전")
     end
 
     it "should ago-ify with appropriate unit when no unit given" do
       loc_date = date.localize(:en)
-      loc_date.ago(:base_time => base_time).should == "1 month ago"
-      loc_date.ago(:base_time => Time.gm(2010,12,6,12,12,30)).should == "5 months ago"
-      loc_date.ago(:base_time => Time.gm(2010,7,7,12,12,30)).should == "1 day ago"
-      loc_date.ago(:base_time => Time.gm(2010,7,6,12,12,30)).should == "12 hours ago"
-      loc_date.ago(:base_time => Time.gm(2010,7,6,0,39,0)).should == "39 minutes ago"
+      loc_date.ago(:base_time => base_time).to_s.should match_normalized("1 month ago")
+      loc_date.ago(:base_time => Time.gm(2010,12,6,12,12,30)).to_s.should match_normalized("5 months ago")
+      loc_date.ago(:base_time => Time.gm(2010,7,7,12,12,30)).to_s.should match_normalized("1 day ago")
+      loc_date.ago(:base_time => Time.gm(2010,7,6,12,12,30)).to_s.should match_normalized("12 hours ago")
+      loc_date.ago(:base_time => Time.gm(2010,7,6,0,39,0)).to_s.should match_normalized("39 minutes ago")
     end
 
     it "should ago-ify with strings regardless of variable's placement or existence" do
       loc_date = date.localize(:ar)
-      loc_date.ago(:base_time => base_time, :unit => :hour).should == "قبل 756 ساعة"
-      loc_date.ago(:base_time => base_time, :unit => :day).should == "قبل 31 يومًا"
-      loc_date.ago(:base_time => base_time, :unit => :month).should == "قبل شهر واحد"
-      loc_date.ago(:base_time => base_time, :unit => :year).should == "قبل 0 سنة"
+      loc_date.ago(:base_time => base_time).to_s(:unit => :hour).should match_normalized("قبل 756 ساعة")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("قبل 31 يومًا")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :month).should match_normalized("قبل شهر واحد")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :year).should match_normalized("قبل 0 سنة")
 
       loc_date = date.localize(:fa)
-      loc_date.ago(:base_time => base_time, :unit => :day).should == "31 روز پیش"
+      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("31 روز پیش")
 
       loc_date = date.localize(:en)
-      loc_date.ago(:base_time => base_time, :unit => :day).should == "31 days ago"
+      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("31 days ago")
     end
 
     it "should ago-ify a date with a number of different units" do
       date = Date.new(2010,6,6)
       loc_date = date.localize(:de)
-      loc_date.ago(:base_time => base_time, :unit => :second).should == "Vor 5314350 Sekunden"
-      loc_date.ago(:base_time => base_time, :unit => :minute).should == "Vor 88572 Minuten"
-      loc_date.ago(:base_time => base_time, :unit => :hour).should == "Vor 1476 Stunden"
-      loc_date.ago(:base_time => base_time, :unit => :day).should == "Vor 61 Tagen"
-      loc_date.ago(:base_time => base_time, :unit => :month).should == "Vor 2 Monaten"
-      loc_date.ago(:base_time => base_time, :unit => :year).should == "Vor 0 Jahren"
+      loc_date.ago(:base_time => base_time).to_s(:unit => :second).should match_normalized("Vor 5314350 Sekunden")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :minute).should match_normalized("Vor 88572 Minuten")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :hour).should match_normalized("Vor 1476 Stunden")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("Vor 61 Tagen")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :month).should match_normalized("Vor 2 Monaten")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :year).should match_normalized("Vor 0 Jahren")
     end
 
     it "should return an error if called on a date in the future" do
@@ -97,12 +97,12 @@ describe Date do
     it "should until-ify with a number of different units" do
       date = Date.new(2010,10,10)
       loc_date = date.localize(:de)
-      loc_date.until(:base_time => base_time, :unit => :second).should == "In 5572050 Sekunden"
-      loc_date.until(:base_time => base_time, :unit => :minute).should == "In 92867 Minuten"
-      loc_date.until(:base_time => base_time, :unit => :hour).should == "In 1547 Stunden"
-      loc_date.until(:base_time => base_time, :unit => :day).should == "In 64 Tagen"
-      loc_date.until(:base_time => base_time, :unit => :month).should == "In 2 Monaten"
-      loc_date.until(:base_time => base_time, :unit => :year).should == "In 0 Jahren"
+      loc_date.until(:base_time => base_time).to_s(:unit => :second).should match_normalized("In 5572050 Sekunden")
+      loc_date.until(:base_time => base_time).to_s(:unit => :minute).should match_normalized("In 92867 Minuten")
+      loc_date.until(:base_time => base_time).to_s(:unit => :hour).should match_normalized("In 1547 Stunden")
+      loc_date.until(:base_time => base_time).to_s(:unit => :day).should match_normalized("In 64 Tagen")
+      loc_date.until(:base_time => base_time).to_s(:unit => :month).should match_normalized("In 2 Monaten")
+      loc_date.until(:base_time => base_time).to_s(:unit => :year).should match_normalized("In 0 Jahren")
     end
 
     it "should return an error if called on a date in the past" do

data/spec/core_ext/calendars/datetime_spec.rb

@@ -80,4 +80,11 @@ describe LocalizedDateTime do
       time.base_obj.getgm.strftime("%H:%M:%S").should == "22:05:00"
     end
   end
+
+  describe "#to_timespan" do
+    it "should return a localized timespan with a direction of :none" do
+      ts = DateTime.new(1987, 9, 20, 22, 5).localize.to_timespan
+      ts.formatter.instance_variable_get(:'@direction').should == :none
+    end
+  end
 end

data/spec/core_ext/calendars/time_spec.rb

@@ -64,8 +64,8 @@ describe "#ago" do
     time = Time.now
     base_time = time + 172800
     loc_time = time.localize(:de)
-    loc_time.ago({:base_time => base_time, :unit => :hour}).should == "Vor 48 Stunden"
-    loc_time.ago({:base_time => base_time, :unit => :day}).should == "Vor 2 Tagen"
+    loc_time.ago(:base_time => base_time).to_s(:unit => :hour).should match_normalized("Vor 48 Stunden")
+    loc_time.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("Vor 2 Tagen")
   end
 end
 

data/spec/formatters/calendars/timespan_formatter_spec.rb

@@ -12,27 +12,56 @@ describe TimespanFormatter do
   describe "#format" do
     let(:formatter) { TimespanFormatter.new(:locale => :de) }
 
-    describe "#ago" do
-      it "works for a variety of units" do
-        formatter.format(-3273932, :year).should == 'Vor 0 Jahren'
-        formatter.format(-3273932, :month).should == 'Vor 1 Monat'
-        formatter.format(-3273932, :week).should == 'Vor 5 Wochen'
-        formatter.format(-3273932, :day).should == 'Vor 37 Tagen'
-        formatter.format(-3273932, :hour).should == 'Vor 909 Stunden'
-        formatter.format(-3273932, :minute).should == 'Vor 54565 Minuten'
-        formatter.format(-3273932, :second).should == 'Vor 3273932 Sekunden'
+    context "default type" do
+      describe "non-directional" do
+        it "works for a variety of units" do
+          formatter.format(3273932, :unit => :year, :direction => :none).should match_normalized('0 Jahre')
+          formatter.format(3273932, :unit => :month, :direction => :none).should match_normalized('1 Monat')
+          formatter.format(3273932, :unit => :week, :direction => :none).should match_normalized('5 Wochen')
+          formatter.format(3273932, :unit => :day, :direction => :none).should match_normalized('37 Tage')
+          formatter.format(3273932, :unit => :hour, :direction => :none).should match_normalized('909 Stunden')
+          formatter.format(3273932, :unit => :minute, :direction => :none).should match_normalized('54565 Minuten')
+          formatter.format(3273932, :unit => :second, :direction => :none).should match_normalized('3273932 Sekunden')
+        end
+      end
+
+      describe "#ago" do
+        it "works for a variety of units" do
+          formatter.format(-3273932, :unit => :year).should match_normalized('Vor 0 Jahren')
+          formatter.format(-3273932, :unit => :month).should match_normalized('Vor 1 Monat')
+          formatter.format(-3273932, :unit => :week).should match_normalized('Vor 5 Wochen')
+          formatter.format(-3273932, :unit => :day).should match_normalized('Vor 37 Tagen')
+          formatter.format(-3273932, :unit => :hour).should match_normalized('Vor 909 Stunden')
+          formatter.format(-3273932, :unit => :minute).should match_normalized('Vor 54565 Minuten')
+          formatter.format(-3273932, :unit => :second).should match_normalized('Vor 3273932 Sekunden')
+        end
+      end
+
+      describe "#until" do
+        it "works for a variety of units" do
+          formatter.format(3273932, :unit => :year).should match_normalized('In 0 Jahren')
+          formatter.format(3273932, :unit => :month).should match_normalized('In 1 Monat')
+          formatter.format(3273932, :unit => :week).should match_normalized('In 5 Wochen')
+          formatter.format(3273932, :unit => :day).should match_normalized('In 37 Tagen')
+          formatter.format(3273932, :unit => :hour).should match_normalized('In 909 Stunden')
+          formatter.format(3273932, :unit => :minute).should match_normalized('In 54565 Minuten')
+          formatter.format(3273932, :unit => :second).should match_normalized('In 3273932 Sekunden')
+        end
       end
     end
 
-    describe "#until" do
-      it "works for a variety of units" do
-        formatter.format(3273932, :year).should == 'In 0 Jahren'
-        formatter.format(3273932, :month).should == 'In 1 Monat'
-        formatter.format(3273932, :week).should == 'In 5 Wochen'
-        formatter.format(3273932, :day).should == 'In 37 Tagen'
-        formatter.format(3273932, :hour).should == 'In 909 Stunden'
-        formatter.format(3273932, :minute).should == 'In 54565 Minuten'
-        formatter.format(3273932, :second).should == 'In 3273932 Sekunden'
+    context "abbreviated type" do
+      let(:options) { { :type => :abbreviated } }
+
+      # Note: non-directional timespans are the only ones that support the abbreviated type (i.e. ago and until cannot be abbreviated)
+      describe "non-directional" do
+        it "works for a variety of units" do
+          # year/month/week not supported
+          formatter.format(3273932, options.merge(:unit => :day, :direction => :none)).should match_normalized('37d')
+          formatter.format(3273932, options.merge(:unit => :hour, :direction => :none)).should match_normalized('909h')
+          formatter.format(3273932, options.merge(:unit => :minute, :direction => :none)).should match_normalized('54565m')
+          formatter.format(3273932, options.merge(:unit => :second, :direction => :none)).should match_normalized('3273932s')
+        end
       end
     end
   end

data/spec/formatters/plurals/rules_spec.rb

@@ -12,17 +12,9 @@ describe Rules do
     it "calls eval on the hash that gets returned, lambdas and all" do
       result = Rules.send(:get_resource, :ru)
 
-      [:ru, :i18n, :plural].inject(result) do |current, key|
-        current.should have_key(key)
-        current[key]
-      end
-
-      plural = result[:ru][:i18n][:plural]
-
-      plural.should include(:keys, :rule)
-
-      plural[:keys].size.should == 4
-      plural[:rule].should be_a(Proc)
+      result.should include(:keys, :rule)
+      result[:keys].size.should == 4
+      result[:rule].should be_a(Proc)
     end
   end
 

data/spec/readme_spec.rb

@@ -75,28 +75,28 @@ describe "README" do
   end
 
   it "verifies relative time spans" do
-    (DateTime.now - 1).localize.ago.should == "1 day ago"
-    (DateTime.now - 0.5).localize.ago.should == "12 hours ago"  # (i.e. half a day)
+    (DateTime.now - 1).localize.ago.to_s.should match_normalized("1 day ago")
+    (DateTime.now - 0.5).localize.ago.to_s.should match_normalized("12 hours ago")  # (i.e. half a day)
 
-    (DateTime.now + 1).localize.until.should == "In 1 day"
-    (DateTime.now + 0.5).localize.until.should == "In 12 hours"
+    (DateTime.now + 1).localize.until.to_s.should match_normalized("In 1 day")
+    (DateTime.now + 0.5).localize.until.to_s.should match_normalized("In 12 hours")
 
-    (DateTime.now - 1).localize(:de).ago.should == "Vor 1 Tag"
-    (DateTime.now + 1).localize(:de).until.should == "In 1 Tag"
+    (DateTime.now - 1).localize(:de).ago.to_s.should match_normalized("Vor 1 Tag")
+    (DateTime.now + 1).localize(:de).until.to_s.should match_normalized("In 1 Tag")
 
-    (DateTime.now - 1).localize(:de).ago(:unit => :hour).should == "Vor 24 Stunden"
-    (DateTime.now + 1).localize(:de).until(:unit => :hour).should == "In 24 Stunden"
+    (DateTime.now - 1).localize(:de).ago.to_s(:unit => :hour).should match_normalized("Vor 24 Stunden")
+    (DateTime.now + 1).localize(:de).until.to_s(:unit => :hour).should match_normalized("In 24 Stunden")
 
     # 86400 = 1 day in seconds, 259200 = 3 days in seconds
-    (Time.now + 86400).localize(:de).ago(:unit => :hour, :base_time => (Time.now + 259200)).should == "Vor 48 Stunden"
+    (Time.now + 86400).localize(:de).ago(:base_time => (Time.now + 259200)).to_s(:unit => :hour).should match_normalized("Vor 48 Stunden")
 
-    ts = TwitterCldr::LocalizedTimespan.new(86400, :de)
-    ts.to_s.should == "In 1 Tag"
-    ts.to_s(:hour).should == "In 24 Stunden"
+    ts = TwitterCldr::LocalizedTimespan.new(86400, :locale => :de)
+    ts.to_s.should match_normalized("In 1 Tag")
+    ts.to_s(:unit => :hour).should match_normalized("In 24 Stunden")
 
-    ts = TwitterCldr::LocalizedTimespan.new(-86400, :de)
-    ts.to_s.should == "Vor 1 Tag"
-    ts.to_s(:hour).should == "Vor 24 Stunden"
+    ts = TwitterCldr::LocalizedTimespan.new(-86400, :locale => :de)
+    ts.to_s.should match_normalized("Vor 1 Tag")
+    ts.to_s(:unit => :hour).should match_normalized("Vor 24 Stunden")
   end
 
   it "verifies plural rules" do

data/spec/resources/loader_spec.rb

@@ -0,0 +1,94 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Resources
+
+describe Loader do
+  let(:loader) { Loader.new }
+
+  describe '#get_resource' do
+    let(:resource_path) { 'random/resource.yml' }
+    let(:resource_content) { 'random YAML content' }
+
+    it 'loads the correct YAML file' do
+      stub_resource_file(resource_path, "---\n- 1\n- 2\n")
+      loader.get_resource(:random, :resource).should == [1, 2]
+    end
+
+    it 'symbolizes hash keys' do
+      stub_resource_file(resource_path, "---\na:\n  b: 3\n")
+      loader.get_resource(:random, :resource).should == { :a => { :b => 3 } }
+    end
+
+    it 'loads the resource only once' do
+      mock(loader).load_resource(resource_path).once { resource_content }
+
+      result = loader.get_resource(:random, :resource)
+      result.should == resource_content
+      # second time load_resource is not called but we get the same object as before
+      loader.get_resource(:random, :resource).object_id.should == result.object_id
+    end
+
+    it 'accepts a variable length resource path both in symbols and strings' do
+      stub(loader).load_resource('foo/bar/baz.yml') { 'foo-bar-baz' }
+      loader.get_resource('foo', :bar, 'baz').should == 'foo-bar-baz'
+    end
+
+    it 'raises an exception if resource file is missing' do
+      mock(File).file?(File.join(TwitterCldr::RESOURCES_DIR, 'foo/bar.yml')) { false }
+      lambda { loader.get_resource(:foo, :bar) }.should raise_error(ArgumentError, "Resource 'foo/bar.yml' not found.")
+    end
+
+    context "custom resources" do
+      it "doesn't merge the custom resource if it doesn't exist" do
+        mock(loader).read_resource_file('foo/bar.yml') { "foo: bar" }
+        loader.get_resource(:foo, :bar).should == { :foo => "bar" }
+      end
+
+      it 'merges the given file with its corresponding custom resource if it exists' do
+        mock(loader).read_resource_file('foo/bar.yml') { "foo: bar" }
+        mock(loader).resource_exists?('custom/foo/bar.yml') { true }
+        mock(loader).read_resource_file('custom/foo/bar.yml') { "bar: baz" }
+
+        # make sure load_resource is called with custom = false the second time
+        mock.proxy(loader).load_resource("foo/bar.yml")
+        mock.proxy(loader).load_resource("custom/foo/bar.yml", false)
+
+        loader.get_resource(:foo, :bar).should == { :foo => "bar", :bar => "baz" }
+      end
+    end
+  end
+
+  describe '#get_locale_resource' do
+    it 'loads the correct locale resource file' do
+      stub(loader).get_resource(:locales, :de, :numbers) { 'foo' }
+      loader.get_locale_resource(:de, :numbers).should == 'foo'
+    end
+
+    it 'loads the resource only once' do
+      mock(loader).load_resource('locales/de/numbers.yml').once { 'foo' }
+
+      result = loader.get_locale_resource(:de, :numbers)
+      # second time get_resource is not called but we get the same object as before
+      loader.get_locale_resource(:de, :numbers).object_id.should == result.object_id
+    end
+
+    it 'converts locales' do
+      mock(TwitterCldr).convert_locale('zh-tw') { :'zh-Hant' }
+      mock(loader).get_resource(:locales, :'zh-Hant', :numbers) { 'foo' }
+
+      loader.get_locale_resource('zh-tw', :numbers).should == 'foo'
+    end
+  end
+
+  def stub_resource_file(resource_path, content)
+    file_path = File.join(TwitterCldr::RESOURCES_DIR, resource_path)
+    stub(File).read(file_path) { content }
+    stub(File).file?(file_path) { true }
+  end
+
+end

data/spec/spec_helper.rb

@@ -28,6 +28,12 @@ RSpec.configure do |config|
   end
 end
 
+RSpec::Matchers.define :match_normalized do |expected|
+  match do |actual|
+    expected.localize.normalize(:using => :NFKC).to_s == actual.localize.normalize(:using => :NFKC).to_s
+  end
+end
+
 def check_token_list(got, expected)
   got.size.should == expected.size
   expected.each_with_index do |exp_hash, index|