twitter_cldr 1.9.1 → 2.0.0

data/spec/localized/localized_time_spec.rb

@@ -61,7 +61,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.each do |type|
+        (TwitterCldr::Tokenizers::DateTimeTokenizer::VALID_TYPES - [:additional]).each do |type|
           lambda { Time.now.localize(locale).send(:"to_#{type}_s") }.should_not raise_error
         end
       end

data/spec/readme_spec.rb

@@ -26,7 +26,7 @@ describe "README" do
     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/."
+    spaces(1337.localize(:es).to_currency.to_s(:currency => "Peru").to_s).should == "1.337,00 PEN"
     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"
@@ -46,8 +46,16 @@ describe "README" do
     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"}
+    TwitterCldr::Shared::Currencies.for_country("Canada").should == { :currency => :CAD, :symbol => "CA$", :name => "Canadian dollar"}
+    TwitterCldr::Shared::Currencies.for_code("CAD").should == { :currency => :CAD, :symbol => "CA$", :name => "Canadian dollar"}
+  end
+
+  it "verifies short and long decimals" do
+    2337.localize.to_short_decimal.to_s.should == "2K"
+    1337123.localize.to_short_decimal.to_s.should == "1M"
+
+    2337.localize.to_long_decimal.to_s.should == "2 thousand"
+    1337123.localize.to_long_decimal.to_s.should == "1 million"
   end
 
   it "verifies dates" do
@@ -74,6 +82,13 @@ describe "README" do
     dt.to_short_s.should == "12/12/11 21:44"
   end
 
+  it "verifies additional date formats" do
+    date_time = DateTime.new(2011, 12, 12, 21, 44, 57, -8.0 / 24.0)
+    TwitterCldr::Formatters::DateTimeFormatter.additional_formats_for(:ja).should be_a(Array)
+    date_time.localize(:ja).to_s.should == "2011/12/12 21:44:57"
+    date_time.localize(:ja).to_s(:format => "EEEEd").should == "12日月曜日"
+  end
+
   it "verifies relative time spans" do
     (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)
@@ -99,6 +114,12 @@ describe "README" do
     ts.to_s(:unit => :hour).should match_normalized("Vor 24 Stunden")
   end
 
+  it "verifies approximate timespans" do
+    TwitterCldr::Localized::LocalizedTimespan.new(44).to_s(:approximate => true).should == "In 44 seconds"
+    TwitterCldr::Localized::LocalizedTimespan.new(45).to_s(:approximate => true).should == "In 1 minute"
+    TwitterCldr::Localized::LocalizedTimespan.new(52).to_s(:approximate => true).should == "In 1 minute"
+  end
+
   it "verifies plural rules" do
     1.localize(:ru).plural_rule.should == :one
     2.localize(:ru).plural_rule.should == :few

data/spec/shared/currencies_spec.rb

@@ -24,7 +24,7 @@ describe Currencies do
     it "should list all supported country codes" do
       codes = Currencies.currency_codes
 
-      codes.size.should == 112
+      codes.size.should == 296
       codes.should include(*TEST_CODES)
     end
   end
@@ -34,11 +34,10 @@ describe Currencies do
       data = Currencies.for_country("Peru")
 
       data.should be_a(Hash)
-      data.should_not include(:country)
       data.should include(
-        :code     => "PEN",
-        :currency => "Nuevo Sol",
-        :symbol   => "S/."
+        :currency => :PEN,
+        :name => "Peruvian nuevo sol",
+        :symbol   => nil
       )
     end
   end
@@ -48,11 +47,10 @@ describe Currencies do
       data = Currencies.for_code("PEN")
 
       data.should be_a(Hash)
-      data.should_not include(:code)
       data.should include(
-          :country  => "Peru",
-          :currency => "Nuevo Sol",
-          :symbol   => "S/."
+        :name => "Peruvian nuevo sol",
+        :currency => :PEN,
+        :symbol => nil
       )
     end
   end

data/spec/spec_helper.rb

@@ -4,8 +4,15 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 
 require 'rspec'
+require 'rspec/autorun' # somehow makes rcov work with rspec
 require 'twitter_cldr'
 
+if ENV['SCOV']
+  require 'simplecov'
+  SimpleCov.start
+  puts 'Running simplecov'
+end
+
 class FastGettext
   class << self
     @@locale = :en

data/spec/tokenizers/base_spec.rb

@@ -15,7 +15,7 @@ module TwitterCldr
   end
 end
 
-describe Base do
+describe TwitterCldr::Tokenizers::Base do
   before(:each) do
     @base = TwitterCldr::Tokenizers::Base.new  # do NOT do this in production - must use subclass
   end
@@ -86,23 +86,26 @@ describe Base do
 
   describe "#expand_pattern" do
     it "recursively calls expand_pattern if a symbol (keypath) is given" do
+      @base.type = :fake_type
       mock(@base).traverse([:another, :path]) { "found_me" }
       mock(@base).pattern_for("found_me") { "pattern_text" }
-      mock.proxy(@base).expand_pattern("pattern_text", :fake_type)
-      mock.proxy(@base).expand_pattern(:'another.path', :fake_type)
-      @base.send(:expand_pattern, :'another.path', :fake_type).should == [{ :value => "pattern_text", :type => :plaintext }]
+      mock.proxy(@base).expand_pattern("pattern_text")
+      mock.proxy(@base).expand_pattern(:'another.path')
+      @base.send(:expand_pattern, :'another.path').should == [{ :value => "pattern_text", :type => :plaintext }]
     end
 
     it "expands placeholders as necessary" do
       placeholder_obj = Object.new
       mock(placeholder_obj).tokens(:type => :man) { ["token1", "token2"] }
       @base.placeholders = [{ :name => "wallace", :object => placeholder_obj }]
-      @base.send(:expand_pattern, "{{wallace}} rules", :man).should == ["token1", "token2", { :type => :plaintext, :value => " rules" }]
+      @base.type = :man
+      @base.send(:expand_pattern, "{{wallace}} rules").should == ["token1", "token2", { :type => :plaintext, :value => " rules" }]
     end
 
     it "doesn't choke if the placeholder can't be found" do
       @base.placeholders = [{ :name => "gromit", :object => "dog" }]
-      @base.send(:expand_pattern, "{{wallace}} rules", :man).should == [{ :type => :plaintext, :value => " rules" }]
+      @base.type = :man
+      @base.send(:expand_pattern, "{{wallace}} rules").should == [{ :type => :plaintext, :value => " rules" }]
     end
   end
 
@@ -113,34 +116,37 @@ describe Base do
     before(:each) do
       stub(@base).traverse([:fake_key]) { "fake_pattern" }
       stub(@base).pattern_for("fake_pattern") { "fake_expandable_pattern" }
-      stub(@base).expand_pattern("fake_expandable_pattern", "fake_type") { [token1, token2] }
+      stub(@base).expand_pattern("fake_expandable_pattern") { [token1, token2] }
     end
 
     it "caches tokens" do
-      result = @base.send(:tokens_for, [:fake_key], "fake_type")
+      @base.type = "fake_type"
+      result = @base.send(:tokens_for, [:fake_key])
       result[0].value.should == "token1"
       result[1].value.should == "token2"
-      @base.class.send(:class_variable_get, :'@@token_cache')["en|fake_key|fake_type".hash].should == result
+      @base.class.send(:class_variable_get, :'@@token_cache')["en|fake_key|fake_type|nil".hash].should == result
 
-      result_again = @base.send(:tokens_for, [:fake_key], "fake_type")
+      @base.type = "fake_type"
+      result_again = @base.send(:tokens_for, [:fake_key])
       result_again.object_id.should == result.object_id
     end
 
     it "caches tokens per language" do
-      result_en = @base.send(:tokens_for, [:fake_key], "fake_type")
+      @base.type = "fake_type"
+      result_en = @base.send(:tokens_for, [:fake_key])
       result_en[0].value.should == "token1"
       result_en[1].value.should == "token2"
-      @base.class.send(:class_variable_get, :'@@token_cache')["en|fake_key|fake_type".hash].should == result_en
-      result_en2 = @base.send(:tokens_for, [:fake_key], "fake_type")
+      @base.class.send(:class_variable_get, :'@@token_cache')["en|fake_key|fake_type|nil".hash].should == result_en
+      result_en2 = @base.send(:tokens_for, [:fake_key])
       result_en2.object_id.should == result_en.object_id
 
       @base.instance_variable_set(:'@locale', :pt)
-      result_pt = @base.send(:tokens_for, [:fake_key], "fake_type")
+      result_pt = @base.send(:tokens_for, [:fake_key])
       result_pt[0].value.should == "token1"
       result_pt[1].value.should == "token2"
-      @base.class.send(:class_variable_get, :'@@token_cache')["pt|fake_key|fake_type".hash].should == result_pt
+      @base.class.send(:class_variable_get, :'@@token_cache')["pt|fake_key|fake_type|nil".hash].should == result_pt
       result_pt.object_id.should_not == result_en.object_id
-      result_pt2 = @base.send(:tokens_for, [:fake_key], "fake_type")
+      result_pt2 = @base.send(:tokens_for, [:fake_key])
       result_pt2.object_id.should == result_pt.object_id
       result_pt2.object_id.should_not == result_en.object_id
       result_pt2.object_id.should_not == result_en2.object_id
@@ -191,11 +197,21 @@ describe Base do
   # expanded format string into whatever parts are defined by the subclass's token type and token splitter regexes.
   describe "#tokenize_format" do
     it "assigns the right token types to the tokens" do
-      stub(@base).token_splitter_regex { /([abc])/ }
-      stub(@base).token_type_regexes { [{ :type => :a, :regex => /a/ },
-                                        { :type => :b, :regex => /b/ },
-                                        { :type => :c, :regex => /c/ },
-                                        { :type => :plaintext, :regex => // }] }
+      stub(@base).token_splitter_regexes do
+        { :else => /([abc])/ }
+      end
+
+      stub(@base).token_type_regexes do
+        {
+          :else => {
+            :a => { :regex => /a/, :priority => 1 },
+            :b => { :regex => /b/, :priority => 1 },
+            :c => { :regex => /c/, :priority => 1 },
+            :plaintext => { :regex => //, :priority => 2 }
+          }
+        }
+      end
+
       tokens = @base.send(:tokenize_format, "a b c")
       tokens.size.should == 5
 
@@ -206,4 +222,38 @@ describe Base do
       tokens[4].value.should == "c"; tokens[4].type.should == :c
     end
   end
+
+  describe "#token_type_regexes_for" do
+    before(:each) do
+      @base.instance_variable_set(:'@token_type_regexes', {
+        :blarg => "blarg",
+        :else => "otherwise"
+      })
+    end
+
+    it "returns the correct regexes by name" do
+      @base.send(:token_type_regexes_for, :blarg).should == "blarg"
+    end
+
+    it "defaults to the regexes stored at :else if the name given can't be found" do
+      @base.send(:token_type_regexes_for, :foo).should == "otherwise"
+    end
+  end
+
+  describe "#token_splitter_regex_for" do
+    before(:each) do
+      @base.instance_variable_set(:'@token_splitter_regexes', {
+        :blarg => "blarg",
+        :else => "otherwise"
+      })
+    end
+
+    it "returns the correct regexes by name" do
+      @base.send(:token_splitter_regex_for, :blarg).should == "blarg"
+    end
+
+    it "defaults to the regexes stored at :else if the name given can't be found" do
+      @base.send(:token_splitter_regex_for, :foo).should == "otherwise"
+    end
+  end
 end

data/spec/tokenizers/calendars/additional_date_format_selector_spec.rb

@@ -0,0 +1,131 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Tokenizers
+
+describe AdditionalDateFormatSelector do
+  let(:selector) do
+    AdditionalDateFormatSelector.new(
+      TwitterCldr.get_locale_resource(:en, :calendars)[:en][:calendars][:gregorian][:additional_formats]
+    )
+  end
+
+  describe "#position_score" do
+    it "calculates the score based on relative offset from actual position" do
+      goal_entities = selector.send(:separate, "MMMyyd")
+      entities      = selector.send(:separate, "d")
+      selector.send(:position_score, entities, goal_entities).should == 2
+    end
+
+    it "calculates a zero score if all entites are in the same positions" do
+      goal_entities = selector.send(:separate, "MMMyyd")
+      entities      = selector.send(:separate, "MMMyyd")
+      selector.send(:position_score, entities, goal_entities).should == 0
+    end
+  end
+
+  describe "#exist_score" do
+    it "calculates a higher score if an entity doesn't exist" do
+      goal_entities = selector.send(:separate, "MMMd")
+      entities      = selector.send(:separate, "d")
+      selector.send(:exist_score, entities, goal_entities).should == 1
+    end
+
+    it "calculates a zero score if all entities exist" do
+      goal_entities = selector.send(:separate, "MMMyyd")
+      entities      = selector.send(:separate, "dMMMyy")
+      selector.send(:exist_score, entities, goal_entities).should == 0
+    end
+  end
+
+  describe "#count_score" do
+    it "calculates the score based on the difference in the length of each matching entity" do
+      goal_entities = selector.send(:separate, "MMMyyd")
+      entities      = selector.send(:separate, "ddMMy")
+      selector.send(:count_score, entities, goal_entities).should == 3
+    end
+
+    it "calculates a zero score if all entities are the same length" do
+      goal_entities = selector.send(:separate, "MMMyyd")
+      entities      = selector.send(:separate, "d")
+      selector.send(:count_score, entities, goal_entities).should == 0
+    end
+  end
+
+  describe "#score" do
+    it "calculates a cumulative score from position and count" do
+      goal_entities = selector.send(:separate, "MMMyydGG")
+      entities      = selector.send(:separate, "ddMMGGyy")
+      selector.send(:exist_score, entities, goal_entities).should == 0
+      selector.send(:count_score, entities, goal_entities).should == 2
+      selector.send(:position_score, entities, goal_entities).should == 3
+      selector.send(:score, entities, goal_entities).should == 5
+    end
+
+    it "calculates a cumulative score from position, count, and existence (existence weighted by 2)" do
+      goal_entities = selector.send(:separate, "MMMyydGG")
+      entities      = selector.send(:separate, "ddMMyy")
+      selector.send(:exist_score, entities, goal_entities).should == 1
+      selector.send(:count_score, entities, goal_entities).should == 2
+      selector.send(:position_score, entities, goal_entities).should == 1
+      # (exist_score * 2) + count_score + position_score
+      selector.send(:score, entities, goal_entities).should == 5
+    end
+  end
+
+  describe "#rank" do
+    it "returns a score for each available format" do
+      ranked_formats = selector.send(:rank, "MMMd")
+      ranked_formats["MMMd"].should == 0
+      ranked_formats["yMEd"].should == 4
+      ranked_formats["y"].should == 4
+      ranked_formats["EHms"].should == 4
+      ranked_formats["MMM"].should == 2
+    end
+  end
+
+  describe "#find_closest" do
+    it "returns an exact match if it exists" do
+      selector.find_closest("MMMd").should == "MMMd"
+      selector.find_closest("Hms").should == "Hms"
+      selector.find_closest("yQQQQ").should == "yQQQQ"
+    end
+
+    it "returns the next closest match (lowest score) if an exact match can't be found" do
+      selector.find_closest("MMMMd").should == "MMMd"
+      selector.find_closest("mHs").should == "Hms"
+      selector.find_closest("Med").should == "MEd"
+    end
+
+    it "returns nil if an empty pattern is given" do
+      selector.find_closest(nil).should be_nil
+      selector.find_closest("").should be_nil
+      selector.find_closest(" ").should be_nil
+    end
+  end
+
+  describe "#separate" do
+    it "divides a string into entities by runs of equal characters" do
+      selector.send(:separate, "ddMMyy").should == ["dd", "MM", "yy"]
+      selector.send(:separate, "ddMMyyMM").should == ["dd", "MM", "yy", "MM"]
+      selector.send(:separate, "mmMM").should == ["mm", "MM"]
+    end
+  end
+
+  describe "#patterns" do
+    it "returns a list of all available patterns" do
+      patterns = selector.patterns
+      patterns.should be_a(Array)
+      patterns.should include(:MMMd)
+      patterns.should include(:yQQQ)
+      patterns.should include(:yQQQQ)
+      patterns.should include(:EHms)
+      patterns.should include(:d)
+    end
+  end
+
+end

data/spec/tokenizers/calendars/datetime_tokenizer_spec.rb

@@ -8,6 +8,8 @@ require 'spec_helper'
 include TwitterCldr::Tokenizers
 
 describe DateTimeTokenizer do
+  let(:tokenizer) { DateTimeTokenizer.new }
+
   describe "#initialize" do
     it "chooses gregorian as the calendar type if none is specified" do
       DateTimeTokenizer.new.calendar_type.should == :gregorian
@@ -15,7 +17,7 @@ describe DateTimeTokenizer do
     end
 
     it "initializes individual date and time placeholder tokenizers" do
-      placeholders = DateTimeTokenizer.new.placeholders
+      placeholders = tokenizer.placeholders
       placeholders[0][:name].should == :time
       placeholders[0][:object].should be_a(TimeTokenizer)
       placeholders[1][:name].should == :date
@@ -25,7 +27,6 @@ describe DateTimeTokenizer do
 
   describe "#tokens" do
     it "should choose the default date time path if no other type is specified" do
-      tokenizer = DateTimeTokenizer.new
       mock.proxy(tokenizer.paths)[:default]
       tokenizer.tokens
     end
@@ -34,25 +35,25 @@ describe DateTimeTokenizer do
       tokenizer = DateTimeTokenizer.new(:locale => :es)
       got       = tokenizer.tokens(:type => :full)
       expected  = [
-          { :value => "EEEE", :type => :pattern },
-          { :value => ", ", :type => :plaintext },
-          { :value => "d", :type => :pattern },
-          { :value => " ", :type => :plaintext },
-          { :value => "'de'", :type => :plaintext },
-          { :value => " ", :type => :plaintext },
-          { :value => "MMMM", :type => :pattern },
-          { :value => " ", :type => :plaintext },
-          { :value => "'de'", :type => :plaintext },
-          { :value => " ", :type => :plaintext },
-          { :value => "y", :type => :pattern },
-          { :value => " ", :type => :plaintext },
-          { :value => "HH", :type => :pattern },
-          { :value => ":", :type => :plaintext },
-          { :value => "mm", :type => :pattern },
-          { :value => ":", :type => :plaintext },
-          { :value => "ss", :type => :pattern },
-          { :value => " ", :type => :plaintext },
-          { :value => "zzzz", :type => :pattern },
+        { :value => "EEEE", :type => :pattern },
+        { :value => ", ", :type => :plaintext },
+        { :value => "d", :type => :pattern },
+        { :value => " ", :type => :plaintext },
+        { :value => "'de'", :type => :plaintext },
+        { :value => " ", :type => :plaintext },
+        { :value => "MMMM", :type => :pattern },
+        { :value => " ", :type => :plaintext },
+        { :value => "'de'", :type => :plaintext },
+        { :value => " ", :type => :plaintext },
+        { :value => "y", :type => :pattern },
+        { :value => " ", :type => :plaintext },
+        { :value => "HH", :type => :pattern },
+        { :value => ":", :type => :plaintext },
+        { :value => "mm", :type => :pattern },
+        { :value => ":", :type => :plaintext },
+        { :value => "ss", :type => :pattern },
+        { :value => " ", :type => :plaintext },
+        { :value => "zzzz", :type => :pattern }
       ]
       check_token_list(got, expected)
     end
@@ -61,17 +62,16 @@ describe DateTimeTokenizer do
   describe "#mirror_resource" do
     it "should add only the missing keys" do
       from = {
-          :a => 1,
-          :b => { :c => 2, :d => 3 },
-          :e => { :f => 4 }
+        :a => 1,
+        :b => { :c => 2, :d => 3 },
+        :e => { :f => 4 }
       }
 
       to = {
-          :b => { :c => 100 },
-          :e => 101
+        :b => { :c => 100 },
+        :e => 101
       }
 
-      tokenizer = DateTimeTokenizer.new
       tokenizer.send(:mirror_resource, :from => from, :to => to)
 
       to[:a].should == 1
@@ -88,4 +88,31 @@ describe DateTimeTokenizer do
       from[:e][:f].should == 4
     end
   end
+
+  describe "#merge_token_type_regexes" do
+    it "merges the token type regex hash recursively, uniting regexes" do
+      first = {
+        :type1 => { :regex => /a/, :content => /aa/, :priority => 1 },
+        :type2 => { :regex => /b/, :priority => 2 },
+      }
+
+      second = {
+        :type1 => { :regex => /c/, :content => /cc/, :priority => 1 },
+        :type2 => { :regex => /d/, :priority => 2 },
+      }
+
+      tokenizer.send(:merge_token_type_regexes, first, second).should == {
+        :type1 => { :regex => Regexp.union(/a/, /c/), :content => Regexp.union(/aa/, /cc/), :priority => 1 },
+        :type2 => { :regex => Regexp.union(/b/, /d/), :priority => 2 }
+      }
+    end
+  end
+
+  describe "#pattern_for" do
+    it "returns the closest matching pattern if this tokenizer has been set up to handle additional date formats" do
+      tokenizer.instance_variable_set(:'@type', :additional)
+      tokenizer.instance_variable_set(:'@format', "MMMd")
+      tokenizer.send(:pattern_for, { :MMMd => "found me!" }).should == "found me!"
+    end
+  end
 end