twitter_cldr 1.9.1 → 2.0.0

data/spec/formatters/calendars/timespan_formatter_spec.rb

@@ -12,15 +12,59 @@ describe TimespanFormatter do
   describe "#format" do
     let(:formatter) { TimespanFormatter.new(:locale => :de) }
 
+    it "approximates timespans accurately if explicity asked to" do
+      options = { :direction => :none, :approximate => true }
+      formatter.format(44, options).should match_normalized("44 Sekunden")
+      formatter.format(45, options).should match_normalized("1 Minute")
+
+      formatter.format(2699, options).should match_normalized("45 Minuten")
+      formatter.format(2700, options).should match_normalized("1 Stunde")
+
+      formatter.format(64799, options).should match_normalized("18 Stunden")
+      formatter.format(64800, options).should match_normalized("1 Tag")
+
+      formatter.format(453599, options).should match_normalized("5 Tage")
+      formatter.format(453600, options).should match_normalized("1 Woche")
+
+      formatter.format(1972307, options).should match_normalized("3 Wochen")
+      formatter.format(1972308, options).should match_normalized("1 Monat")
+
+      formatter.format(23667694, options).should match_normalized("9 Monate")
+      formatter.format(23667695, options).should match_normalized("1 Jahr")
+    end
+
+    it "doesn't approximate timespans by default" do
+      options = { :direction => :none }
+      formatter.format(44, options).should match_normalized("44 Sekunden")
+      formatter.format(45, options).should match_normalized("45 Sekunden")
+
+      formatter.format(2699, options).should match_normalized("45 Minuten")
+      formatter.format(2700, options).should match_normalized("45 Minuten")
+
+      formatter.format(64799, options).should match_normalized("18 Stunden")
+      formatter.format(64800, options).should match_normalized("18 Stunden")
+
+      formatter.format(453599, options).should match_normalized("5 Tage")
+      formatter.format(453600, options).should match_normalized("5 Tage")
+
+      formatter.format(1972307, options).should match_normalized("3 Wochen")
+      formatter.format(1972308, options).should match_normalized("3 Wochen")
+
+      formatter.format(23667694, options).should match_normalized("9 Monate")
+      formatter.format(23667695, options).should match_normalized("9 Monate")
+
+      formatter.format(31556926, options).should match_normalized("1 Jahr")
+    end
+
     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 => :day, :direction => :none).should match_normalized('38 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 => :minute, :direction => :none).should match_normalized('54566 Minuten')
           formatter.format(3273932, :unit => :second, :direction => :none).should match_normalized('3273932 Sekunden')
         end
       end
@@ -30,9 +74,9 @@ describe TimespanFormatter 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 => :day).should match_normalized('Vor 38 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 => :minute).should match_normalized('Vor 54566 Minuten')
           formatter.format(-3273932, :unit => :second).should match_normalized('Vor 3273932 Sekunden')
         end
       end
@@ -42,9 +86,9 @@ describe TimespanFormatter 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 => :day).should match_normalized('In 38 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 => :minute).should match_normalized('In 54566 Minuten')
           formatter.format(3273932, :unit => :second).should match_normalized('In 3273932 Sekunden')
         end
       end
@@ -57,9 +101,9 @@ describe TimespanFormatter do
       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 => :day, :direction => :none)).should match_normalized('38d')
           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 => :minute, :direction => :none)).should match_normalized('54566m')
           formatter.format(3273932, options.merge(:unit => :second, :direction => :none)).should match_normalized('3273932s')
         end
       end

data/spec/formatters/numbers/abbreviated/abbreviated_number_formatter_spec.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Formatters
+
+describe AbbreviatedNumberFormatter do
+  before(:each) do
+    @formatter = AbbreviatedNumberFormatter.new(:locale => :en)
+  end
+
+  describe "#transform_number" do
+    it "chops off the number to the necessary number of sig figs" do
+      @formatter.send(:transform_number, 10 ** 3).should == 1
+      @formatter.send(:transform_number, 10 ** 4).should == 10
+      @formatter.send(:transform_number, 10 ** 5).should == 100
+      @formatter.send(:transform_number, 10 ** 6).should == 1
+      @formatter.send(:transform_number, 10 ** 7).should == 10
+      @formatter.send(:transform_number, 10 ** 8).should == 100
+      @formatter.send(:transform_number, 10 ** 9).should == 1
+      @formatter.send(:transform_number, 10 ** 10).should == 10
+      @formatter.send(:transform_number, 10 ** 11).should == 100
+      @formatter.send(:transform_number, 10 ** 12).should == 1
+      @formatter.send(:transform_number, 10 ** 13).should == 10
+      @formatter.send(:transform_number, 10 ** 14).should == 100
+    end
+
+    it "returns the original number if greater than 10^15" do
+      @formatter.send(:transform_number, 10 ** 15).should == 10 ** 15
+    end
+
+    it "returns the original number if less than 10^3" do
+      @formatter.send(:transform_number, 999).should == 999
+    end
+  end
+
+  describe "#get_key" do
+    it "builds a power-of-ten key based on the number of digits in the input" do
+      (3..15).each { |i| @formatter.send(:get_key, "1337#{"0" * (i - 3)}").should == 10 ** i }
+    end
+  end
+
+  describe "#get_tokens" do
+    before(:each) do
+      stub(@formatter).get_type { :awesome_type }
+    end
+
+    it "gets tokens for a valid number (between 10^3 and 10^15)" do
+      mock(@formatter.tokenizer).tokens({
+        :sign => :positive,
+        :type => :awesome_type,
+        :format => 10 ** 4
+      }) { "I'm just right!" }
+
+      @formatter.get_tokens(12345).should == "I'm just right!"
+    end
+
+    it "returns tokens for decimals if the number is too large" do
+      mock(@formatter.tokenizer).tokens({
+        :sign => :positive,
+        :type => :decimal,
+        :format => nil
+      }) { "I'm too big!" }
+
+      @formatter.get_tokens(1234567891011122).should == "I'm too big!"
+    end
+
+    it "returns tokens for decimals if the number is too small" do
+      mock(@formatter.tokenizer).tokens({
+        :sign => :positive,
+        :type => :decimal,
+        :format => nil
+      }) { "I'm too small!" }
+
+      @formatter.get_tokens(123).should == "I'm too small!"
+    end
+  end
+end

data/spec/formatters/numbers/abbreviated/long_decimal_formatter_spec.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Formatters
+
+describe LongDecimalFormatter do
+  before(:each) do
+    @formatter = LongDecimalFormatter.new(:locale => :en)
+  end
+
+  it "formats valid numbers correctly (from 10^3 - 10^15)" do
+    @formatter.format(10 ** 3).should match_normalized("1 thousand")
+    @formatter.format(10 ** 4).should match_normalized("10 thousand")
+    @formatter.format(10 ** 5).should match_normalized("100 thousand")
+    @formatter.format(10 ** 6).should match_normalized("1 million")
+    @formatter.format(10 ** 7).should match_normalized("10 million")
+    @formatter.format(10 ** 8).should match_normalized("100 million")
+    @formatter.format(10 ** 9).should match_normalized("1 billion")
+    @formatter.format(10 ** 10).should match_normalized("10 billion")
+    @formatter.format(10 ** 11).should match_normalized("100 billion")
+    @formatter.format(10 ** 12).should match_normalized("1 trillion")
+    @formatter.format(10 ** 13).should match_normalized("10 trillion")
+    @formatter.format(10 ** 14).should match_normalized("100 trillion")
+  end
+
+  it "formats the number as if it were a straight decimal if it exceeds 10^15" do
+    @formatter.format(10**15).should == "1,000,000,000,000,000"
+  end
+
+  it "formats the number as if it were a straight decimal if it's less than 1000" do
+    @formatter.format(500).should == "500"
+  end
+end

data/spec/formatters/numbers/abbreviated/short_decimal_formatter_spec.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Formatters
+
+describe ShortDecimalFormatter do
+  before(:each) do
+    @formatter = ShortDecimalFormatter.new(:locale => :en)
+  end
+
+  it "formats valid numbers correctly (from 10^3 - 10^15)" do
+    @formatter.format(10 ** 3).should match_normalized("1K")
+    @formatter.format(10 ** 4).should match_normalized("10K")
+    @formatter.format(10 ** 5).should match_normalized("100K")
+    @formatter.format(10 ** 6).should match_normalized("1M")
+    @formatter.format(10 ** 7).should match_normalized("10M")
+    @formatter.format(10 ** 8).should match_normalized("100M")
+    @formatter.format(10 ** 9).should match_normalized("1B")
+    @formatter.format(10 ** 10).should match_normalized("10B")
+    @formatter.format(10 ** 11).should match_normalized("100B")
+    @formatter.format(10 ** 12).should match_normalized("1T")
+    @formatter.format(10 ** 13).should match_normalized("10T")
+    @formatter.format(10 ** 14).should match_normalized("100T")
+  end
+
+  it "formats the number as if it were a straight decimal if it exceeds 10^15" do
+    @formatter.format(10**15).should == "1,000,000,000,000,000"
+  end
+
+  it "formats the number as if it were a straight decimal if it's less than 1000" do
+    @formatter.format(500).should == "500"
+  end
+end

data/spec/formatters/numbers/currency_formatter_spec.rb

@@ -28,11 +28,20 @@ describe CurrencyFormatter do
     end
 
     it "should use the currency symbol for the corresponding currency code" do
-      @formatter.format(12, :currency => "PEN").should == "S/.12.00"
+      @formatter.format(12, :currency => "THB").should == "฿12.00"
     end
 
     it "overrides the default precision" do
       @formatter.format(12, :precision => 3).should == "$12.000"
     end
+
+    it "should use the currency precision" do
+      @formatter.format(12, :currency => "TND").should == "TND12.000"
+    end
+
+    it "should use the currency rounding" do
+      @formatter.format(12.03, :currency => "CHF").should == "CHF12.05"
+      @formatter.format(12.02, :currency => "CHF").should == "CHF12.00"
+    end
   end
 end

data/spec/localized/localized_date_spec.rb

@@ -25,7 +25,7 @@ describe LocalizedDate do
       loc_date = date.localize(:en)
       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,7,12,12,30)).to_s.should match_normalized("2 days 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
@@ -33,24 +33,24 @@ describe LocalizedDate do
     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).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.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("قبل 32 يومًا")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :month).should match_normalized("قبل 1 من الشهور")
+      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).to_s(:unit => :day).should match_normalized("31 روز پیش")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("32 روز پیش")
 
       loc_date = date.localize(:en)
-      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("31 days ago")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("32 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).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 => :minute).should match_normalized("Vor 88573 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 => :day).should match_normalized("Vor 62 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
@@ -69,8 +69,8 @@ describe LocalizedDate do
       date = Date.new(2010,10,10)
       loc_date = date.localize(:de)
       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 => :minute).should match_normalized("In 92868 Minuten")
+      loc_date.until(:base_time => base_time).to_s(:unit => :hour).should match_normalized("In 1548 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")
@@ -125,7 +125,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.each do |type|
+        (TwitterCldr::Tokenizers::DateTimeTokenizer::VALID_TYPES - [:additional]).each do |type|
           lambda { Date.today.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
         end
       end

data/spec/localized/localized_datetime_spec.rb

@@ -32,7 +32,7 @@ describe LocalizedDateTime do
     it "should stringify with buddhist calendar" do
       # Ensure that buddhist calendar data is present in th locale.
       TwitterCldr.get_locale_resource(:th, :calendars)[:th][:calendars][:buddhist].should_not(
-          be_nil, 'buddhist calendar is missing for :th locale (check resources/locales/th/calendars.yml)'
+        be_nil, 'buddhist calendar is missing for :th locale (check resources/locales/th/calendars.yml)'
       )
 
       #date_time.localize(:th, :calendar_type => :buddhist).to_full_s # It doesn't support era
@@ -71,11 +71,35 @@ describe LocalizedDateTime do
   describe 'formatters' do
     it "don't raise errors for any locale" do
       TwitterCldr.supported_locales.each do |locale|
-        TwitterCldr::Tokenizers::DateTimeTokenizer::VALID_TYPES.each do |type|
-          lambda { DateTime.now.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
+        (TwitterCldr::Tokenizers::DateTimeTokenizer::VALID_TYPES - [:additional]).each do |type|
+          lambda { date_time.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
         end
       end
     end
+
+    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
+        end
+      end
+    end
+  end
+
+  describe "#to_s" do
+    it "uses the default format if no :format is given" do
+      loc_date = date_time.localize
+      mock.proxy(loc_date).to_default_s
+      loc_date.to_s.should == "Sep 20, 1987, 10:05:00 p.m."
+    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
 
 end

data/spec/localized/localized_number_spec.rb

@@ -71,12 +71,12 @@ describe LocalizedNumber do
       let(:number) { LocalizedNumber.new(10, :en) }
 
       it 'should default precision to zero' do
-        mock.proxy(number.formatter).format(number.base_obj, {})
+        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)
+        mock.proxy(number.formatter).format(number.base_obj, :precision => 2, :type => :decimal)
         number.to_s(:precision => 2).should == "10.00"
       end
     end
@@ -85,12 +85,12 @@ 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)
+        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)
+        mock.proxy(number.formatter).format(number.base_obj, :precision => 1, :type => :currency)
         number.to_s(:precision => 1).should == "$10.0"
       end
     end
@@ -99,15 +99,43 @@ 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, {})
+        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)
+        mock.proxy(number.formatter).format(number.base_obj, :precision => 1, :type => :percent)
         number.to_s(:precision => 1).should == "10.0%"
       end
     end
+
+    context 'short decimals' 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
+
+    context 'long decimals' 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
   end
 
   describe '#plural_rule' do