twitter_cldr 2.0.2 → 2.1.0

data/spec/formatters/numbers/currency_formatter_spec.rb

@@ -24,7 +24,16 @@ describe CurrencyFormatter do
 
     it "should use the specified currency symbol when specified" do
       # S/. is the symbol for the Peruvian Nuevo Sol, just in case you were curious
-      @formatter.format(12, :currency => "S/.").should == "S/.12.00"
+      @formatter.format(12, :symbol => "S/.").should == "S/.12.00"
+    end
+
+    it "should use the currency code as the symbol if the currency code can't be identified" do
+      @formatter.format(12, :currency => "XYZ").should == "XYZ12.00"
+    end
+
+    it "should respect the :use_cldr_symbol option" do
+      @formatter.format(12, :currency => "CAD").should == "$12.00"
+      @formatter.format(12, :currency => "CAD", :use_cldr_symbol => true).should == "CA$12.00"
     end
 
     it "should use the currency symbol for the corresponding currency code" do
@@ -35,7 +44,7 @@ describe CurrencyFormatter do
       @formatter.format(12, :precision => 3).should == "$12.000"
     end
 
-    it "should use the currency precision" do
+    it "should use the currency-specific default precision" do
       @formatter.format(12, :currency => "TND").should == "TND12.000"
     end
 

data/spec/formatters/plurals/rules_spec.rb

@@ -60,7 +60,7 @@ describe Rules do
 
   describe "#all" do
     it "gets rules for the default locale (usually supplied by FastGettext)" do
-      mock(TwitterCldr).get_locale { :ru }
+      mock(TwitterCldr).locale { :ru }
       Rules.all.should =~ [:one, :few, :many, :other]
     end
   end

data/spec/localized/localized_date_spec.rb

@@ -12,66 +12,64 @@ describe LocalizedDate do
   let(:date) { Date.today }
 
   describe "#ago" do
-    let(:date) { Date.new(2010,7,6) }
-    let(:base_time) { Time.gm(2010,8,6,12,12,30) }
+    let(:date) { Date.new(2010, 7, 6) }
+    let(:base_time) { Time.gm(2010, 8, 6, 12, 12, 30) }
 
     it "should ago-ify from now when no base_time given" do
-      stub(Time).now { Time.gm(2010,8,6,12,12,30) }
+      stub(Time).now { Time.gm(2010, 8, 6, 12, 12, 30) }
       loc_date = date.localize(:ko)
-      loc_date.ago.to_s(:unit => :hour).should match_normalized("756시간 전")
+      loc_date.ago.to_s(:unit => :hour).should match_normalized("744시간 전")
     end
 
     it "should ago-ify with appropriate unit when no unit given" 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("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")
+      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")
     end
 
     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("قبل 32 يومًا")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :hour).should match_normalized("قبل 744 ساعة")
+      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("قبل 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("32 روز پیش")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("31 روز پیش")
 
       loc_date = date.localize(:en)
-      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("32 days ago")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :day).should match_normalized("31 days ago")
     end
 
     it "should ago-ify a date with a number of different units" do
-      date = Date.new(2010,6,6)
+      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 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 62 Tagen")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :second).should match_normalized("Vor 5270400 Sekunden")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :minute).should match_normalized("Vor 87840 Minuten")
+      loc_date.ago(:base_time => base_time).to_s(:unit => :hour).should match_normalized("Vor 1464 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 => :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
 
     it "should return an error if called on a date in the future" do
-      date = Date.new(2010,10,10)
+      date = Date.new(2010, 10, 10)
       loc_date = date.localize(:de)
       lambda { loc_date.ago(base_time, :second)}.should raise_error(ArgumentError)
     end
   end
 
   describe "#until" do
-    let(:base_time) { Time.gm(2010,8,6,12,12,30) }
+    let(:base_time) { Time.gm(2010, 8, 6, 12, 12, 30) }
 
     it "should until-ify with a number of different units" do
-      date = Date.new(2010,10,10)
+      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 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 => :second).should match_normalized("In 5616000 Sekunden")
+      loc_date.until(:base_time => base_time).to_s(:unit => :minute).should match_normalized("In 93600 Minuten")
+      loc_date.until(:base_time => base_time).to_s(:unit => :hour).should match_normalized("In 1560 Stunden")
+      loc_date.until(:base_time => base_time).to_s(:unit => :day).should match_normalized("In 65 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")
     end

data/spec/localized/localized_object_spec.rb

@@ -81,7 +81,7 @@ describe LocalizedObject do
     end
 
     it 'uses default locale and empty options hash by default' do
-      mock(LocalizedClass).new(localizable_object, TwitterCldr.get_locale, {})
+      mock(LocalizedClass).new(localizable_object, TwitterCldr.locale, {})
       localizable_object.localize
     end
   end

data/spec/localized/localized_string_spec.rb

@@ -90,6 +90,39 @@ describe LocalizedString do
     end
   end
 
+  describe "#to_f" do
+    it "should correctly parse a number with a thousands separator" do
+      "1,300".localize.to_f.should == 1300.0
+      "1.300".localize(:es).to_f.should == 1300.0
+    end
+
+    it "should correctly parse a number with a decimal separator" do
+      "1.300".localize.to_f.should == 1.3
+      "1,300".localize(:es).to_f.should == 1.3
+    end
+
+    it "should correctly parse a number with a thousands and a decimal separator" do
+      "1,300.05".localize.to_f.should == 1300.05
+      "1.300,05".localize(:es).to_f.should == 1300.05
+    end
+
+    it "should return zero if the string contains no numbers" do
+      "abc".localize.to_f.should == 0.0
+    end
+
+    it "should return only the numbers at the beginning of the string if the string contains any non-numeric characters" do
+      "1abc".localize.to_f.should == 1.0
+      "a1bc".localize.to_f.should == 0.0
+    end
+  end
+
+  describe "#to_i" do
+    it "should chop off the decimal" do
+      "1,300.05".localize.to_i.should == 1300
+      "1.300,05".localize(:es).to_i.should == 1300
+    end
+  end
+
   describe "#normalize" do
     let(:string) { 'string' }
     let(:normalized_string) { 'normalized' }

data/spec/localized/localized_symbol_spec.rb

@@ -12,7 +12,7 @@ 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"
-      FastGettext.locale = :es
+      TwitterCldr.locale = :es
       :es.localize.as_language_code.should == "español"
     end
 

data/spec/normalization/base_spec.rb

@@ -4,6 +4,7 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 
 require 'spec_helper'
+include TwitterCldr::Normalization
 
 describe Base do
   describe "#combining_class_for" do

data/spec/parsers/number_parser_spec.rb

@@ -0,0 +1,189 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+require 'pry'
+require 'pry-nav'
+
+include TwitterCldr::Parsers
+
+describe TwitterCldr::Parsers::NumberParser do
+  let(:separators) { ["\\.", ","] }
+
+  before(:each) do
+    @parser = NumberParser.new(:es)
+  end
+
+  describe "#group_separator" do
+    it "returns the correct group separator" do
+      @parser.send(:group_separator).should == "\\."
+    end
+  end
+
+  describe "#decimal_separator" do
+    it "returns the correct decimal separator" do
+      @parser.send(:decimal_separator).should == ","
+    end
+  end
+
+  describe "#identify" do
+    it "properly identifies a numeric value" do
+      @parser.send(:identify, "7841", *separators).should == { :value => "7841", :type => :numeric }
+    end
+
+    it "properly identifies a decimal separator" do
+      @parser.send(:identify, ",", *separators).should == { :value => ",", :type => :decimal }
+    end
+
+    it "properly identifies a group separator" do
+      @parser.send(:identify, ".", *separators).should == { :value => ".", :type => :group }
+    end
+
+    it "returns nil if the text doesn't match a number or either separators" do
+      @parser.send(:identify, "abc", *separators).should == { :value => "abc", :type => nil }
+    end
+  end
+
+  describe "#tokenize" do
+    it "splits text by numericality and group/decimal separators" do
+      @parser.send(:tokenize, "1,33.00", *separators).should == [
+        { :value => "1",  :type => :numeric },
+        { :value => ",",  :type => :decimal },
+        { :value => "33", :type => :numeric },
+        { :value => ".",  :type => :group },
+        { :value => "00", :type => :numeric }
+      ]
+    end
+
+    it "returns an empty array for a non-numeric string" do
+      @parser.send(:tokenize, "abc", *separators).should be_empty
+    end
+  end
+
+  describe "#separators" do
+    it "returns all separators when strict mode is off" do
+      group, decimal = @parser.send(:separators, false)
+      group.should == '\.,\s'
+      decimal.should == '\.,\s'
+    end
+
+    it "returns only locale-specific separators when strict mode is on" do
+      group, decimal = @parser.send(:separators, true)
+      group.should == '\.'
+      decimal.should == ','
+    end
+  end
+
+  describe "#punct_valid" do
+    it "correctly validates a number with no decimal" do
+      tokens = @parser.send(:tokenize, "1.337", *separators).reject { |t| t[:type] == :numeric }
+      @parser.send(:punct_valid?, tokens).should be_true
+    end
+
+    it "correctly validates a number with a decimal" do
+      tokens = @parser.send(:tokenize, "1.337,00", *separators).reject { |t| t[:type] == :numeric }
+      @parser.send(:punct_valid?, tokens).should be_true
+    end
+
+    it "reports on an invalid number when it has more than one decimal" do
+      tokens = @parser.send(:tokenize, "1,337,00", *separators).reject { |t| t[:type] == :numeric }
+      @parser.send(:punct_valid?, tokens).should be_false
+    end
+  end
+
+  describe "#is_numeric?" do
+    it "returns true if the text is numeric" do
+      NumberParser.is_numeric?("4839", "").should be_true
+      NumberParser.is_numeric?("1", "").should be_true
+    end
+
+    it "returns false if the text is not purely numeric" do
+      NumberParser.is_numeric?("abc", "").should be_false
+      NumberParser.is_numeric?("123abc", "").should be_false
+    end
+
+    it "returns false if the text is blank" do
+      NumberParser.is_numeric?("", "").should be_false
+    end
+
+    it "accepts the given characters as valid numerics" do
+      NumberParser.is_numeric?("a123a", "a").should be_true
+      NumberParser.is_numeric?("1.234,56").should be_true  # default separator chars used here
+    end
+  end
+
+  describe "#valid?" do
+    it "correctly identifies a series of valid cases" do
+      ["5", "5,0", "1.337", "1.337,0", "0,05", ",5", "1.337.000,00"].each do |num|
+        @parser.valid?(num).should be_true
+      end
+    end
+
+    it "correctly identifies a series of invalid cases" do
+      ["12,0,0", "5,", "5."].each do |num|
+        @parser.valid?(num).should be_false
+      end
+    end
+  end
+
+  describe "#parse" do
+    it "correctly parses a series of valid numbers" do
+      cases = {
+        "5" => 5,
+        "5,0" => 5.0,
+        "1.337" => 1337,
+        "1.337,0" => 1337.0,
+        "0,05" => 0.05,
+        ",5" => 0.5,
+        "1.337.000,00" => 1337000.0
+      }
+
+      cases.each do |text, expected|
+        @parser.parse(text).should == expected
+      end
+    end
+
+    it "correctly raises an error when asked to parse invalid numbers" do
+      cases = ["12,0,0", "5,", "5."]
+      cases.each do |text|
+        lambda { @parser.parse(text) }.should raise_error(InvalidNumberError)
+      end
+    end
+
+    context "non-strict" do
+      it "succeeds in parsing even if inexact punctuation is used" do
+        @parser.parse("5 100", :strict => false).should == 5100
+      end
+    end
+  end
+
+  describe "#try_parse" do
+    it "parses correctly with a valid number" do
+      @parser.try_parse("1.234").should == 1234
+    end
+
+    it "parses correctly with a valid number and yields to the given block" do
+      pre_result = nil
+      @parser.try_parse("1.234") do |result|
+        pre_result = result
+        9
+      end.should == 9
+      pre_result.should == 1234
+    end
+
+    it "falls back on the default value if the number is invalid" do
+      @parser.try_parse("5,").should be_nil
+      @parser.try_parse("5,", 0).should == 0
+    end
+
+    it "falls back on the block if the number is invalid" do
+      @parser.try_parse("5,") { |result| 9 }.should == 9
+    end
+
+    it "doesn't catch anything but an InvalidNumberError" do
+      lambda { @parser.try_parse(Object.new) }.should raise_error(NoMethodError)
+    end
+  end
+end

data/spec/readme_spec.rb

@@ -26,7 +26,6 @@ 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 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"
@@ -36,18 +35,17 @@ describe "README" do
   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 => :CAD, :symbol => "CA$", :name => "Canadian dollar"}
-    TwitterCldr::Shared::Currencies.for_code("CAD").should == { :currency => :CAD, :symbol => "CA$", :name => "Canadian dollar"}
+    TwitterCldr::Shared::Currencies.for_code("CAD").should == {
+      :currency => :CAD,
+      :cldr_symbol => "CA$",
+      :symbol => "$",
+      :name => "Canadian dollar",
+      :code_points => [36]
+    }
   end
 
   it "verifies short and long decimals" do
@@ -275,8 +273,9 @@ describe "README" do
   end
 
   it "verifies locale defaults" do
-    TwitterCldr.get_locale.should == :en
+    TwitterCldr.locale.should == :en
+    TwitterCldr.locale = nil
     FastGettext.locale = "ru"
-    TwitterCldr.get_locale.should == :ru
+    TwitterCldr.locale.should == :ru
   end
 end

data/spec/resources/loader_spec.rb

@@ -43,7 +43,7 @@ describe Loader do
       lambda { loader.get_resource(:foo, :bar) }.should raise_error(ArgumentError, "Resource 'foo/bar.yml' not found.")
     end
 
-    context "custom resources" do
+    context 'custom resources' do
       it "doesn't merge the custom resource if it doesn't exist" do
         mock(loader).read_resource_file('foo/bar.yml') { ":foo: bar" }
         loader.get_resource(:foo, :bar).should == { :foo => "bar" }
@@ -85,6 +85,80 @@ describe Loader do
     end
   end
 
+  describe '#resource_loaded' do
+    it 'should return true if the resource is cached, false otherwise' do
+      loader.preload_resources_for_locale(:de, :numbers)
+      loader.resource_loaded?(:locales, :de, :numbers).should be_true
+      loader.resource_loaded?(:locales, :de, :calendars).should be_false
+    end
+  end
+
+  describe '#locale_resource_loaded' do
+    it 'should return true if the locale resource is cached, false otherwise' do
+      loader.preload_resources_for_locale(:de, :numbers)
+      loader.locale_resource_loaded?(:de, :numbers).should be_true
+      loader.locale_resource_loaded?(:de, :calendars).should be_false
+    end
+  end
+
+  describe '#resource_types' do
+    it 'returns the list of available resource types' do
+      types = loader.resource_types
+      types.should be_a(Array)
+      types.should include(:calendars)
+      types.should include(:numbers)
+      types.should include(:units)
+    end
+  end
+
+  describe '#preload_resources_for_locale' do
+    it 'loads potentially multiple resources into the cache' do
+      loader.preload_resources_for_locale(:ar, :calendars, :units)
+      loader.locale_resource_loaded?(:ar, :calendars).should be_true
+      loader.locale_resource_loaded?(:ar, :units).should be_true
+      loader.locale_resource_loaded?(:en, :units).should be_false
+    end
+
+    it 'loads all resources for the locale if the :all resource type is specified' do
+      loader.preload_resources_for_locale(:ar, :all)
+      loader.resource_types.each do |resource_type|
+        loader.locale_resource_loaded?(:ar, resource_type).should be_true
+        loader.locale_resource_loaded?(:en, resource_type).should be_false
+      end
+    end
+  end
+
+  describe '#preload_resource_for_locales' do
+    it 'loads a single resource for potentially multiple locales into the cache' do
+      loader.preload_resource_for_locales(:calendars, :sv, :bn)
+      loader.locale_resource_loaded?(:sv, :calendars).should be_true
+      loader.locale_resource_loaded?(:bn, :calendars).should be_true
+      loader.locale_resource_loaded?(:sv, :units).should be_false
+    end
+  end
+
+  describe '#preload_resources_for_all_locales' do
+    it 'loads potentially multiple resources for all locales' do
+      loader.preload_resources_for_all_locales(:plurals, :lists)
+      TwitterCldr.supported_locales.each do |locale|
+        loader.locale_resource_loaded?(locale, :plurals).should be_true
+        loader.locale_resource_loaded?(locale, :lists).should be_true
+        loader.locale_resource_loaded?(locale, :calendars).should be_false
+      end
+    end
+  end
+
+  describe '#preload_all_resources' do
+    it 'loads all resources for all locales' do
+      loader.preload_all_resources
+      TwitterCldr.supported_locales.each do |locale|
+        loader.resource_types.each do |resource_type|
+          loader.locale_resource_loaded?(locale, resource_type).should be_true
+        end
+      end
+    end
+  end
+
   def stub_resource_file(resource_path, content)
     file_path = File.join(TwitterCldr::RESOURCES_DIR, resource_path)
     stub(File).read(file_path) { content }

data/spec/shared/calendar_spec.rb

@@ -11,9 +11,14 @@ describe Calendar do
 
   let(:calendar) { Calendar.new(:de) }
 
+  before(:each) do
+    # clear cache for each test
+    Calendar.send(:class_variable_set, :@@calendar_cache, {})
+  end
+
   describe '#initialize' do
     it 'returns calendar for default locale and type' do
-      stub(TwitterCldr).get_locale { :fr }
+      stub(TwitterCldr).locale { :fr }
       cal = Calendar.new
 
       cal.locale.should == :fr
@@ -130,4 +135,121 @@ describe Calendar do
     end
   end
 
+  describe '#fields' do
+    it 'returns the list of fields for the locale (eg. weekday, month, etc)' do
+      fields = calendar.fields
+      fields[:hour].should match_normalized("Stunde")
+      fields[:dayperiod].should match_normalized("Tageshälfte")
+      fields[:weekday].should match_normalized("Wochentag")
+
+      fields = Calendar.new(:ja).fields
+      fields[:hour].should match_normalized("時")
+      fields[:dayperiod].should match_normalized("午前/午後")
+      fields[:weekday].should match_normalized("曜日")
+    end
+  end
+
+  describe '#quarters' do
+    it 'returns default quarters' do
+      calendar.quarters.should == {
+        1 => "1. Quartal",
+        2 => "2. Quartal",
+        3 => "3. Quartal",
+        4 => "4. Quartal"
+      }
+    end
+
+    it 'returns quarters with other name forms' do
+      calendar.quarters(:abbreviated).should == {
+        1 => "Q1", 2 => "Q2",
+        3 => "Q3", 4 => "Q4"
+      }
+
+      calendar.quarters(:narrow).should == {
+        1 => 1, 2 => 2,
+        3 => 3, 4 => 4
+      }
+    end
+  end
+
+  describe '#periods' do
+    it 'returns default periods' do
+      periods = calendar.periods
+      periods[:am].should == "vorm."
+      periods[:pm].should == "nachm."
+    end
+
+    it 'returns quarters with other name forms' do
+      periods = calendar.periods(:abbreviated)
+      periods[:am].should == "vorm."
+      periods[:pm].should == "nachm."
+    end
+  end
+
+  describe '#eras' do
+    it 'returns default eras' do
+      calendar.eras.should == {
+        0 => "v. Chr.",
+        1 => "n. Chr."
+      }
+    end
+
+    it 'returns eras with other name forms' do
+      calendar.eras(:abbr).should == {
+        0 => "v. Chr.",
+        1 => "n. Chr."
+      }
+    end
+  end
+
+  describe '#date_order' do
+    it 'should return the correct date order for a few different locales' do
+      Calendar.new(:en).date_order.should == [:month, :day, :year]
+      Calendar.new(:ja).date_order.should == [:year, :month, :day]
+      Calendar.new(:ar).date_order.should == [:day, :month, :year]
+    end
+  end
+
+  describe '#time_order' do
+    it 'should return the correct time order for a few different locales' do
+      Calendar.new(:en).time_order.should == [:hour, :minute, :second, :period]
+      Calendar.new(:ja).time_order.should == [:hour, :minute, :second]
+      Calendar.new(:ar).time_order.should == [:hour, :minute, :second, :period]
+    end
+  end
+
+  describe '#datetime_order' do
+    it 'should return the correct date and time order for a few different locales' do
+      Calendar.new(:en).datetime_order.should == [:month, :day, :year, :hour, :minute, :second, :period]
+      Calendar.new(:ja).datetime_order.should == [:year, :month, :day, :hour, :minute, :second]
+      Calendar.new(:ar).datetime_order.should == [:day, :month, :year, :hour, :minute, :second, :period]
+    end
+  end
+
+  describe '#methods_for_tokens' do
+    it 'converts pattern tokens into their corresponding method names' do
+      tokens = [TwitterCldr::Tokenizers::Token.new(:value => "YYYY", :type => :pattern)]
+      calendar.send(:methods_for_tokens, tokens).should == [:year_of_week_of_year]
+    end
+
+    it 'ignores plaintext tokens' do
+      tokens = [TwitterCldr::Tokenizers::Token.new(:value => "blarg", :type => :plaintext)]
+      calendar.send(:methods_for_tokens, tokens).should == []
+    end
+  end
+
+  describe '#resolve_methods' do
+    it 'converts certain method names to their basic equivalents' do
+      calendar.send(:resolve_methods, [:year_of_week_of_year]).should == [:year]
+      calendar.send(:resolve_methods, [:weekday_local]).should == [:weekday]
+      calendar.send(:resolve_methods, [:day_of_month, :second_fraction]).should == [:day, :second]
+    end
+
+    it 'does not convert basic method names' do
+      calendar.send(:resolve_methods, [:year]).should == [:year]
+      calendar.send(:resolve_methods, [:day, :month]).should == [:day, :month]
+      calendar.send(:resolve_methods, [:minute, :hour, :second]).should == [:minute, :hour, :second]
+    end
+  end
+
 end