twitter_cldr 3.0.0.beta1 → 3.0.0

data/spec/formatters/numbers/rbnf/rbnf_spec.rb

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Formatters::Rbnf
+
+TEST_FILE_DIR = File.join(File.dirname(__FILE__), "locales")
+
+def test_file_for(locale)
+  File.join(TEST_FILE_DIR, locale, "rbnf_test.yml")
+end
+
+failures = {}
+
+describe RbnfFormatter do
+  def allowed_failures
+    @allowed_failures ||= begin
+      YAML.load_file(
+        File.join(File.dirname(__FILE__), "allowed_failures.yml")
+      )
+    end
+  end
+
+  def allowed_failure?(options = {})
+    trail = [:locale, :group, :rule_set]
+    dest = trail.inject(allowed_failures) do |ret, leg|
+      if ret && ret[options[leg]]
+        ret[options[leg]]
+      else
+        ret
+      end
+    end
+
+    if dest
+      dest.include?(options[:number])
+    else
+      false
+    end
+  end
+
+  TwitterCldr.supported_locales.each do |locale|
+    formatter = RbnfFormatter.new(locale)
+    test_data = YAML.load_file(test_file_for(locale.to_s))
+
+    describe locale.localize.as_language_code do
+      formatter.group_names.each do |group_name|
+
+        describe group_name do
+          formatter.rule_set_names_for_group(group_name).each do |rule_set_name|
+
+            describe rule_set_name.gsub("-", " ") do
+
+              # running basic test suite only runs spellout-numbering tests (for speed)
+              it "formats correctly", :slow => rule_set_name != "spellout-numbering" do
+                test_data[group_name][rule_set_name].each_pair do |number, expected|
+                  got = formatter.format(number, {
+                    :rule_group => group_name,
+                    :rule_set => rule_set_name
+                  })
+
+                  if got != expected
+                    opts = {
+                      :locale => locale, :group => group_name,
+                      :rule_set => rule_set_name, :number => number
+                    }
+
+                    unless allowed_failure?(opts)
+                      failures[locale] ||= {}
+                      failures[locale][group_name] ||= {}
+                      failures[locale][group_name][rule_set_name] ||= []
+                      failures[locale][group_name][rule_set_name] << number
+                      got.should == expected
+                    end
+                  else
+                    got.should == expected
+                  end
+
+                end
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+
+  after(:all) do
+    if failures.size > 0
+      puts "\nFailure hash:"
+      puts failures.inspect
+    end
+  end
+
+end

data/spec/formatters/plurals/plural_formatter_spec.rb

@@ -11,11 +11,11 @@ describe PluralFormatter do
 
   describe '#initialize' do
     it 'fetches locale from options hash' do
-      PluralFormatter.new(:locale => :ru).locale.should == :ru
+      PluralFormatter.new(:ru).locale.should == :ru
     end
 
-    it "uses default locale if it's not passed in options hash" do
-      PluralFormatter.new.locale.should == TwitterCldr::DEFAULT_LOCALE
+    it "uses current locale if it's not passed in options hash" do
+      PluralFormatter.new.locale.should == TwitterCldr.locale
     end
   end
 
@@ -198,7 +198,7 @@ describe PluralFormatter do
   describe '#pluralization_rule' do
     it 'delegates pluralization rule fetching to Rules.rule_for method' do
       mock(Plurals::Rules).rule_for(42, :jp) { 'result' }
-      PluralFormatter.new(:locale => :jp).send(:pluralization_rule, 42).should == 'result'
+      PluralFormatter.new(:jp).send(:pluralization_rule, 42).should == 'result'
     end
   end
 

data/spec/formatters/plurals/rules_spec.rb

@@ -13,7 +13,7 @@ describe Rules do
       result = Rules.send(:get_resource, :ru)
 
       result.should include(:keys, :rule)
-      result[:keys].size.should == 4
+      result[:keys].size.should == 3
       result[:rule].should be_a(Proc)
     end
   end
@@ -29,8 +29,8 @@ describe Rules do
     it "returns the correct values for Russian rules" do
       rules = {
           :one  => [1, 101],
-          :few  => [2, 3, 4, 102],
-          :many => ((5..11).to_a + [111])
+          :many => ((5..11).to_a + [111]),
+          :other  => [2, 3, 4, 102]
       }
 
       rules.each do |rule, examples|
@@ -48,7 +48,7 @@ describe Rules do
   describe "#all_for" do
     it "returns a list of all applicable rules for the given locale" do
       Rules.all_for(:en).should =~ [:one, :other]
-      Rules.all_for(:ru).should =~ [:one, :few, :many, :other]
+      Rules.all_for(:ru).should =~ [:one, :many, :other]
     end
 
     it "returns nil on error" do
@@ -61,7 +61,7 @@ describe Rules do
   describe "#all" do
     it "gets rules for the default locale (usually supplied by FastGettext)" do
       mock(TwitterCldr).locale { :ru }
-      Rules.all.should =~ [:one, :few, :many, :other]
+      Rules.all.should =~ [:one, :many, :other]
     end
   end
 end

data/spec/localized/localized_date_spec.rb

@@ -123,7 +123,7 @@ describe LocalizedDate do
   describe 'formatters' do
     it "don't raise errors for any locale" do
       TwitterCldr.supported_locales.each do |locale|
-        (TwitterCldr::Tokenizers::DateTimeTokenizer::VALID_TYPES - [:additional]).each do |type|
+        (LocalizedDate.types - [:additional]).each do |type|
           lambda { DateTime.now.localize(locale).to_date.send(:"to_#{type}_s") }.should_not raise_error
         end
       end

data/spec/localized/localized_datetime_spec.rb

@@ -63,15 +63,15 @@ describe LocalizedDateTime do
   end
 
   describe "#to_timespan" do
-    it "should return a localized timespan with a direction of :none" do
-      date_time.localize.to_timespan.formatter.instance_variable_get(:'@direction').should == :none
+    it "should return a localized timespan" do
+      date_time.localize.to_timespan.should be_a(LocalizedTimespan)
     end
   end
 
   describe 'formatters' do
     it "don't raise errors for any locale" do
       TwitterCldr.supported_locales.each do |locale|
-        (TwitterCldr::Tokenizers::DateTimeTokenizer::VALID_TYPES - [:additional]).each do |type|
+        (TwitterCldr::DataReaders::CalendarDataReader.types - [:additional]).each do |type|
           lambda { date_time.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
         end
       end
@@ -79,10 +79,11 @@ describe LocalizedDateTime do
 
     it "don't raise errors for additional date formats" do
       TwitterCldr.supported_locales.each do |locale|
-        fmt = TwitterCldr::Formatters::DateTimeFormatter.new(:locale => locale)
-        fmt.additional_format_selector.patterns.each do |pattern|
-          lambda { fmt.format(date_time, :type => :additional, :format => pattern.to_s) }.should_not raise_error
-          lambda { date_time.localize(locale).to_s(:format => pattern.to_s) }.should_not raise_error
+        data_reader = CalendarDataReader.new(locale)
+        data_reader.additional_format_selector.patterns.each do |pattern|
+          # puts "#{locale}: #{pattern}"
+          # lambda { date_time.localize(locale).to_additional_s(pattern.to_s) }.should_not raise_error
+          date_time.localize(locale).to_additional_s(pattern.to_s)
         end
       end
     end
@@ -94,12 +95,6 @@ describe LocalizedDateTime do
       mock.proxy(loc_date).to_default_s
       loc_date.to_s.should == "Sep 20, 1987, 10:05:00 PM"
     end
-
-    it "uses the given format instead of the default when specified" do
-      loc_date = date_time.localize
-      mock.proxy(loc_date).to_default_s.never
-      date_time.localize.to_s(:format => "MMMd").should == "Sep 20"
-    end
   end
 
   describe "#with_timezone" do

data/spec/localized/localized_number_spec.rb

@@ -13,29 +13,17 @@ describe LocalizedNumber do
     let(:decimal)  { LocalizedNumber.new(10, :en) }
     let(:currency) { LocalizedNumber.new(10, :en, :type => :currency) }
 
-    it 'uses :decimal type by default' do
-      decimal.type.should == :decimal
-    end
-
-    it 'setups DecimalFormatter by default' do
-      decimal.formatter.should be_an_instance_of(TwitterCldr::Formatters::DecimalFormatter)
+    it 'uses nil type by default (defers decision to data reader)' do
+      decimal.type.should == nil
     end
 
     it 'uses provided type if there is one' do
       currency.type.should == :currency
     end
 
-    it 'setups formatter corresponding to the specified type' do
-      currency.formatter.should be_an_instance_of(TwitterCldr::Formatters::CurrencyFormatter)
-    end
-
-    it 'setups formatter with correct locale' do
-      mock.proxy(TwitterCldr::Formatters::DecimalFormatter).new(:locale => :es)
-      LocalizedNumber.new(10, :es)
-    end
-
-    it 'raises ArguemntError if unsupported type is passed' do
-      lambda { LocalizedNumber.new(10, :en, :type => :foo) }.should raise_error(ArgumentError, 'type foo is not supported')
+    it 'sets up object with correct locale, falls back to default locale' do
+      LocalizedNumber.new(10, :es).locale.should == :es
+      LocalizedNumber.new(10, :blarg).locale.should == TwitterCldr::DEFAULT_LOCALE
     end
   end
 
@@ -43,7 +31,7 @@ describe LocalizedNumber do
     let(:number)   { LocalizedNumber.new(10, :en) }
     let(:currency) { LocalizedNumber.new(10, :en, :type => :currency) }
 
-    LocalizedNumber::TYPES.each do |type|
+    LocalizedNumber.types.each do |type|
       describe "#to_#{type}" do
         let(:method) { "to_#{type}" }
 
@@ -51,7 +39,7 @@ describe LocalizedNumber do
           number.send(method).object_id.should_not == number.object_id
         end
 
-        it 'creates an object of appropriate type, but does not change the type of the original object' do
+        it 'creates an object of the appropriate type, but does not change the type of the original object' do
           new_number = currency.send(method)
           new_number.type.should == type
           currency.type.should == :currency
@@ -59,24 +47,29 @@ describe LocalizedNumber do
 
         it 'creates a new object with the same base object and locale' do
           percent = LocalizedNumber.new(42, :fr, :type => :percent)
-          mock.proxy(TwitterCldr::Localized::LocalizedNumber).new(42, :fr, :type => type)
-          percent.send(method)
+          new_percent = percent.send(method)
+          new_percent.locale.should == :fr
+          new_percent.base_obj.should == 42
         end
       end
     end
   end
 
   describe '#to_s' do
+    it 'raises ArguemntError if unsupported type is passed' do
+      lambda do
+        LocalizedNumber.new(10, :en, :type => :foo).to_s
+      end.should raise_error(ArgumentError, 'Type foo is not supported')
+    end
+
     context 'decimals' do
       let(:number) { LocalizedNumber.new(10, :en) }
 
       it 'should default precision to zero' do
-        mock.proxy(number.formatter).format(number.base_obj, { :type => :decimal })
         number.to_s.should == "10"
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        mock.proxy(number.formatter).format(number.base_obj, :precision => 2, :type => :decimal)
         number.to_s(:precision => 2).should == "10.00"
       end
     end
@@ -85,12 +78,10 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(10, :en, :type => :currency) }
 
       it "should default to a precision of 2" do
-        mock.proxy(number.formatter).format(number.base_obj, :precision => 2, :type => :currency)
         number.to_s(:precision => 2).should == "$10.00"
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        mock.proxy(number.formatter).format(number.base_obj, :precision => 1, :type => :currency)
         number.to_s(:precision => 1).should == "$10.0"
       end
     end
@@ -99,12 +90,10 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(10, :en, :type => :percent) }
 
       it "should default to a precision of 0" do
-        mock.proxy(number.formatter).format(number.base_obj, { :type => :percent })
         number.to_s.should == "10%"
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        mock.proxy(number.formatter).format(number.base_obj, :precision => 1, :type => :percent)
         number.to_s(:precision => 1).should == "10.0%"
       end
     end
@@ -113,12 +102,10 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(1000, :en, :type => :short_decimal) }
 
       it "should default to a precision of 0" do
-        mock.proxy(number.formatter).format(number.base_obj, { :type => :short_decimal })
         number.to_s.should == "1K"
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        mock.proxy(number.formatter).format(number.base_obj, :precision => 1, :type => :short_decimal)
         number.to_s(:precision => 1).should == "1.0K"
       end
     end
@@ -127,12 +114,10 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(1000, :en, :type => :long_decimal) }
 
       it "should default to a precision of 0" do
-        mock.proxy(number.formatter).format(number.base_obj, { :type => :long_decimal })
         number.to_s.should == "1 thousand"
       end
 
       it 'should not overwrite precision when explicitly passed' do
-        mock.proxy(number.formatter).format(number.base_obj, :precision => 1, :type => :long_decimal)
         number.to_s(:precision => 1).should == "1.0 thousand"
       end
     end
@@ -141,7 +126,7 @@ describe LocalizedNumber do
   describe '#plural_rule' do
     it 'returns the appropriate plural rule for the number' do
       1.localize(:ru).plural_rule.should == :one
-      2.localize(:ru).plural_rule.should == :few
+      2.localize(:ru).plural_rule.should == :other
       5.localize(:ru).plural_rule.should == :many
     end
 

data/spec/localized/localized_object_spec.rb

@@ -41,11 +41,6 @@ describe LocalizedObject do
       LocalizedClass.new(base_object, :foobar).locale.should == TwitterCldr::DEFAULT_LOCALE
     end
 
-    it 'passes options (including locale) to formatter' do
-      mock(LocalizedFormatter).new(options.merge(:locale => locale))
-      LocalizedClass.new(base_object, locale, options)
-    end
-
     it "doesn't change original options hash" do
       lambda { LocalizedClass.new(base_object, locale, options) }.should_not change { options }
     end

data/spec/localized/localized_string_spec.rb

@@ -133,12 +133,12 @@ describe LocalizedString do
     end
 
     it 'it uses NFD by default' do
-      mock(TwitterCldr::Normalization::NFD).normalize(string) { normalized_string }
+      mock(Eprun).normalize(string, :nfd) { normalized_string }
       localized_string.normalize.base_obj.should == normalized_string
     end
 
     it "uses specified algorithm if there is any" do
-      mock(TwitterCldr::Normalization::NFKD).normalize(string) { normalized_string }
+      mock(Eprun).normalize(string, :nfkd) { normalized_string }
       localized_string.normalize(:using => :NFKD).base_obj.should == normalized_string
     end
 
@@ -147,6 +147,44 @@ describe LocalizedString do
     end
   end
 
+  describe "#casefold" do
+    it 'returns a LocalizedString' do
+      str = "Weißrussland".localize.casefold
+      str.should be_an_instance_of(LocalizedString)
+      str.to_s.should == "weissrussland"
+    end
+
+    it 'does not pass the t option by default' do
+      "Istanbul".localize.casefold.to_s.should == "istanbul"
+    end
+
+    it 'uses the t option when explicitly given' do
+      "Istanbul".localize.casefold(:t => true).to_s.should == "ıstanbul"
+    end
+
+    it 'uses t by default if the locale is tr (az not supported)' do
+      "Istanbul".localize(:tr).casefold.to_s.should == "ıstanbul"
+    end
+  end
+
+  describe "#each_sentence" do
+    it "returns an enumerator if not passed a block" do
+      "foo bar".localize.each_sentence.should be_a(Enumerator)
+    end
+
+    it "yields sentences as localized strings" do
+      str = "Quick. Brown. Fox.".localize
+
+      str.each_sentence do |sentence|
+        sentence.should be_a(LocalizedString)
+      end
+
+      str.each_sentence.to_a.map(&:to_s).should == [
+        "Quick.", " Brown.", " Fox."
+      ]
+    end
+  end
+
   describe "#code_points" do
     it "returns an array of Unicode code points for the string" do
       "español".localize.code_points.should == [0x65, 0x73, 0x70, 0x61, 0xF1, 0x6F, 0x6C]

data/spec/localized/localized_time_spec.rb

@@ -32,11 +32,8 @@ describe LocalizedTime do
   end
 
   describe "#ago" do
-    it "should ago-ify a time with a number of different units" do
-      base_time = time + 172800
-      loc_time = time.localize(:de)
-      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")
+    it "should return a localized timespan" do
+      time.localize(:de).ago.should be_a(LocalizedTimespan)
     end
   end
 
@@ -61,7 +58,7 @@ describe LocalizedTime do
   describe 'formatters' do
     it "don't raise errors for any locale" do
       TwitterCldr.supported_locales.each do |locale|
-        (TwitterCldr::Tokenizers::DateTimeTokenizer::VALID_TYPES - [:additional]).each do |type|
+        (CalendarDataReader.types - [:additional]).each do |type|
           lambda { Time.now.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
         end
       end

data/spec/localized/localized_timespan_spec.rb

@@ -0,0 +1,144 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Localized
+
+describe LocalizedTimespan do
+  it "should format a numer of seconds in different units" do
+    timespan = LocalizedTimespan.new(-172800, :locale => :de)
+    timespan.to_s(:unit => :hour).should match_normalized("Vor 48 Stunden")
+    timespan.to_s(:unit => :day).should match_normalized("Vor 2 Tagen")
+  end
+
+  it "approximates timespans accurately if explicity asked" do
+    options = {
+      :direction => :none,
+      :approximate => true
+    }
+
+    expected = {
+      44 => "44 Sekunden",
+      45 => "1 Minute",
+      2699 => "45 Minuten",
+      2700 => "1 Stunde",
+      64799 => "18 Stunden",
+      64800 => "1 Tag",
+      453599 => "5 Tage",
+      453600 => "1 Woche",
+      1972307 => "3 Wochen",
+      1972308 => "1 Monat",
+      23667694 => "9 Monate",
+      23667695 => "1 Jahr"
+    }
+
+    expected.each_pair do |seconds, text|
+      timespan = LocalizedTimespan.new(seconds, :locale => :de)
+      timespan.to_s(options).should match_normalized(text)
+    end
+  end
+
+  it "doesn't approximate timespans by default" do
+    options = { :direction => :none }
+    expected = {
+      44 => "44 Sekunden",
+      45 => "45 Sekunden",
+      2699 => "45 Minuten",
+      2700 => "45 Minuten",
+      64799 => "18 Stunden",
+      64800 => "18 Stunden",
+      453599 => "5 Tage",
+      453600 => "5 Tage",
+      1972307 => "3 Wochen",
+      1972308 => "3 Wochen",
+      23667694 => "9 Monate",
+      23667695 => "9 Monate",
+      31556926 => "1 Jahr"
+    }
+
+    expected.each_pair do |seconds, text|
+      timespan = LocalizedTimespan.new(seconds, :locale => :de)
+      timespan.to_s(options).should match_normalized(text)
+    end
+  end
+
+  describe "non-directional" do
+    it "works for a variety of units" do
+      timespan = LocalizedTimespan.new(3273932, :locale => :de)
+      options = { :direction => :none }
+      expected = {
+        :year => '0 Jahre',
+        :month => '1 Monat',
+        :week => '5 Wochen',
+        :day => '38 Tage',
+        :hour => '909 Stunden',
+        :minute => '54566 Minuten',
+        :second => '3273932 Sekunden'
+      }
+
+      expected.each_pair do |unit, text|
+        timespan.to_s(options.merge(:unit => unit)).should match_normalized(text)
+      end
+    end
+  end
+
+  describe "ago" do
+    it "works for a variety of units" do
+      timespan = LocalizedTimespan.new(-3273932, :locale => :de)
+      expected = {  
+        :year => 'Vor 0 Jahren',
+        :month => 'Vor 1 Monat',
+        :week => 'Vor 5 Wochen',
+        :day => 'Vor 38 Tagen',
+        :hour => 'Vor 909 Stunden',
+        :minute => 'Vor 54566 Minuten',
+        :second => 'Vor 3273932 Sekunden'
+      }
+
+      expected.each_pair do |unit, text|
+        timespan.to_s(:unit => unit).should match_normalized(text)
+      end
+    end
+  end
+
+  describe "#until" do
+    it "works for a variety of units" do
+      timespan = LocalizedTimespan.new(3273932, :locale => :de)
+      expected = {
+        :year => 'In 0 Jahren',
+        :month => 'In 1 Monat',
+        :week => 'In 5 Wochen',
+        :day => 'In 38 Tagen',
+        :hour => 'In 909 Stunden',
+        :minute => 'In 54566 Minuten',
+        :second => 'In 3273932 Sekunden'
+      }
+
+      expected.each_pair do |unit, text|
+        timespan.to_s(:unit => unit).should match_normalized(text)
+      end
+    end
+  end
+
+  # 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
+      timespan = LocalizedTimespan.new(3273932)
+      options = { :type => :abbreviated, :direction => :none }
+      expected = {
+        :day => '38d',
+        :hour => '909h',
+        :minute => '54566m',
+        :second => '3273932s'
+      }
+
+      expected.each_pair do |unit, text|
+        timespan.to_s(options.merge(:unit => unit)).should match_normalized(text)
+      end
+    end
+  end
+end

data/spec/normalization_spec.rb

@@ -5,8 +5,6 @@
 
 require 'spec_helper'
 
-include TwitterCldr
-
 describe TwitterCldr::Normalization do
 
   describe "#normalize" do
@@ -14,27 +12,29 @@ describe TwitterCldr::Normalization do
     let(:normalized_string) { 'normalized' }
 
     it 'it uses NFD by default' do
-      mock(TwitterCldr::Normalization::NFD).normalize(string) { normalized_string }
-      Normalization.normalize(string).should == normalized_string
+      mock(Eprun).normalize(string, :nfd) { normalized_string }
+      TwitterCldr::Normalization.normalize(string).should == normalized_string
     end
 
     it "uses specified algorithm if there is any" do
-      mock(TwitterCldr::Normalization::NFKD).normalize(string) { normalized_string }
-      Normalization.normalize(string, :using => :NFKD).should == normalized_string
+      mock(Eprun).normalize(string, :nfkd) { normalized_string }
+      TwitterCldr::Normalization.normalize(string, :using => :nfkd).should == normalized_string
     end
 
     it "raises an ArgumentError if passed an unsupported normalizer name" do
-      lambda { Normalization.normalize(string, :using => :blarg) }.should raise_error(ArgumentError)
+      lambda do
+        TwitterCldr::Normalization.normalize(string, :using => :blarg)
+      end.should raise_error(ArgumentError)
     end
 
-    it 'accepts normalizer name in a lower case' do
-      mock(TwitterCldr::Normalization::NFKD).normalize(string) { normalized_string }
-      Normalization.normalize(string, :using => :nfkd).should == normalized_string
+    it 'accepts normalizer name in upper case' do
+      mock(Eprun).normalize(string, :nfkd) { normalized_string }
+      TwitterCldr::Normalization.normalize(string, :using => :NFKD).should == normalized_string
     end
 
     it 'accepts a string' do
-      mock(TwitterCldr::Normalization::NFKD).normalize(string) { normalized_string }
-      Normalization.normalize(string, :using => 'NFKD').should == normalized_string
+      mock(Eprun).normalize(string, :nfkd) { normalized_string }
+      TwitterCldr::Normalization.normalize(string, :using => 'nfkd').should == normalized_string
     end
 
   end