twitter_cldr 1.7.0 → 1.8.0

data/spec/localized/localized_datetime_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::Localized
+
+describe LocalizedDateTime do
+
+  let(:date_time) { DateTime.new(1987, 9, 20, 22, 5) }
+
+  describe '#initilize' do
+    it 'sets calendar type' do
+      date_time.localize(:th, :calendar_type => :buddhist).calendar_type.should == :buddhist
+    end
+
+    it 'uses default calendar type' do
+      date_time.localize(:en).calendar_type.should == TwitterCldr::DEFAULT_CALENDAR_TYPE
+    end
+  end
+
+  describe "stringify" do
+    it "should stringify with a default calendar" do
+      #date_time.localize(:th, :calendar_type => :buddhist).to_full_s # It doesn't support era
+      date_time.localize(:th).to_long_s
+      date_time.localize(:th).to_medium_s
+      date_time.localize(:th).to_short_s
+    end
+
+    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)'
+      )
+
+      #date_time.localize(:th, :calendar_type => :buddhist).to_full_s # It doesn't support era
+      date_time.localize(:th, :calendar_type => :buddhist).to_long_s
+      date_time.localize(:th, :calendar_type => :buddhist).to_medium_s
+      date_time.localize(:th, :calendar_type => :buddhist).to_short_s
+    end
+  end
+
+  describe "#to_date" do
+    it "should convert to a date" do
+      date_time.localize.to_date.base_obj.strftime("%Y-%m-%d").should == "1987-09-20"
+    end
+
+    it 'forwards calendar type' do
+      date_time.localize(:th, :calendar_type => :buddhist).to_date.calendar_type == :buddhist
+    end
+  end
+
+  describe "#to_time" do
+    it "should convert to a time" do
+      date_time.localize.to_time.base_obj.getgm.strftime("%H:%M:%S").should == "22:05:00"
+    end
+
+    it 'forwards calendar type' do
+      date_time.localize(:th, :calendar_type => :buddhist).to_time.calendar_type == :buddhist
+    end
+  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
+    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.each do |type|
+          lambda { DateTime.now.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
+        end
+      end
+    end
+  end
+
+end

data/spec/{core_ext/numbers → localized}/localized_number_spec.rb

@@ -8,6 +8,7 @@ require 'spec_helper'
 include TwitterCldr
 
 describe LocalizedNumber do
+
   describe '#initialize' do
     let(:decimal)  { LocalizedNumber.new(10, :en) }
     let(:currency) { LocalizedNumber.new(10, :en, :type => :currency) }
@@ -58,7 +59,7 @@ 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::LocalizedNumber).new(42, :fr, :type => type)
+          mock.proxy(TwitterCldr::Localized::LocalizedNumber).new(42, :fr, :type => type)
           percent.send(method)
         end
       end
@@ -123,4 +124,36 @@ describe LocalizedNumber do
       5.localize.plural_rule.should == :other
     end
   end
+
+  describe 'formatters for every locale' do
+    it "makes sure currency formatters for every locale don't raise errors" do
+      TwitterCldr.supported_locales.each do |locale|
+        lambda { 1337.localize(locale).to_currency.to_s }.should_not raise_error
+        lambda { 1337.localize(locale).to_currency.to_s(:precision => 3) }.should_not raise_error
+        lambda { 1337.localize(locale).to_currency.to_s(:precision => 3, :currency => "EUR") }.should_not raise_error
+      end
+    end
+
+    it "makes sure decimal formatters for every locale don't raise errors" do
+      TwitterCldr.supported_locales.each do |locale|
+        lambda { 1337.localize(locale).to_decimal.to_s }.should_not raise_error
+        lambda { 1337.localize(locale).to_decimal.to_s(:precision => 3) }.should_not raise_error
+      end
+    end
+
+    it "makes sure percentage formatters for every locale don't raise errors" do
+      TwitterCldr.supported_locales.each do |locale|
+        lambda { 1337.localize(locale).to_percent.to_s }.should_not raise_error
+        lambda { 1337.localize(locale).to_percent.to_s(:precision => 3) }.should_not raise_error
+      end
+    end
+
+    it "makes sure basic number formatters for every locale don't raise errors" do
+      TwitterCldr.supported_locales.each do |locale|
+        lambda { 1337.localize(locale).to_s }.should_not raise_error
+        lambda { 1337.localize(locale).to_s(:precision => 3) }.should_not raise_error
+      end
+    end
+  end
+
 end

data/spec/localized/localized_object_spec.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Localized
+
+describe LocalizedObject do
+
+  class LocalizedFormatter
+    def initialize(options); end
+  end
+
+  class LocalizedClass < LocalizedObject
+    def formatter_const
+      LocalizedFormatter
+    end
+  end
+
+  describe '#initialize' do
+    let(:base_object) { 'base-object' }
+    let(:locale) { :fr }
+    let(:localized_object) { LocalizedClass.new(base_object, locale) }
+    let(:options) { { :foobar => 'value' } }
+
+    it 'sets base object' do
+      localized_object.base_obj.should == base_object
+    end
+
+    it 'sets locale' do
+      localized_object.locale.should == locale
+    end
+
+    it 'converts locale' do
+      LocalizedClass.new(base_object, :msa).locale.should == :ms
+    end
+
+    it 'falls back to default locale if unsupported locale is passed' 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
+  end
+
+  describe '.localize' do
+    it 'defines #localize method on a class' do
+      some_class = Class.new
+
+      some_class.new.should_not respond_to(:localize)
+      LocalizedClass.localize(some_class)
+      some_class.new.should respond_to(:localize)
+    end
+  end
+
+  describe '#localize' do
+    let(:locale)  { :ru }
+    let(:options) { { :option => 'value' } }
+
+    let(:localizable_object) do
+      some_class = Class.new
+      LocalizedClass.localize(some_class)
+      some_class.new
+    end
+
+    it 'returns localized object' do
+      localizable_object.localize.should be_a(LocalizedClass)
+    end
+
+    it 'accepts locale and options and pass them to the localized class constructor' do
+      mock(LocalizedClass).new(localizable_object, locale, options)
+      localizable_object.localize(locale, options)
+    end
+
+    it 'uses default locale and empty options hash by default' do
+      mock(LocalizedClass).new(localizable_object, TwitterCldr.get_locale, {})
+      localizable_object.localize
+    end
+  end
+
+end

data/spec/{core_ext/string_spec.rb → localized/localized_string_spec.rb}

@@ -5,26 +5,7 @@
 
 require 'spec_helper'
 
-include TwitterCldr
-
-describe String do
-
-  describe '#localize' do
-    it 'returns localized string object' do
-      'foo'.localize.should be_a(LocalizedString)
-    end
-
-    it "uses default locale if it's not explicitly specified" do
-      mock(TwitterCldr).get_locale { :ja }
-      'foo'.localize.locale.should == :ja
-    end
-
-    it 'uses provided locale if there is one' do
-      'foo'.localize(:ru).locale.should == :ru
-    end
-  end
-
-end
+include TwitterCldr::Localized
 
 describe LocalizedString do
   describe '#%' do
@@ -110,24 +91,26 @@ describe LocalizedString do
   end
 
   describe "#normalize" do
-    it "returns a normalized instance of LocalizedString, defaults to NFD" do
-      mock.proxy(TwitterCldr::Normalization::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]
+    let(:string) { 'string' }
+    let(:normalized_string) { 'normalized' }
+    let(:localized_string) { string.localize }
+
+    it 'returns a LocalizedString' do
+      localized_string.normalize.should be_an_instance_of(LocalizedString)
+    end
+
+    it 'it uses NFD by default' do
+      mock(TwitterCldr::Normalization::NFD).normalize(string) { normalized_string }
+      localized_string.normalize.base_obj.should == normalized_string
     end
 
-    it "returns a normalized instance of LocalizedString using the specified algorithm" do
-      mock.proxy(TwitterCldr::Normalization::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]
+    it "uses specified algorithm if there is any" do
+      mock(TwitterCldr::Normalization::NFKD).normalize(string) { normalized_string }
+      localized_string.normalize(:using => :NFKD).base_obj.should == normalized_string
     end
 
     it "raises an ArgumentError if passed an unsupported normalization form" do
-      lambda { "español".localize.normalize(:using => :blarg) }.should raise_error(ArgumentError)
+      lambda { localized_string.normalize(:using => :blarg) }.should raise_error(ArgumentError)
     end
   end
 

data/spec/{core_ext/symbol_spec.rb → localized/localized_symbol_spec.rb}

@@ -5,9 +5,10 @@
 
 require 'spec_helper'
 
-include TwitterCldr
+include TwitterCldr::Localized
 
 describe LocalizedSymbol do
+
   describe "#as_language_code" do
     it "returns the correct localized language from the symbol" do
       :es.localize.as_language_code.should == "Spanish"
@@ -26,4 +27,5 @@ describe LocalizedSymbol do
       :'zh'.localize.as_language_code.should == "Chinese"
     end
   end
+
 end

data/spec/localized/localized_time_spec.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Localized
+
+describe LocalizedTime do
+  let(:time) { Time.now }
+
+  describe "stringify" do
+    it "should stringify with a default calendar" do
+      #time.localize(:th, :calendar_type => :buddhist).to_full_s # It doesn't support era
+      time.localize(:th).to_long_s
+      time.localize(:th).to_medium_s
+      time.localize(:th).to_short_s
+    end
+
+    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)'
+      )
+
+      #time.localize(:th, :calendar_type => :buddhist).to_full_s # It doesn't support era
+      time.localize(:th, :calendar_type => :buddhist).to_long_s
+      time.localize(:th, :calendar_type => :buddhist).to_medium_s
+      time.localize(:th, :calendar_type => :buddhist).to_short_s
+    end
+  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")
+    end
+  end
+
+  describe "#to_datetime" do
+    it "should combine a date and a time object into a datetime" do
+      date = Date.new(1987, 9, 20)
+      time = Time.local(2000, 5, 12, 22, 5)
+      datetime = time.localize.to_datetime(date)
+      datetime.should be_a(LocalizedDateTime)
+      datetime.base_obj.strftime("%Y-%m-%d %H:%M:%S").should == "1987-09-20 22:05:00"
+    end
+
+    it "should work with an instance of LocalizedDate too" do
+      date = Date.new(1987, 9, 20).localize
+      time = Time.local(2000, 5, 12, 22, 5)
+      datetime = time.localize.to_datetime(date)
+      datetime.should be_a(LocalizedDateTime)
+      datetime.base_obj.strftime("%Y-%m-%d %H:%M:%S").should == "1987-09-20 22:05:00"
+    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.each do |type|
+          lambda { Time.now.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/normalization_spec.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr
+
+describe TwitterCldr::Normalization do
+
+  describe "#normalize" do
+    let(:string) { 'string' }
+    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
+    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
+    end
+
+    it "raises an ArgumentError if passed an unsupported normalizer name" do
+      lambda { Normalization.normalize(string, :using => :blarg) }.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
+    end
+
+    it 'accepts a string' do
+      mock(TwitterCldr::Normalization::NFKD).normalize(string) { normalized_string }
+      Normalization.normalize(string, :using => 'NFKD').should == normalized_string
+    end
+
+  end
+
+end

data/spec/readme_spec.rb

@@ -31,7 +31,7 @@ describe "README" do
     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)
+    num = TwitterCldr::Localized::LocalizedNumber.new(1337, :es)
     spaces(num.to_currency.to_s).should == "1.337,00 $"
   end
 
@@ -70,7 +70,7 @@ describe "README" do
     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 = TwitterCldr::Localized::LocalizedDateTime.new(date_time, :es)
     dt.to_short_s.should == "12/12/11 21:44"
   end
 
@@ -90,11 +90,11 @@ describe "README" do
     # 86400 = 1 day in seconds, 259200 = 3 days in seconds
     (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, :locale => :de)
+    ts = TwitterCldr::Localized::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, :locale => :de)
+    ts = TwitterCldr::Localized::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
@@ -140,10 +140,56 @@ describe "README" do
     end
   end
 
+  it "verifies language code conversion" do
+    TwitterCldr::Shared::LanguageCodes.convert(:es, :from => :bcp_47, :to => :iso_639_2).should == :spa
+
+    expected = [:bcp_47, :iso_639_1, :iso_639_2, :iso_639_3]
+    actual = TwitterCldr::Shared::LanguageCodes.standards_for(:es, :bcp_47)
+    expected.size.should == actual.size
+    actual.each { |standard| expected.should include(standard) }
+
+    expected = [:bcp_47, :iso_639_1, :iso_639_2, :iso_639_3]
+    actual = TwitterCldr::Shared::LanguageCodes.standards_for_language(:Spanish)
+    expected.size.should == actual.size
+    actual.each { |standard| expected.should include(standard) }
+
+    TwitterCldr::Shared::LanguageCodes.languages.should include(:Spanish)
+
+    TwitterCldr::Shared::LanguageCodes.valid_standard?(:iso_639_1).should be_true
+    TwitterCldr::Shared::LanguageCodes.valid_standard?(:blarg).should be_false
+
+    TwitterCldr::Shared::LanguageCodes.valid_code?(:es, :bcp_47).should be_true
+    TwitterCldr::Shared::LanguageCodes.valid_code?(:es, :iso_639_2).should be_false
+
+    TwitterCldr::Shared::LanguageCodes.from_language(:Spanish, :iso_639_2).should == :spa
+
+    TwitterCldr::Shared::LanguageCodes.to_language(:spa, :iso_639_2).should == "Spanish"
+  end
+
+  it "verifies postal code validations" do
+    TwitterCldr::Shared::PostalCodes.valid?(:us, "94103").should be_true
+    TwitterCldr::Shared::PostalCodes.valid?(:us, "9410").should be_false
+    TwitterCldr::Shared::PostalCodes.valid?(:gb, "BS98 1TL").should be_true
+    TwitterCldr::Shared::PostalCodes.valid?(:se, "280 12").should be_true
+    TwitterCldr::Shared::PostalCodes.valid?(:ca, "V3H 1Z7").should be_true
+
+    TwitterCldr::Shared::PostalCodes.territories.should include(:gb)
+
+    TwitterCldr::Shared::PostalCodes.regex_for_territory(:us).should == /\d{5}([ \-]\d{4})?/
+  end
+
+  it "verifies phone codes" do
+    TwitterCldr::Shared::PhoneCodes.code_for_territory(:us).should == "1"
+    TwitterCldr::Shared::PhoneCodes.code_for_territory(:pe).should == "51"
+    TwitterCldr::Shared::PhoneCodes.code_for_territory(:eg).should == "20"
+    TwitterCldr::Shared::PhoneCodes.code_for_territory(:dk).should == "45"
+    TwitterCldr::Shared::PhoneCodes.territories.should include(:pe)
+  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 = TwitterCldr::Localized::LocalizedSymbol.new(:ru, :es)
     ls.as_language_code.should == "ruso"
   end