twitter_cldr 1.6.2 → 1.7.0

data/spec/collation/trie_builder_spec.rb

@@ -102,17 +102,16 @@ END
   let(:tailoring_resource_stub) do
 <<END
 ---
-collator_options:
-  case_first: upper
-tailored_table: ! '0491; [5C1B, 5, 5]
+:collator_options:
+  :case_first: upper
+:tailored_table: ! '0491; [5C1B, 5, 5]
 
   0490; [5C1B, 5, 86]'
-suppressed_contractions: ГК
-...
+:suppressed_contractions: ГК
 END
   end
 
-  let(:tailoring_data) { TwitterCldr::Utils.deep_symbolize_keys(YAML.load(tailoring_resource_stub)) }
+  let(:tailoring_data) { YAML.load(tailoring_resource_stub) }
 
   describe '.load_tailored_trie' do
     let(:locale)        { :xxx }
@@ -150,9 +149,7 @@ END
     end
 
     it 'do not copy other collation elements from the fallback' do
-      %w[0301 0306 041A 0413 0415].each do |code_point|
-        code_points = [code_point.to_i(16)]
-
+      [0x301, 0x306, 0x41A, 0x413, 0x415].each_slice(1) do |code_points|
         tailored_trie.get(code_points).should_not be_nil
         tailored_trie.get(code_points).object_id.should == fallback.get(code_points).object_id
       end

data/spec/core_ext/array_spec.rb

@@ -10,7 +10,7 @@ include TwitterCldr
 describe LocalizedArray do
   describe '#code_points_to_string' do
     it 'transforms an array of code points into a string' do
-      %w[0074 0077 0069 0074 0074 0065 0072].localize.code_points_to_string.should == 'twitter'
+      [0x74, 0x77, 0x69, 0x74, 0x74, 0x65, 0x72].localize.code_points_to_string.should == 'twitter'
     end
   end
 

data/spec/core_ext/string_spec.rb

@@ -133,7 +133,7 @@ describe LocalizedString do
 
   describe "#code_points" do
     it "returns an array of Unicode code points for the string" do
-      "español".localize.code_points.should == ["0065", "0073", "0070", "0061", "00F1", "006F", "006C"]
+      "español".localize.code_points.should == [0x65, 0x73, 0x70, 0x61, 0xF1, 0x6F, 0x6C]
     end
   end
 

data/spec/formatters/numbers/currency_formatter_spec.rb

@@ -17,6 +17,11 @@ describe CurrencyFormatter do
       @formatter.format(12).should == "$12.00"
     end
 
+    it "handles negative numbers" do
+      # yes, the parentheses really are part of the format, don't worry about it
+      @formatter.format(-12).should == "-($12.00)"
+    end
+
     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"

data/spec/formatters/numbers/decimal_formatter_spec.rb

@@ -20,6 +20,10 @@ describe DecimalFormatter do
     it "should format negative decimals correctly" do
       @formatter.format(-12.0).should == "-12,0"
     end
+
+    it "should respect the :precision option" do
+      @formatter.format(-12, :precision => 3).should == "-12,000"
+    end
   end
 
   describe "#get_tokens" do

data/spec/formatters/numbers/number_formatter_spec.rb

@@ -42,12 +42,12 @@ describe NumberFormatter do
 
   describe "#parse_number" do
     it "should round and split the given number by decimal" do
-      @formatter.send(:parse_number, 12, :precision => 0).should == ["12", "0"]
-      @formatter.send(:parse_number, 12.2, :precision => 0).should == ["12", "0"]
-      @formatter.send(:parse_number, 12.5, :precision => 0).should == ["13", "0"]
+      @formatter.send(:parse_number, 12, :precision => 0).should == ["12"]
+      @formatter.send(:parse_number, 12.2, :precision => 0).should == ["12"]
+      @formatter.send(:parse_number, 12.5, :precision => 0).should == ["13"]
       @formatter.send(:parse_number, 12.25, :precision => 1).should == ["12", "3"]
       @formatter.send(:parse_number, 12.25, :precision => 2).should == ["12", "25"]
-      @formatter.send(:parse_number, 12.25, :precision => 3).should == ["12", "25"]
+      @formatter.send(:parse_number, 12.25, :precision => 3).should == ["12", "250"]
     end
   end
 

data/spec/formatters/numbers/percent_formatter_spec.rb

@@ -15,4 +15,12 @@ describe PercentFormatter do
   it "should format the number correctly" do
     @formatter.format(12).should == "12 %"
   end
+
+  it "should format negative numbers correctly" do
+    @formatter.format(-12).should == "-12 %"
+  end
+
+  it "should respect the :precision option" do
+    @formatter.format(-12, :precision => 3).should match_normalized("-12,000 %")
+  end
 end

data/spec/normalization/base_spec.rb

@@ -10,8 +10,8 @@ include TwitterCldr::Normalization
 describe Base do
   describe "#combining_class_for" do
     it "returns the correct combining class for select code points" do
-      Base.combining_class_for("0303").should == 230  # combining tilde
-      Base.combining_class_for("006E").should == 0    # latin letter n
+      Base.combining_class_for(0x303).should == 230  # combining tilde
+      Base.combining_class_for(0x6E).should  == 0    # latin letter n
     end
   end
 end

data/spec/normalization/normalization_spec.rb

@@ -63,7 +63,7 @@ describe 'Unicode Normalization Algorithms' do
       file.each do |line|
         next if line.empty? || line =~ /^(@|#)/
 
-        data = line.split(';')[0...5].map { |cps| cps.split }
+        data = line.split(';')[0...5].map { |cps| cps.split.map(&:hex) }
 
         invariants.each do |expected_index, tests|
           expected = data[expected_index - 1]
@@ -87,8 +87,8 @@ describe 'Unicode Normalization Algorithms' do
     <<-END
 Test:       "#{line.strip}"
 Invariant:  normalized(c#{test_index}) == c#{expected_index}
-Expected:   normalized(#{test.inspect}) == #{expected.inspect}
-Got:        #{normalized.inspect}
+Expected:   normalized(#{pretty_code_points(test).inspect}) == #{pretty_code_points(expected).inspect}
+Got:        #{pretty_code_points(normalized).inspect}
     END
   end
 
@@ -102,4 +102,8 @@ Got:        #{normalized.inspect}
     puts 'done.'
   end
 
+  def pretty_code_points(code_points)
+    code_points.map { |cp| cp.to_s(16).rjust(4, '0').upcase }
+  end
+
 end

data/spec/readme_spec.rb

@@ -174,27 +174,27 @@ describe "README" do
   end
 
   it "verifies code point conversions" do
-    code_point = TwitterCldr::Shared::CodePoint.for_hex("1F3E9")
+    code_point = TwitterCldr::Shared::CodePoint.find(0x1F3E9)
     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"]
+    TwitterCldr::Utils::CodePoints.from_string("¿").should == [0x0BF]
 
     # Convert code points to characters:
-    TwitterCldr::Utils::CodePoints.to_string(["00BF"]).should == "¿"
+    TwitterCldr::Utils::CodePoints.to_string([0xBF]).should == "¿"
   end
 
   it "verifies normalization" do
-    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::Normalization::NFD.normalize("español")).should == ["0065", "0073", "0070", "0061", "006E", "0303", "006F", "006C"]
+    TwitterCldr::Normalization::NFD.normalize('français').should == TwitterCldr::Utils::CodePoints.to_string([0x66, 0x72, 0x61, 0x6E, 0x63, 0x327, 0x61, 0x69, 0x73])
+    TwitterCldr::Utils::CodePoints.from_string('español').should == [0x65, 0x73, 0x70, 0x61, 0xF1, 0x6F, 0x6C]
+    TwitterCldr::Utils::CodePoints.from_string(TwitterCldr::Normalization::NFD.normalize('español')).should == [0x65, 0x73, 0x70, 0x61, 0x6E, 0x303, 0x6F, 0x6C]
 
-    "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"]
+    "español".localize.code_points.should == [101, 115, 112, 97, 241, 111, 108]
+    "español".localize.normalize.code_points.should == [101, 115, 112, 97, 110, 771, 111, 108]
+    "español".localize.normalize(:using => :NFKD).code_points.should == [101, 115, 112, 97, 110, 771, 111, 108]
   end
 
   it "verifies Twitter-specific locale conversion" do

data/spec/resources/loader_spec.rb

@@ -20,7 +20,7 @@ describe Loader do
     end
 
     it 'symbolizes hash keys' do
-      stub_resource_file(resource_path, "---\na:\n  b: 3\n")
+      stub_resource_file(resource_path, "---\n:a:\n  :b: 3\n")
       loader.get_resource(:random, :resource).should == { :a => { :b => 3 } }
     end
 
@@ -45,14 +45,14 @@ describe Loader 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" }
+        mock(loader).read_resource_file('foo/bar.yml') { ":foo: bar" }
         loader.get_resource(:foo, :bar).should == { :foo => "bar" }
       end
 
       it 'merges the given file with its corresponding custom resource if it exists' do
-        mock(loader).read_resource_file('foo/bar.yml') { "foo: bar" }
+        mock(loader).read_resource_file('foo/bar.yml') { ":foo: bar" }
         mock(loader).resource_exists?('custom/foo/bar.yml') { true }
-        mock(loader).read_resource_file('custom/foo/bar.yml') { "bar: baz" }
+        mock(loader).read_resource_file('custom/foo/bar.yml') { ":bar: baz" }
 
         # make sure load_resource is called with custom = false the second time
         mock.proxy(loader).load_resource("foo/bar.yml")

data/spec/shared/code_point_spec.rb

@@ -8,97 +8,137 @@ require 'spec_helper'
 include TwitterCldr::Shared
 
 describe CodePoint do
-  describe "#for_hex" do
-    it "should retrieve information for any valid code point" do
-      data = CodePoint.for_hex('0301')
-      data.should be_a(CodePoint)
-      data.values.length.should == 15
+  describe "#initialize" do
+    let(:unicode_data) { ['17D1', 'KHMER SIGN VIRIAM', 'Mn', '0', 'NSM', decomposition, "", "", "", 'N', "", "", "", "", ""] }
+    let(:code_point)   { CodePoint.new(*unicode_data) }
+
+    context 'when decomposition is canonical' do
+      let(:decomposition) { '0028 007A 0029' }
+
+      it 'parses decomposition mapping' do
+        code_point.decomposition.should == [0x28, 0x7A, 0x29]
+      end
+
+      it 'initializes compatibility tag as nil' do
+        code_point.compatibility_decomposition_tag.should be_nil
+      end
+
+      it 'returns false from compatibility_decomposition?' do
+        code_point.should_not be_compatibility_decomposition
+      end
     end
 
-    it "should return nil for invalid code points" do
-      CodePoint.for_hex('xyz').should be_nil
-      CodePoint.for_hex('FFFFFFF').should be_nil
-      CodePoint.for_hex('uytukhil123').should be_nil
+    context 'when decomposition is compatibility' do
+      let(:decomposition) { '<font> 0028 007A 0029' }
+
+      it 'parses decomposition mapping' do
+        code_point.decomposition.should == [0x28, 0x7A, 0x29]
+      end
+
+      it 'initializes compatibility decomposition tag' do
+        code_point.compatibility_decomposition_tag.should == 'font'
+      end
+
+      it 'returns true from compatibility_decomposition?' do
+        code_point.should be_compatibility_decomposition
+      end
     end
 
-    it "works with strings in a lower case" do
-      test_code_points_data(
-          "abcd" => ["ABCD", "MEETEI MAYEK LETTER HUK", "Lo", "0", "L", "", "", "", "", "N", "", "", "", "", ""]
-      )
+    context 'when decomposition is empty' do
+      let(:decomposition) { '' }
+
+      it 'parses decomposition mapping' do
+        code_point.decomposition.should be_nil
+      end
+
+      it 'initializes compatibility tag as nil' do
+        code_point.compatibility_decomposition_tag.should be_nil
+      end
+
+      it 'returns false from compatibility_decomposition?' do
+        code_point.should_not be_compatibility_decomposition
+      end
     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', '', '', '', '']
-      )
+    it 'raises ArgumentError if decomposition has invalid format' do
+
+    end
+  end
+
+  describe "#find" do
+    it "retrieves information for any valid code point" do
+      data = CodePoint.find(0x301)
+      data.should be_a(CodePoint)
+      data.values.length.should == 15
+    end
+
+    it "returns nil if the information is not found" do
+      CodePoint.find(0xFFFFFFF).should be_nil
     end
 
     it "fetches valid information for the specified code point" do
       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', "", "", "", "", ""]
+          0x17D1  => [0x17D1, "KHMER SIGN VIRIAM", "Mn", "0", "NSM", "", "", "", "", "N", "", "", "", "", ""],
+          0xFE91  => [0xFE91, "ARABIC LETTER BEH INITIAL FORM", "Lo", "0", "AL", "<initial> 0628", "", "", "", "N", "GLYPH FOR INITIAL ARABIC BAA", "", "", "", ""],
+          0x24B5  => [0x24B5, "PARENTHESIZED LATIN SMALL LETTER Z", "So", "0", "L", "<compat> 0028 007A 0029", "", "", "", "N", "", "", "", "", ""],
+          0x2128  => [0x2128, "BLACK-LETTER CAPITAL Z", "Lu", "0", "L", "<font> 005A", "", "", "", "N", "BLACK-LETTER Z", "", "", "", ""],
+          0x1F241 => [0x1F241, "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_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", "", "", "", "", ""]
+          0x4E11 => [0x4E11, "<CJK Ideograph>", "Lo", "0", "L", "", "", "", "", "N", "", "", "", "", ""],
+          0xAC55 => [0xAC55, "<Hangul Syllable>", "Lo", "0", "L", "", "", "", "", "N", "", "", "", "", ""],
+          0xD7A1 => [0xD7A1, "<Hangul Syllable>", "Lo", "0", "L", "", "", "", "", "N", "", "", "", "", ""],
+          0xDAAA => [0xDAAA, "<Non Private Use High Surrogate>", "Cs", "0", "L", "", "", "", "", "N", "", "", "", "", ""],
+          0xF8FE => [0xF8FE, "<Private Use>", "Co", "0", "L", "", "", "", "", "N", "", "", "", "", ""]
       )
     end
 
     def test_code_points_data(test_data)
       test_data.each do |code_point, data|
-        cp_data = CodePoint.for_hex(code_point)
+        cp_data = CodePoint.find(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]
-        cp_data.combining_class.should == data[3]
+        [:code_point, :name, :category, :combining_class].map { |msg| cp_data.send(msg) }.should == data[0..3]
       end
     end
   end
 
-  describe "#for_decomposition" do
-    let(:decomp_map) { { :"YYYY ZZZZ" => "0ABC" } }
+  describe "#for_canonical_decomposition" do
+    let(:canonical_compositions) { { [123, 456] => 789 } }
 
     before(:each) do
       # clear the decomposition map after each test so mocks/stubs work
-      CodePoint.instance_variable_set(:@decomposition_map, nil)
-      stub(CodePoint).for_hex { |code_point| "I'm code point #{code_point}" }
+      CodePoint.instance_variable_set(:@canonical_compositions, nil)
+      stub(CodePoint).find { |code_point| "I'm code point #{code_point}" }
     end
 
-    after(:each) do
+    after(:all) do
       # clear the decomposition map after each test so mocks/stubs work
-      CodePoint.instance_variable_set(:@decomposition_map, nil)
+      CodePoint.instance_variable_set(:@canonical_compositions, nil)
     end
 
     context "with a stubbed decomposition map" do
       before(:each) do
-        stub(TwitterCldr).get_resource(:unicode_data, :decomposition_map) { decomp_map }
+        mock(TwitterCldr).get_resource(:unicode_data, :canonical_compositions) { canonical_compositions }
       end
 
       it "should return a code point with the correct value" do
-        CodePoint.for_decomposition(["YYYY", "ZZZZ"]).should == "I'm code point 0ABC"
+        CodePoint.for_canonical_decomposition([123, 456]).should == "I'm code point 789"
       end
 
       it "should return nil if no decomposition mapping exists" do
-        CodePoint.for_decomposition(["NO"]).should be_nil
+        CodePoint.for_canonical_decomposition([987]).should be_nil
       end
     end
 
     it "should cache the decomposition map" do
-      mock(TwitterCldr).get_resource(:unicode_data, :decomposition_map) { decomp_map }.once
-      CodePoint.for_decomposition(["NO"]).should be_nil
-      CodePoint.for_decomposition(["NO"]).should be_nil
+      mock(TwitterCldr).get_resource(:unicode_data, :canonical_compositions) { canonical_compositions }.once
+      CodePoint.for_canonical_decomposition([0xA0]).should be_nil
+      CodePoint.for_canonical_decomposition([0xA0]).should be_nil
     end
   end
 
@@ -115,50 +155,50 @@ describe CodePoint do
     end
 
     it "returns nil if not part of a hangul block" do
-      CodePoint.hangul_type(100.to_s(16)).should == nil
+      CodePoint.hangul_type(100).should == nil
     end
 
     it "returns the correct part (i.e. lpart, vpart, or tpart) before composition or decomposition" do
-      CodePoint.hangul_type(5.to_s(16)).should == :lparts
-      CodePoint.hangul_type(30.to_s(16)).should == :vparts
-      CodePoint.hangul_type(41.to_s(16)).should == :tparts
+      CodePoint.hangul_type(5).should  == :lparts
+      CodePoint.hangul_type(30).should == :vparts
+      CodePoint.hangul_type(41).should == :tparts
     end
 
     it "returns composition if no part can be found" do
-      CodePoint.hangul_type(11.to_s(16)).should == :compositions
+      CodePoint.hangul_type(11).should == :compositions
     end
   end
 
   describe "#excluded_from_composition?" do
     it "excludes anything in the list of ranges" do
       stub(CodePoint).composition_exclusions { [10..10, 13..14, 20..30] }
-      CodePoint.excluded_from_composition?(10.to_s(16)).should be_true
-      CodePoint.excluded_from_composition?(13.to_s(16)).should be_true
-      CodePoint.excluded_from_composition?(14.to_s(16)).should be_true
-      CodePoint.excluded_from_composition?(15.to_s(16)).should be_false
-      CodePoint.excluded_from_composition?(19.to_s(16)).should be_false
-      CodePoint.excluded_from_composition?(100.to_s(16)).should be_false
+      CodePoint.excluded_from_composition?(10).should be_true
+      CodePoint.excluded_from_composition?(13).should be_true
+      CodePoint.excluded_from_composition?(14).should be_true
+      CodePoint.excluded_from_composition?(15).should be_false
+      CodePoint.excluded_from_composition?(19).should be_false
+      CodePoint.excluded_from_composition?(100).should be_false
     end
   end
 
   describe "#get_block" do
     it "finds the block that corresponds to the code point" do
       stub(TwitterCldr).get_resource(:unicode_data, :blocks) { [[:klingon, 122..307], [:hirogen, 1337..2200]] }
-      CodePoint.send(:get_block, 200.to_s(16)).should == [:klingon, 122..307]
-      CodePoint.send(:get_block, 2199.to_s(16)).should == [:hirogen, 1337..2200]
-      CodePoint.send(:get_block, 100.to_s(16)).should be_nil
+      CodePoint.send(:get_block, 200).should  == [:klingon, 122..307]
+      CodePoint.send(:get_block, 2199).should == [:hirogen, 1337..2200]
+      CodePoint.send(:get_block, 100).should be_nil
     end
   end
 
   describe "#get_range_start" do
     it "returns the data for a non-explicit range" do
-      block_data = { "0" => ["1337", "<CJK Ideograph Extension A, First>"] }
-      CodePoint.send(:get_range_start, "ABC", block_data).should == ["ABC", "<CJK Ideograph Extension A>"]
+      block_data = { 0x1337 => [0x1337, "<CJK Ideograph Extension A, First>"] }
+      CodePoint.send(:get_range_start, 0xABC, block_data).should == [0xABC, "<CJK Ideograph Extension A>"]
     end
 
     it "returns nil if the block data doesn't contain a non-explicit range" do
-      block_data = { "0" => ["1337", "<CJK Ideograph Extension A>"] }
-      CodePoint.send(:get_range_start, "ABC", block_data).should == nil
+      block_data = { 0x1337 => [0x1337, "<CJK Ideograph Extension A>"] }
+      CodePoint.send(:get_range_start, 0xABC, block_data).should == nil
     end
   end
 end