twitter_cldr 1.4.1 → 1.5.0

data/spec/formatters/calendars/datetime_formatter_spec.rb

@@ -24,10 +24,74 @@ describe DateTimeFormatter do
     end
   end
 
+  describe "#weekday_local_stand_alone" do
+    it "test: pattern c" do
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,   4), 'c', 1).should == '1'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,   5), 'c', 1).should == '2'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,  10), 'c', 1).should == '7'
+    end
+
+    it "test: pattern cc" do
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1, 4),  'cc',  2).should == 'Mo.'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1, 5),  'cc',  2).should == 'Di.'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1, 10), 'cc',  2).should == 'So.'
+    end
+
+    it "test: pattern ccc" do
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1, 4),  'ccc',  3).should == 'Mo.'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1, 5),  'ccc',  3).should == 'Di.'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1, 10), 'ccc',  3).should == 'So.'
+    end
+
+    it "test: pattern cccc" do
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,   4), 'cccc', 4).should == 'Montag'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,   5), 'cccc', 4).should == 'Dienstag'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,  10), 'cccc', 4).should == 'Sonntag'
+    end
+
+    it "test: pattern ccccc" do
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,   4), 'ccccc', 5).should == 'M'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,   5), 'ccccc', 5).should == 'D'
+      @formatter.send(:weekday_local_stand_alone, Date.new(2010, 1,  10), 'ccccc', 5).should == 'S'
+    end
+  end
+
+  describe "#weekday_local" do
+    it "test: pattern e" do
+      @formatter.send(:weekday_local, Date.new(2010, 1,   4), 'e', 1).should == '1'
+      @formatter.send(:weekday_local, Date.new(2010, 1,   5), 'e', 1).should == '2'
+      @formatter.send(:weekday_local, Date.new(2010, 1,  10), 'e', 1).should == '7'
+    end
+
+    it "test: pattern ee" do
+      @formatter.send(:weekday_local, Date.new(2010, 1,   4), 'ee', 2).should == '1'
+      @formatter.send(:weekday_local, Date.new(2010, 1,   5), 'ee', 2).should == '2'
+      @formatter.send(:weekday_local, Date.new(2010, 1,  10), 'ee', 2).should == '7'
+    end
+
+    it "test: pattern eee" do
+      @formatter.send(:weekday_local, Date.new(2010, 1,   4), 'eee', 3).should == 'Mo.'
+      @formatter.send(:weekday_local, Date.new(2010, 1,   5), 'eee', 3).should == 'Di.'
+      @formatter.send(:weekday_local, Date.new(2010, 1,  10), 'eee', 3).should == 'So.'
+    end
+
+    it "test: pattern eeee" do
+      @formatter.send(:weekday_local, Date.new(2010, 1,   4), 'eeee', 4).should == 'Montag'
+      @formatter.send(:weekday_local, Date.new(2010, 1,   5), 'eeee', 4).should == 'Dienstag'
+      @formatter.send(:weekday_local, Date.new(2010, 1,  10), 'eeee', 4).should == 'Sonntag'
+    end
+
+    it "test: pattern eeeee" do
+      @formatter.send(:weekday_local, Date.new(2010, 1,   4), 'eeeee', 5).should == 'M'
+      @formatter.send(:weekday_local, Date.new(2010, 1,   5), 'eeeee', 5).should == 'D'
+      @formatter.send(:weekday_local, Date.new(2010, 1,  10), 'eeeee', 5).should == 'S'
+    end
+  end
+
   describe "#weekday" do
     it "test: pattern E, EE, EEE" do
-      @formatter.send(:weekday, Date.new(2010, 1, 1), 'E', 1).should == 'Fr.'
-      @formatter.send(:weekday, Date.new(2010, 1, 1), 'EE', 2).should == 'Fr.'
+      @formatter.send(:weekday, Date.new(2010, 1, 1), 'E',   1).should == 'Fr.'
+      @formatter.send(:weekday, Date.new(2010, 1, 1), 'EE',  2).should == 'Fr.'
       @formatter.send(:weekday, Date.new(2010, 1, 1), 'EEE', 3).should == 'Fr.'
     end
 
@@ -327,4 +391,30 @@ describe DateTimeFormatter do
       @formatter.send(:year, Date.new(12345, 1, 1), 'yyyyy', 5).should == '12345'
     end
   end
+
+  describe "#era" do
+    before(:each) do
+      @formatter = DateTimeFormatter.new(:locale => :en)
+    end
+
+    it "test: pattern G" do
+      @formatter.send(:era, Date.new(2012, 1, 1), 'G', 1).should == "AD"
+      @formatter.send(:era, Date.new(-1, 1, 1), 'G', 1).should == "BC"
+    end
+
+    it "test: pattern GG" do
+      @formatter.send(:era, Date.new(2012, 1, 1), 'GG', 2).should == "AD"
+      @formatter.send(:era, Date.new(-1, 1, 1), 'GG', 2).should == "BC"
+    end
+
+    it "test: pattern GGG" do
+      @formatter.send(:era, Date.new(2012, 1, 1), 'GGG', 3).should == "AD"
+      @formatter.send(:era, Date.new(-1, 1, 1), 'GGG', 3).should == "BC"
+    end
+
+    it "test: pattern GGGG" do
+      @formatter.send(:era, Date.new(2012, 1, 1), 'GGGG', 4).should == "Anno Domini"
+      @formatter.send(:era, Date.new(-1, 1, 1), 'GGGG', 4).should == "Before Christ"
+    end
+  end
 end

data/spec/{normalizers → normalization}/base_spec.rb

@@ -5,7 +5,7 @@
 
 require 'spec_helper'
 
-include TwitterCldr::Normalizers
+include TwitterCldr::Normalization
 
 describe Base do
   describe "#combining_class_for" do

data/spec/normalization/hangul_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::Normalization
+
+describe Hangul do
+
+  describe ".compose" do
+    it 'composes decomposed Hangul syllable without a trailing consonant' do
+      Hangul.compose([0x1101, 0x1167]).should == 0xAEF4
+    end
+
+    it 'composes decomposed Hangul syllable with a trailing consonant' do
+      Hangul.compose([0x1111, 0x1171, 0x11B6]).should == 0xD4DB
+    end
+  end
+
+  describe ".decompose" do
+    it 'decomposes precomposed Hangul syllable without a trailing consonant' do
+      Hangul.decompose(0xAEF4).should == [0x1101, 0x1167]
+    end
+
+    it 'decomposes precomposed Hangul syllable with a trailing consonant' do
+      Hangul.decompose(0xD4DB).should == [0x1111, 0x1171, 0x11B6]
+    end
+  end
+
+  describe '.hangul_syllable?' do
+    it 'returns true for code points from Hangul syllables range' do
+      [0xAC00, 0xAC01, 0xBC9F, 0xD7A1, 0xD7A3].map { |code_point| Hangul.hangul_syllable?(code_point).should be_true }
+    end
+
+    it 'returns false for other code points' do
+      [0xAB, 0xABFF, 0xD7A4, 0xFFCF].map { |code_point| Hangul.hangul_syllable?(code_point).should be_false }
+    end
+  end
+
+end

data/spec/{normalizers → normalization}/normalization_spec.rb

@@ -7,24 +7,23 @@ require 'spec_helper'
 
 require 'open-uri'
 
-include TwitterCldr::Normalizers
+include TwitterCldr::Normalization
 
 describe 'Unicode Normalization Algorithms' do
 
-  NORMALIZERS_SPEC_PATH = File.dirname(__FILE__)
-  SHORT_TEST_PATH       = File.join(NORMALIZERS_SPEC_PATH, 'NormalizationTestShort.txt')
-  FULL_TEST_PATH        = File.join(NORMALIZERS_SPEC_PATH, 'NormalizationTest.txt')
+  SHORT_NORMALIZATION_TEST_PATH = File.join(File.dirname(__FILE__), 'NormalizationTestShort.txt')
+  FULL_NORMALIZATION_TEST_PATH  = File.join(File.dirname(__FILE__), 'NormalizationTest.txt')
 
-  NORMALIZATION_TEST_URL = 'http://unicode.org/Public/UNIDATA/NormalizationTest.txt'
+  FULL_NORMALIZATION_TEST_URL = 'http://unicode.org/Public/UNIDATA/NormalizationTest.txt'
 
   shared_examples_for 'a normalization algorithm' do
-    it 'passes all the tests in NormalizersTestShort.txt' do
-      run_normalization_test(described_class, invariants, SHORT_TEST_PATH)
+    it 'passes all the tests in NormalizationTestShort.txt' do
+      run_test(described_class, invariants, SHORT_NORMALIZATION_TEST_PATH)
     end
 
-    it 'passes all the tests in NormalizersTest.txt', :slow => true do
+    it 'passes all the tests in NormalizationTest.txt', :slow => true do
       prepare_full_test
-      run_normalization_test(described_class, invariants, FULL_TEST_PATH)
+      run_test(described_class, invariants, FULL_NORMALIZATION_TEST_PATH)
     end
   end
 
@@ -59,7 +58,7 @@ describe 'Unicode Normalization Algorithms' do
   # where (c1, c2,...) are columns of the normalization test separated by semicolons and normalized() is the
   # normalization function. Note, how expectation and tests columns indexes match the numbers in the `invariants` hash.
   #
-  def run_normalization_test(normalizer, invariants, file_path)
+  def run_test(normalizer, invariants, file_path)
     open(file_path, 'r:UTF-8') do |file|
       file.each do |line|
         next if line.empty? || line =~ /^(@|#)/
@@ -74,7 +73,7 @@ describe 'Unicode Normalization Algorithms' do
 
             normalized = normalizer.normalize_code_points(test)
 
-            message = normalization_error_message(line, test, expected, normalized, test_index, expected_index)
+            message = error_message(line, test, expected, normalized, test_index, expected_index)
             normalized.should(eq(expected), message)
           end
         end
@@ -82,9 +81,9 @@ describe 'Unicode Normalization Algorithms' do
     end
   end
 
-  # Generates helpful error message for normalization test failure.
+  # Generates a descriptive error message test failure.
   #
-  def normalization_error_message(line, test, expected, normalized, test_index, expected_index)
+  def error_message(line, test, expected, normalized, test_index, expected_index)
     <<-END
 Test:       "#{line.strip}"
 Invariant:  normalized(c#{test_index}) == c#{expected_index}
@@ -93,13 +92,13 @@ Got:        #{normalized.inspect}
     END
   end
 
-  # Downloads full Unicode normalization tests suit if necessary.
+  # Downloads full version of the test if necessary.
   #
   def prepare_full_test
-    return if File.file?(FULL_TEST_PATH)
+    return if File.file?(FULL_NORMALIZATION_TEST_PATH)
 
     print '    Downloading NormalizationTest.txt ... '
-    open(FULL_TEST_PATH, 'w') { |file| file.write(open(NORMALIZATION_TEST_URL).read) }
+    open(FULL_NORMALIZATION_TEST_PATH, 'w') { |file| file.write(open(FULL_NORMALIZATION_TEST_URL).read) }
     puts 'done.'
   end
 

data/spec/readme_spec.rb

@@ -188,9 +188,9 @@ describe "README" do
   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::Normalization::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"]
+    TwitterCldr::Utils::CodePoints.from_string(TwitterCldr::Normalization::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"]

data/spec/shared/code_point_spec.rb

@@ -16,39 +16,49 @@ describe CodePoint do
     end
 
     it "should return nil for invalid code points" do
-      CodePoint.for_hex('abcd').should be_nil
+      CodePoint.for_hex('xyz').should be_nil
       CodePoint.for_hex('FFFFFFF').should be_nil
       CodePoint.for_hex('uytukhil123').should be_nil
     end
 
+    it "works with strings in a lower case" do
+      test_code_points_data(
+          "abcd" => ["ABCD", "MEETEI MAYEK LETTER HUK", "Lo", "0", "L", "", "", "", "", "N", "", "", "", "", ""]
+      )
+    end
+
+    it "works with strings shorter than 4 characters (by left-padding them with zeros)" do
+      test_code_points_data(
+          '306' => ['0306', 'COMBINING BREVE', 'Mn', '230', 'NSM', '', '', '', '', 'N', 'NON-SPACING BREVE', '', '', '', '']
+      )
+    end
+
     it "fetches valid information for the specified code point" do
-      test_data = {
-        '17D1' => ['17D1','KHMER SIGN VIRIAM','Mn','0','NSM',"","","","",'N',"","","","",""],
-        'FE91' => ['FE91','ARABIC LETTER BEH INITIAL FORM','Lo','0','AL','<initial> 0628',"","","",'N','GLYPH FOR INITIAL ARABIC BAA',"","","",""],
-        '24B5' => ['24B5','PARENTHESIZED LATIN SMALL LETTER Z','So','0','L','<compat> 0028 007A 0029',"","","",'N',"","","","",""],
-        '2128' => ['2128','BLACK-LETTER CAPITAL Z','Lu','0','L','<font> 005A',"","","",'N','BLACK-LETTER Z',"","","",""],
-        '1F241'=> ['1F241','TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-4E09','So','0','L','<compat> 3014 4E09 3015',"","","",'N',"","","","",""]
-      }
-      test_data.each_pair do |code_point, data|
-        cp_data = CodePoint.for_hex(code_point)
-        cp_data.code_point.should == data[0]
-        cp_data.name.should == data[1]
-        cp_data.category.should == data[2]
-        cp_data.combining_class.should == data[3]
-      end
+      test_code_points_data(
+          '17D1'  => ['17D1', 'KHMER SIGN VIRIAM', 'Mn', '0', 'NSM', "", "", "", "", 'N', "", "", "", "", ""],
+          'FE91'  => ['FE91', 'ARABIC LETTER BEH INITIAL FORM', 'Lo', '0', 'AL', '<initial> 0628', "", "", "", 'N', 'GLYPH FOR INITIAL ARABIC BAA', "", "", "", ""],
+          '24B5'  => ['24B5', 'PARENTHESIZED LATIN SMALL LETTER Z', 'So', '0', 'L', '<compat> 0028 007A 0029', "", "", "", 'N', "", "", "", "", ""],
+          '2128'  => ['2128', 'BLACK-LETTER CAPITAL Z', 'Lu', '0', 'L', '<font> 005A', "", "", "", 'N', 'BLACK-LETTER Z', "", "", "", ""],
+          '1F241' => ['1F241', 'TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-4E09', 'So', '0', 'L', '<compat> 3014 4E09 3015', "", "", "", 'N', "", "", "", "", ""]
+      )
     end
 
     it "fetches valid information for a code point within a range" do
-      test_data = {
-        '4E11' => ["4E11","<CJK Ideograph>","Lo","0","L","","","","","N","","","","",""],
-        'AC55' => ["AC55","<Hangul Syllable>","Lo","0","L","","","","","N","","","","",""],
-        'D7A1' => ["D7A1","<Hangul Syllable>","Lo","0","L","","","","","N","","","","",""],
-        'DAAA' => ["DAAA","<Non Private Use High Surrogate>","Cs","0","L","","","","","N","","","","",""],
-        'F8FE' => ["F8FE","<Private Use>","Co","0","L","","","","","N","","","","",""]
-      }
+      test_code_points_data(
+          '4E11' => ["4E11", "<CJK Ideograph>", "Lo", "0", "L", "", "", "", "", "N", "", "", "", "", ""],
+          'AC55' => ["AC55", "<Hangul Syllable>", "Lo", "0", "L", "", "", "", "", "N", "", "", "", "", ""],
+          'D7A1' => ["D7A1", "<Hangul Syllable>", "Lo", "0", "L", "", "", "", "", "N", "", "", "", "", ""],
+          'DAAA' => ["DAAA", "<Non Private Use High Surrogate>", "Cs", "0", "L", "", "", "", "", "N", "", "", "", "", ""],
+          'F8FE' => ["F8FE", "<Private Use>", "Co", "0", "L", "", "", "", "", "N", "", "", "", "", ""]
+      )
+    end
 
-      test_data.each_pair do |code_point, data|
+    def test_code_points_data(test_data)
+      test_data.each do |code_point, data|
         cp_data = CodePoint.for_hex(code_point)
+
+        cp_data.should_not be_nil
+
         cp_data.code_point.should == data[0]
         cp_data.name.should == data[1]
         cp_data.category.should == data[2]
@@ -94,11 +104,14 @@ describe CodePoint do
 
   describe "#hangul_type" do
     before(:each) do
-      stub(CodePoint).hangul_blocks { { :lparts => [1..10],
-                                        :vparts => [21..30],
-                                        :tparts => [41..50],
-                                        :compositions => [1..30],
-                                        :decompositions => [31..50] } }
+      stub(CodePoint).hangul_blocks {
+        {
+            :lparts       => [1..10],
+            :vparts       => [21..30],
+            :tparts       => [41..50],
+            :compositions => [1..50]
+        }
+      }
     end
 
     it "returns nil if not part of a hangul block" do
@@ -111,9 +124,8 @@ describe CodePoint do
       CodePoint.hangul_type(41.to_s(16)).should == :tparts
     end
 
-    it "returns composition or decomposition if no part can be found" do
+    it "returns composition if no part can be found" do
       CodePoint.hangul_type(11.to_s(16)).should == :compositions
-      CodePoint.hangul_type(40.to_s(16)).should == :decompositions
     end
   end
 

data/spec/shared/resources_spec.rb

@@ -11,17 +11,26 @@ describe Resources do
   let(:resources) { Resources.new }
 
   describe '#get_resource' do
+    let(:resource_path) { 'random/resource.yml' }
+    let(:resource_content) { 'random YAML content' }
+
     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]
+      stub_resource_file(resource_path, "---\n- 1\n- 2\n")
+      resources.get_resource(:random, :resource).should == [1, 2]
+    end
+
+    it 'symbolizes hash keys' do
+      stub_resource_file(resource_path, "---\na:\n  b: 3\n")
+      resources.get_resource(:random, :resource).should == { :a => { :b => 3 } }
     end
 
     it 'loads the resource only once' do
-      mock(resources).load_resource('shared/currencies.yml').once { 'foo-bar-baz' }
+      mock(resources).load_resource(resource_path).once { resource_content }
 
-      result = resources.get_resource(:shared, :currencies)
+      result = resources.get_resource(:random, :resource)
+      result.should == resource_content
       # 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
+      resources.get_resource(:random, :resource).object_id.should == result.object_id
     end
 
     it 'accepts a variable length resource path both in symbols and strings' do
@@ -30,16 +39,25 @@ describe Resources do
     end
 
     it 'raises an exception if resource file is missing' do
+      mock(File).file?(File.join(TwitterCldr::RESOURCES_DIR, 'foo/bar.yml')) { false }
       lambda { resources.get_resource(:foo, :bar) }.should raise_error(ArgumentError, "Resource 'foo/bar.yml' not found.")
     end
   end
 
   describe '#get_locale_resource' do
-    it 'load the correct locale resource file' do
+    it 'loads the correct locale resource file' do
       stub(resources).get_resource(:locales, :de, :numbers) { 'foo' }
       resources.get_locale_resource(:de, :numbers).should == 'foo'
     end
 
+    it 'loads the resource only once' do
+      mock(resources).load_resource('locales/de/numbers.yml').once { 'foo' }
+
+      result = resources.get_locale_resource(:de, :numbers)
+      # second time get_resource is not called but we get the same object as before
+      resources.get_locale_resource(:de, :numbers).object_id.should == result.object_id
+    end
+
     it 'converts locales' do
       mock(TwitterCldr).convert_locale('zh-tw') { :'zh-Hant' }
       mock(resources).get_resource(:locales, :'zh-Hant', :numbers) { 'foo' }
@@ -48,4 +66,10 @@ describe Resources do
     end
   end
 
+  def stub_resource_file(resource_path, content)
+    file_path = File.join(TwitterCldr::RESOURCES_DIR, resource_path)
+    stub(File).read(file_path) { content }
+    stub(File).file?(file_path) { true }
+  end
+
 end

data/spec/tokenizers/base_spec.rb

@@ -147,6 +147,23 @@ describe Base do
     end
   end
 
+  describe "#expand" do
+    it "leaves a normal hash alone" do
+      hash = { :twitter => { :is => "cool" } }
+      @base.send(:expand, hash, hash).should == hash
+    end
+
+    it "expands a single symbol path" do
+      hash = { :twitter => { :is => :'adjective.positive' }, :adjective => { :positive => "cool" } }
+      @base.send(:expand, hash, hash).should == { :twitter => { :is => "cool" }, :adjective => { :positive => "cool" } }
+    end
+
+    it "expands nested symbol paths" do
+      hash = { :twitter => { :is => :'adjective.positive' }, :adjective => { :positive => :'adjective.default', :default => "awesome" } }
+      @base.send(:expand, hash, hash).should == { :twitter => { :is => "awesome" }, :adjective => { :positive => "awesome", :default => "awesome" } }
+    end
+  end
+
   describe "#traverse" do
     before(:each) do
       @tree = { :admiral => { :captain => { :commander => { :lieutenant => "Found Me!" } } } }

data/spec/twitter_cldr_spec.rb

@@ -29,7 +29,7 @@ describe TwitterCldr do
       locales = TwitterCldr.supported_locales
       locales.should include(:es)
       locales.should include(:zh)
-      locales.should include(:no)
+      locales.should include(:nb)
       locales.should include(:ja)
     end