twitter_cldr 1.2.0 → 1.3.0

data/spec/core_ext/string_spec.rb

@@ -110,12 +110,25 @@ describe LocalizedString do
   end
 
   describe "#normalize" do
-    it "returns a normalized instance of LocalizedString" do
+    it "returns a normalized instance of LocalizedString, defaults to NFD" do
+      mock.proxy(TwitterCldr::Normalizers::NFD).normalize("español")
       "español".bytes.to_a.should == [101, 115, 112, 97, 195, 177, 111, 108]
       result = "español".localize.normalize
       result.should be_a(LocalizedString)
       result.to_s.bytes.to_a.should == [101, 115, 112, 97, 110, 204, 131, 111, 108]
     end
+
+    it "returns a normalized instance of LocalizedString using the specified algorithm" do
+      mock.proxy(TwitterCldr::Normalizers::NFKD).normalize("español")
+      "español".bytes.to_a.should == [101, 115, 112, 97, 195, 177, 111, 108]
+      result = "español".localize.normalize(:using => :NFKD)
+      result.should be_a(LocalizedString)
+      result.to_s.bytes.to_a.should == [101, 115, 112, 97, 110, 204, 131, 111, 108]
+    end
+
+    it "raises an ArgumentError if passed an unsupported normalization form" do
+      lambda { "español".localize.normalize(:using => :blarg) }.should raise_error(ArgumentError)
+    end
   end
 
   describe "#code_points" do

data/spec/formatters/numbers/number_formatter_spec.rb

@@ -11,11 +11,11 @@ describe NumberFormatter do
   before(:each) do
     @tokenizer = TwitterCldr::Tokenizers::NumberTokenizer.new(:locale => :sv, :type => :decimal)
 
-    any_instance_of(NumberFormatter) do |formatter|
+    any_instance_of(DecimalFormatter) do |formatter|
       mock(formatter).tokenizer { @tokenizer }
     end
 
-    @formatter = NumberFormatter.new(:locale => :sv)
+    @formatter = DecimalFormatter.new(:locale => :sv)
     @formatter.instance_variable_set("@tokenizer", @tokenizer)
   end
 
@@ -78,7 +78,7 @@ describe NumberFormatter do
       @formatter.format(1337).should == "1 337"
     end
 
-    it "formats an decimal larger than 999.9" do
+    it "formats a decimal larger than 999.9" do
       @formatter.format(1337.37).should == "1 337,37"
     end
   end

data/spec/formatters/plurals/rules_spec.rb

@@ -59,10 +59,10 @@ describe Rules do
       Rules.all_for(:ru).should =~ [:one, :few, :many, :other]
     end
 
-    it "returns an empty array on error" do
+    it "returns nil on error" do
       stub(Rules).get_resource { lambda { raise "Jelly beans" } }
-      Rules.all_for(:en).should == []
-      Rules.all_for(:ru).should == []
+      Rules.all_for(:en).should be_nil
+      Rules.all_for(:ru).should be_nil
     end
   end
 

data/spec/readme_spec.rb

@@ -0,0 +1,190 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+def spaces(str)
+  str.gsub("\xC2\xA0", " ")
+end
+
+describe "README" do
+  it "verifies supported_locales" do
+    sup = TwitterCldr.supported_locales
+    sup.should be_a(Array)
+    sup.first.should be_a(Symbol)
+  end
+
+  it "verifies supported_locale?" do
+    TwitterCldr.supported_locale?(:es).should be_true
+    TwitterCldr.supported_locale?(:xx).should be_false
+  end
+
+  it "verifies number formatting" do
+    nbsp = "\xC2\xA0"
+    1337.localize(:es).to_s.should == "1.337"
+    spaces(1337.localize(:es).to_currency.to_s).should == "1.337,00 $"
+    spaces(1337.localize(:es).to_currency.to_s(:currency => "EUR").to_s).should == "1.337,00 €"
+    spaces(1337.localize(:es).to_currency.to_s(:currency => "Peru").to_s).should == "1.337,00 S/."
+    1337.localize(:es).to_percent.to_s.should == "1.337%"
+    1337.localize(:es).to_percent.to_s(:precision => 2).should == "1.337,00%"
+    1337.localize(:es).to_decimal.to_s(:precision => 3).should == "1.337,000"
+
+    num = TwitterCldr::LocalizedNumber.new(1337, :es)
+    spaces(num.to_currency.to_s).should == "1.337,00 $"
+  end
+
+  it "verifies extra currency data" do
+    countries = TwitterCldr::Shared::Currencies.countries
+    countries.should be_a(Array)
+    countries.should include("Lithuania")
+    countries.should include("Philippines")
+
+    currency_codes = TwitterCldr::Shared::Currencies.currency_codes
+    currency_codes.should be_a(Array)
+    currency_codes.should include("LTL")
+    currency_codes.should include("PHP")
+
+    TwitterCldr::Shared::Currencies.for_country("Canada").should == { :currency => "Dollar", :symbol => "$", :code => "CAD" }
+    TwitterCldr::Shared::Currencies.for_code("CAD").should == { :currency => "Dollar", :symbol => "$", :country => "Canada"}
+  end
+
+  it "verifies dates" do
+    date_time = DateTime.new(2011, 12, 12, 21, 44, 57, -8.0 / 24.0)
+    date = date_time.localize.to_date.base_obj
+    time = Time.at(date_time.localize.to_time.base_obj.utc - (8 * 60 * 60))
+
+    date_time.localize(:es).to_full_s.should == "lunes, 12 de diciembre de 2011 21:44:57 UTC -0800"
+    date_time.localize(:es).to_long_s.should == "12 de diciembre de 2011 21:44:57 -08:00"
+    date_time.localize(:es).to_medium_s.should == "12/12/2011 21:44:57"
+    date_time.localize(:es).to_short_s.should == "12/12/11 21:44"
+
+    date.localize(:es).to_full_s.should == "lunes, 12 de diciembre de 2011"
+    date.localize(:es).to_long_s.should == "12 de diciembre de 2011"
+    date.localize(:es).to_medium_s.should == "12/12/2011"
+    date.localize(:es).to_short_s.should == "12/12/11"
+
+    time.localize(:es).to_full_s.should match(/21:44:57 UTC [-+]\d{4}/)
+    time.localize(:es).to_long_s.should == "21:44:57 UTC"
+    time.localize(:es).to_medium_s.should == "21:44:57"
+    time.localize(:es).to_short_s.should == "21:44"
+
+    dt = TwitterCldr::LocalizedDateTime.new(date_time, :es)
+    dt.to_short_s.should == "12/12/11 21:44"
+  end
+
+  it "verifies plural rules" do
+    1.localize(:ru).plural_rule.should == :one
+    2.localize(:ru).plural_rule.should == :few
+    5.localize(:ru).plural_rule.should == :many
+
+    TwitterCldr::Formatters::Plurals::Rules.all.should == [:one, :other]
+    TwitterCldr::Formatters::Plurals::Rules.all_for(:es).should == [:one, :other]
+    TwitterCldr::Formatters::Plurals::Rules.all_for(:ru).should == [:one, :few, :many, :other]
+
+    # get the rule for a number in a specific locale
+    TwitterCldr::Formatters::Plurals::Rules.rule_for(1, :ru).should == :one
+    TwitterCldr::Formatters::Plurals::Rules.rule_for(2, :ru).should == :few
+  end
+
+  describe "plural interpolation" do
+    it "verifies first technique" do
+      replacements = { :horse_count => 3,
+                       :horses => { :one => "is 1 horse",
+                                    :other => "are %{horse_count} horses" } }
+
+      ("there %{horse_count:horses} in the barn".localize % replacements).should == "there are 3 horses in the barn"
+    end
+
+    it "verifies second technique" do
+      str = 'there %<{ "horse_count": { "one": "is one horse", "other": "are %{horse_count} horses" } }> in the barn'
+      (str.localize % { :horse_count => 3 }).should == "there are 3 horses in the barn"
+    end
+
+    it "verifies regular Ruby interpolation works" do
+      ("five euros plus %.3f in tax" % (13.25 * 0.087)).should == "five euros plus 1.153 in tax"
+
+      if RUBY_VERSION >= '1.9.0'
+        ("there are %{count} horses in the barn" % { :count => "5" }).should == "there are 5 horses in the barn"
+      end
+    end
+
+    it "verifies named interpolation parameters" do
+      #"five euros plus %<percent>.3f in %{noun}".localize % { :percent => 13.25 * 0.087, :noun => "tax" }.should == "five euros plus 1.15 in tax"
+    end
+  end
+
+  it "verifies world languages" do
+    :es.localize(:es).as_language_code.should == "español"
+    :ru.localize(:es).as_language_code.should == "ruso"
+    ls = TwitterCldr::LocalizedSymbol.new(:ru, :es)
+    ls.as_language_code.should == "ruso"
+  end
+
+  it "verifies language data" do
+    # get all languages for the default locale
+    all = TwitterCldr::Shared::Languages.all
+    all.should include(:"zh-Hant")
+    all[:'zh-Hant'].should == "Traditional Chinese"
+    all.should include(:vi)
+    all[:vi].should == "Vietnamese"
+
+    # get all languages for a specific locale
+    all_es = TwitterCldr::Shared::Languages.all_for(:es)
+    all_es.should include(:"zh-Hant")
+    all_es[:'zh-Hant'].should == "chino tradicional"
+    all_es.should include(:vi)
+    all_es[:vi].should == "vietnamita"
+
+    # get a language by its code for the default locale
+    TwitterCldr::Shared::Languages.from_code(:'zh-Hant').should == "Traditional Chinese"
+
+    # get a language from its code for a specific locale
+    TwitterCldr::Shared::Languages.from_code_for_locale(:'zh-Hant', :es).should == "chino tradicional"
+
+    # translate a language from one locale to another
+    TwitterCldr::Shared::Languages.translate_language("chino tradicional", :es, :en).should == "Traditional Chinese"
+    TwitterCldr::Shared::Languages.translate_language("Traditional Chinese", :en, :es).should == "chino tradicional"
+  end
+
+  it "verifies code point conversions" do
+    code_point = TwitterCldr::Shared::UnicodeData.for_code_point("1F3E9")
+    code_point.name.should             == "LOVE HOTEL"
+    code_point.bidi_mirrored.should    == "N"
+    code_point.category.should         == "So"
+    code_point.combining_class.should  == "0"
+
+    # Convert characters to code points:
+    TwitterCldr::Utils::CodePoints.from_string("¿").should == ["00BF"]
+
+    # Convert code points to characters:
+    TwitterCldr::Utils::CodePoints.to_string(["00BF"]).should == "¿"
+  end
+
+  it "verifies normalization" do
+    TwitterCldr::Normalizers::NFD.normalize("français").should == TwitterCldr::Utils::CodePoints.to_string(["0066", "0072", "0061", "006E", "0063", "0327", "0061", "0069", "0073"])
+    TwitterCldr::Utils::CodePoints.from_string("español").should == ["0065", "0073", "0070", "0061", "00F1", "006F", "006C"]
+    TwitterCldr::Utils::CodePoints.from_string(TwitterCldr::Normalizers::NFD.normalize("español")).should == ["0065", "0073", "0070", "0061", "006E", "0303", "006F", "006C"]
+
+    "español".localize.code_points.should == ["0065", "0073", "0070", "0061", "00F1", "006F", "006C"]
+    "español".localize.normalize.code_points.should == ["0065", "0073", "0070", "0061", "006E", "0303", "006F", "006C"]
+    "español".localize.normalize(:using => :NFKD).code_points.should == ["0065", "0073", "0070", "0061", "006E", "0303", "006F", "006C"]
+  end
+
+  it "verifies Twitter-specific locale conversion" do
+    TwitterCldr.convert_locale(:'zh-cn').should == :zh
+    TwitterCldr.convert_locale(:zh).should == :zh
+    TwitterCldr.convert_locale(:'zh-tw').should == :'zh-Hant'
+    TwitterCldr.convert_locale(:'zh-Hant').should == :'zh-Hant'
+
+    TwitterCldr.convert_locale(:msa).should == :ms
+    TwitterCldr.convert_locale(:ms).should == :ms
+  end
+
+  it "verifies locale defaults" do
+    TwitterCldr.get_locale.should == :en
+    FastGettext.locale = "ru"
+    TwitterCldr.get_locale.should == :ru
+  end
+end

data/spec/shared/calendar_spec.rb

@@ -0,0 +1,133 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Shared
+
+describe Calendar do
+
+  let(:calendar) { Calendar.new(:de) }
+
+  describe '#initialize' do
+    it 'returns calendar for default locale and type' do
+      stub(TwitterCldr).get_locale { :fr }
+      cal = Calendar.new
+
+      cal.locale.should == :fr
+      cal.calendar_type.should == TwitterCldr::DEFAULT_CALENDAR_TYPE
+    end
+
+    it 'returns calendar for a specific locale' do
+      Calendar.new(:jp).locale.should == :jp
+    end
+
+    it 'uses TwitterCldr.convert_locale' do
+      Calendar.new(:'zh-cn').locale.should == :zh
+    end
+
+    it 'returns calendar of a specific type' do
+      Calendar.new(:th, :buddhist).calendar_type.should == :buddhist
+    end
+
+  end
+
+  describe '#months' do
+    context 'when data is available' do
+      it 'returns months list in a wide names form by default' do
+        calendar.months.should == %w[Januar Februar März April Mai Juni Juli August September Oktober November Dezember]
+      end
+
+      it 'supports wide names form' do
+        calendar.months(:wide).should == %w[Januar Februar März April Mai Juni Juli August September Oktober November Dezember]
+      end
+
+      it 'supports narrow names form' do
+        calendar.months(:narrow).should == %w[J F M A M J J A S O N D]
+      end
+
+      it 'supports abbreviated names form' do
+        calendar.months(:abbreviated).should == %w[Jan Feb Mär Apr Mai Jun Jul Aug Sep Okt Nov Dez]
+      end
+
+      it 'returns nil if invalid names form is passed' do
+        calendar.months(:wat).should == nil
+      end
+    end
+
+    context 'when some data is missing' do
+      it 'returns nil if some names format is missing' do
+        stub(TwitterCldr).get_locale_resource { { :de => { :calendars => { :gregorian => { :months => { :'stand-alone' => {} } } } } } }
+        calendar.months(:wide).should == nil
+      end
+
+      it 'returns nil if calendars data is missing' do
+        stub(TwitterCldr).get_locale_resource { { :de => {} } }
+        calendar.months(:wide).should == nil
+      end
+    end
+  end
+
+  describe '#weekdays' do
+    context 'when data is available' do
+      it 'returns weekdays list in a wide names form by default' do
+        calendar.weekdays.should == {
+            :sun => 'Sonntag',
+            :mon => 'Montag',
+            :tue => 'Dienstag',
+            :wed => 'Mittwoch',
+            :thu => 'Donnerstag',
+            :fri => 'Freitag',
+            :sat => 'Samstag'
+        }
+      end
+
+      it 'supports wide names form' do
+        calendar.weekdays(:wide).should == {
+            :sun => 'Sonntag',
+            :mon => 'Montag',
+            :tue => 'Dienstag',
+            :wed => 'Mittwoch',
+            :thu => 'Donnerstag',
+            :fri => 'Freitag',
+            :sat => 'Samstag'
+        }
+      end
+
+      it 'supports narrow names form' do
+        calendar.weekdays(:narrow).should == { :sun => 'S', :mon => 'M', :tue => 'D', :wed => 'M', :thu => 'D', :fri => 'F', :sat => 'S' }
+      end
+
+      it 'supports abbreviated names form' do
+        calendar.weekdays(:abbreviated).should == {
+            :sun => 'So',
+            :mon => 'Mo',
+            :tue => 'Di',
+            :wed => 'Mi',
+            :thu => 'Do',
+            :fri => 'Fr',
+            :sat => 'Sa'
+        }
+      end
+
+      it 'returns nil if invalid names form is passed' do
+        calendar.weekdays(:wat).should == nil
+      end
+    end
+
+    context 'when some data is missing' do
+      it 'returns nil if some names format is missing' do
+        stub(TwitterCldr).get_locale_resource { { :de => { :calendars => { :gregorian => { :days => { :'stand-alone' => {} } } } } } }
+        calendar.weekdays(:wide).should == nil
+      end
+
+      it 'returns nil if calendars data is missing' do
+        stub(TwitterCldr).get_locale_resource { { :de => {} } }
+        calendar.weekdays(:wide).should == nil
+      end
+    end
+  end
+
+end

data/spec/shared/numbers_spec.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Shared
+
+describe Numbers do
+  describe "#symbols" do
+    let(:symbols) { { :nan => 'NaN', :minus_sign => '-' } }
+
+    it 'returns numerical symbols for default locale' do
+      stub(TwitterCldr).get_locale { :jp }
+      stub(TwitterCldr).get_locale_resource(:jp, :numbers) { { :jp => { :numbers => { :symbols => symbols } } } }
+      Numbers.symbols.should == symbols
+    end
+
+    it 'returns numerical symbols for default locale' do
+      stub(TwitterCldr).get_locale_resource(:np, :numbers) { { :np => { :numbers => { :symbols => symbols } } } }
+      Numbers.symbols(:np).should == symbols
+    end
+
+    it 'converts locale' do
+      stub(TwitterCldr).get_locale_resource(:'zh-Hant', :numbers) { { :'zh-Hant' => { :numbers => { :symbols => symbols } } } }
+      Numbers.symbols('zh-tw').should == symbols
+    end
+
+    it 'returns nil if the resource is missing' do
+      stub(TwitterCldr).get_locale_resource(:nop, :numbers) { nil }
+      Numbers.symbols(:nop).should be_nil
+    end
+  end
+end

data/spec/shared/resources_spec.rb

@@ -8,26 +8,44 @@ require 'spec_helper'
 include TwitterCldr::Shared
 
 describe Resources do
-  before(:each) do
-    @resource = Resources.new
-  end
+  let(:resources) { Resources.new }
+
+  describe '#get_resource' do
+    it 'loads the correct YAML file' do
+      stub(File).read(File.join(TwitterCldr::RESOURCES_DIR, 'shared/currencies.yml')) { "---\n- 1\n- 2\n" }
+      resources.get_resource(:shared, :currencies).should == [1, 2]
+    end
 
-  describe "#resource_for" do
-    it "loads the requested resource from disk only once" do
-      # note that it should convert the string "de" into a symbol
-      mock(@resource).data_for(:de, "racehorse").once { "german racehorse resource" }
+    it 'loads the resource only once' do
+      mock(resources).load_resource('shared/currencies.yml').once { 'foo-bar-baz' }
 
-      # do it twice - the second one shouldn't call data_for
-      @resource.resource_for("de", "racehorse").should == "german racehorse resource"
-      @resource.resource_for("de", "racehorse").should == "german racehorse resource"
+      result = resources.get_resource(:shared, :currencies)
+      # second time load_resource is not called but we get the same object as before
+      resources.get_resource(:shared, :currencies).object_id.should == result.object_id
+    end
+
+    it 'accepts a variable length resource path both in symbols and strings' do
+      stub(resources).load_resource('foo/bar/baz.yml') { 'foo-bar-baz' }
+      resources.get_resource('foo', :bar, 'baz').should == 'foo-bar-baz'
+    end
+
+    it 'raises an exception if resource file is missing' do
+      lambda { resources.get_resource(:foo, :bar) }.should raise_error(ArgumentError, "Resource 'foo/bar.yml' not found.")
     end
   end
 
-  describe "#data_for" do
-    it "loads the correct file for the given locale and resource" do
-      mock(YAML).load("data") { { "key" => "value" } }
-      mock(File).read(File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), "resources", "de", "racehorse.yml")) { "data" }
-      @resource.resource_for("de", "racehorse").should == { :key => "value" }
+  describe '#get_locale_resource' do
+    it 'load the correct locale resource file' do
+      stub(resources).get_resource(:locales, :de, :numbers) { 'foo' }
+      resources.get_locale_resource(:de, :numbers).should == 'foo'
+    end
+
+    it 'converts locales' do
+      mock(TwitterCldr).convert_locale('zh-tw') { :'zh-Hant' }
+      mock(resources).get_resource(:locales, :'zh-Hant', :numbers) { 'foo' }
+
+      resources.get_locale_resource('zh-tw', :numbers).should == 'foo'
     end
   end
+
 end