twitter_cldr 3.2.1 → 3.3.0

data/spec/shared/code_point_spec.rb

@@ -9,7 +9,6 @@ include TwitterCldr::Shared
 
 describe CodePoint do
   def clear
-    CodePoint.instance_variable_set(:@composition_exclusion_cache, nil)
     CodePoint.instance_variable_set(:@canonical_compositions, nil)
     CodePoint.instance_variable_set(:@block_cache, nil)
     CodePoint.instance_variable_set(:@blocks, nil)
@@ -32,10 +31,6 @@ describe CodePoint do
       it 'initializes compatibility tag as nil' do
         expect(code_point.compatibility_decomposition_tag).to be_nil
       end
-
-      it 'returns false from compatibility_decomposition?' do
-        expect(code_point).not_to be_compatibility_decomposition
-      end
     end
 
     context 'when decomposition is compatibility' do
@@ -48,10 +43,6 @@ describe CodePoint do
       it 'initializes compatibility decomposition tag' do
         expect(code_point.compatibility_decomposition_tag).to eq('font')
       end
-
-      it 'returns true from compatibility_decomposition?' do
-        expect(code_point).to be_compatibility_decomposition
-      end
     end
 
     context 'when decomposition is empty' do
@@ -64,47 +55,81 @@ describe CodePoint do
       it 'initializes compatibility tag as nil' do
         expect(code_point.compatibility_decomposition_tag).to be_nil
       end
+    end
+  end
 
-      it 'returns false from compatibility_decomposition?' do
-        expect(code_point).not_to be_compatibility_decomposition
-      end
+  describe '#properties' do
+    it 'identifies all properties belonging to the code point' do
+      code_point = CodePoint.get(65)
+      properties = code_point.properties
+      expect(properties.alphabetic).to be_true
+      expect(properties.script).to eq(Set.new(%w(Latin)))
+      expect(properties.general_category).to eq(Set.new(%w(L Lu)))
+    end
+  end
+
+  describe '.properties' do
+    it 'provides an instance of PropertiesDatabase' do
+      expect(CodePoint.properties).to be_a(PropertiesDatabase)
+      expect(CodePoint.properties.property_names.size).to be > 60
+    end
+  end
+
+  describe '.code_points_for_property' do
+    it 'delegates to the properties database' do
+      database = Object.new
+      property_name = 'foo'
+      property_value = 'bar'
+      stub(CodePoint).properties { database }
+      mock(database).code_points_for_property(property_name, property_value)
+      CodePoint.code_points_for_property(property_name, property_value)
+    end
+  end
+
+  describe '.properties_for_code_point' do
+    it 'delegates to the properties database' do
+      database = Object.new
+      code_point = 65
+      stub(CodePoint).properties { database }
+      mock(database).properties_for_code_point(code_point)
+      CodePoint.properties_for_code_point(code_point)
     end
   end
 
-  describe "#find" do
+  describe ".get" do
     it "retrieves information for any valid code point" do
-      data = CodePoint.find(0x301)
+      data = CodePoint.get(0x301)
       expect(data).to be_a(CodePoint)
       expect(data.fields.length).to eq(15)
     end
 
     it "returns nil if the information is not found" do
-      expect(CodePoint.find(0xFFFFFFF)).to be_nil
+      expect(CodePoint.get(0xFFFFFFF)).to be_nil
     end
 
     it "fetches valid information for the specified code point" do
       test_code_points_data(
-          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", "", "", "", "", ""]
+        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(
-          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", "", "", "", "", ""]
+        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.find(code_point)
+        cp_data = CodePoint.get(code_point)
 
         expect(cp_data).not_to be_nil
 
@@ -112,128 +137,4 @@ describe CodePoint do
       end
     end
   end
-
-  describe "#code_points_for{index}" do
-    it "returns code points for the given general unicode property name" do
-      cps = CodePoint.code_points_for_category(:Cc)
-      expect(cps).to be_a(Array)
-      expect(cps.first).to eq(0..31)
-
-      cps = CodePoint.code_points_for_bidi_class(:BN)
-      expect(cps).to be_a(Array)
-      expect(cps.first).to eq(0..8)
-
-      cps = CodePoint.code_points_for_bidi_mirrored(:N)
-      expect(cps).to be_a(Array)
-      expect(cps.first).to eq(0..39)
-    end
-  end
-
-  describe "#code_points_for_property_value" do
-    it "returns code points for the given unicode property and value" do
-      cps = CodePoint.code_points_for_line_break(:CM)
-      expect(cps).to be_a(Array)
-      expect(cps.first).to eq(0..8)
-
-      cps = CodePoint.code_points_for_sentence_break(:Extend)
-      expect(cps).to be_a(Array)
-      expect(cps.first).to eq(768..879)
-
-      cps = CodePoint.code_points_for_word_break(:Hebrew_Letter)
-      expect(cps).to be_a(Array)
-      expect(cps.first).to eq(1488..1514)
-    end
-  end
-
-  describe "#for_canonical_decomposition" do
-    let(:canonical_compositions) { { [123, 456] => 789 } }
-
-    before(:each) do
-      stub(CodePoint).find { |code_point| "I'm code point #{code_point}" }
-    end
-
-    context "with a stubbed decomposition map" do
-      before(:each) do
-        mock(TwitterCldr).get_resource(:unicode_data, :canonical_compositions) { canonical_compositions }
-      end
-
-      it "should return a code point with the correct value" do
-        expect(CodePoint.for_canonical_decomposition([123, 456])).to eq("I'm code point 789")
-      end
-
-      it "should return nil if no decomposition mapping exists" do
-        expect(CodePoint.for_canonical_decomposition([987])).to be_nil
-      end
-    end
-
-    it "should cache the decomposition map" do
-      mock(TwitterCldr).get_resource(:unicode_data, :canonical_compositions) { canonical_compositions }.once
-      expect(CodePoint.for_canonical_decomposition([0xA0])).to be_nil
-      expect(CodePoint.for_canonical_decomposition([0xA0])).to be_nil
-    end
-  end
-
-  describe "#hangul_type" do
-    before(:each) do
-      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
-      expect(CodePoint.hangul_type(100)).to eq(nil)
-    end
-
-    it "returns the correct part (i.e. lpart, vpart, or tpart) before composition or decomposition" do
-      expect(CodePoint.hangul_type(5)).to  eq(:lparts)
-      expect(CodePoint.hangul_type(30)).to eq(:vparts)
-      expect(CodePoint.hangul_type(41)).to eq(:tparts)
-    end
-
-    it "returns composition if no part can be found" do
-      expect(CodePoint.hangul_type(11)).to eq(: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] }
-      expect(CodePoint.excluded_from_composition?(10)).to be_true
-      expect(CodePoint.excluded_from_composition?(13)).to be_true
-      expect(CodePoint.excluded_from_composition?(14)).to be_true
-      expect(CodePoint.excluded_from_composition?(15)).to be_false
-      expect(CodePoint.excluded_from_composition?(19)).to be_false
-      expect(CodePoint.excluded_from_composition?(100)).to be_false
-    end
-  end
-
-  describe "#get_block" do
-    before(:each) do
-      CodePoint.send(:block_cache).clear
-    end
-
-    it "finds the block that corresponds to the code point" do
-      stub(TwitterCldr).get_resource(:unicode_data, :blocks) { [[:klingon, 122..307], [:hirogen, 1337..2200]] }
-      expect(CodePoint.send(:get_block, 200)).to  eq([:klingon, 122..307])
-      expect(CodePoint.send(:get_block, 2199)).to eq([:hirogen, 1337..2200])
-      expect(CodePoint.send(:get_block, 100)).to be_nil
-    end
-  end
-
-  describe "#get_range_start" do
-    it "returns the data for a non-explicit range" do
-      block_data = { 0x1337 => [0x1337, "<CJK Ideograph Extension A, First>"] }
-      expect(CodePoint.send(:get_range_start, 0xABC, block_data)).to eq([0xABC, "<CJK Ideograph Extension A>"])
-    end
-
-    it "returns nil if the block data doesn't contain a non-explicit range" do
-      block_data = { 0x1337 => [0x1337, "<CJK Ideograph Extension A>"] }
-      expect(CodePoint.send(:get_range_start, 0xABC, block_data)).to eq(nil)
-    end
-  end
-end
+end

data/spec/shared/currencies_spec.rb

@@ -25,10 +25,10 @@ describe Currencies do
       data = Currencies.for_code("PEN")
       expect(data).to be_a(Hash)
       expect(data).to include(
-        :name        => "Peruvian nuevo sol",
-        :currency    => :PEN,
-        :symbol      => "S/.",
-        :cldr_symbol => "PEN"
+        name:        "Peruvian nuevo sol",
+        currency:    :PEN,
+        symbol:      "S/.",
+        cldr_symbol: "PEN"
       )
     end
 
@@ -36,10 +36,10 @@ describe Currencies do
       data = Currencies.for_code("CAD")
       expect(data).to be_a(Hash)
       expect(data).to include(
-        :name        => "Canadian dollar",
-        :currency    => :CAD,
-        :symbol      => "$",
-        :cldr_symbol => "CA$"
+        name:        "Canadian dollar",
+        currency:    :CAD,
+        symbol:      "$",
+        cldr_symbol: "CA$"
       )
     end
 

data/spec/shared/language_codes_spec.rb

@@ -58,24 +58,24 @@ describe LanguageCodes do
 
   describe '#convert' do
     it 'converts codes between different standards' do
-      expect(LanguageCodes.convert(:Spanish, :from => :name,      :to => :bcp_47   )).to eq(:es)
-      expect(LanguageCodes.convert(:es,      :from => :bcp_47,    :to => :iso_639_1)).to eq(:es)
-      expect(LanguageCodes.convert(:es,      :from => :iso_639_1, :to => :iso_639_2)).to eq(:spa)
-      expect(LanguageCodes.convert(:spa,     :from => :iso_639_2, :to => :iso_639_3)).to eq(:spa)
-      expect(LanguageCodes.convert(:spa,     :from => :iso_639_3, :to => :name     )).to eq(:Spanish)
+      expect(LanguageCodes.convert(:Spanish, from: :name,      to: :bcp_47   )).to eq(:es)
+      expect(LanguageCodes.convert(:es,      from: :bcp_47,    to: :iso_639_1)).to eq(:es)
+      expect(LanguageCodes.convert(:es,      from: :iso_639_1, to: :iso_639_2)).to eq(:spa)
+      expect(LanguageCodes.convert(:spa,     from: :iso_639_2, to: :iso_639_3)).to eq(:spa)
+      expect(LanguageCodes.convert(:spa,     from: :iso_639_3, to: :name     )).to eq(:Spanish)
     end
 
     it 'converts from terminology iso_639_2 codes' do
-      expect(LanguageCodes.convert(:hye, :from => :iso_639_2, :to => :bcp_47)).to eq(:hy)
+      expect(LanguageCodes.convert(:hye, from: :iso_639_2, to: :bcp_47)).to eq(:hy)
     end
 
     it 'converts from alternative bcp_47 codes' do
-      expect(LanguageCodes.convert('ar-adf', :from => :bcp_47, :to => :iso_639_3)).to eq(:adf)
+      expect(LanguageCodes.convert('ar-adf', from: :bcp_47, to: :iso_639_3)).to eq(:adf)
     end
 
     it 'returns nil if conversion data is missing' do
-      expect(LanguageCodes.convert(:bsq, :from => :bcp_47, :to => :iso_639_1)).to be_nil
-      expect(LanguageCodes.convert(:FooBar, :from => :name, :to => :iso_639_1)).to be_nil
+      expect(LanguageCodes.convert(:bsq, from: :bcp_47, to: :iso_639_1)).to be_nil
+      expect(LanguageCodes.convert(:FooBar, from: :name, to: :iso_639_1)).to be_nil
     end
 
     it 'accepts strings' do
@@ -83,16 +83,16 @@ describe LanguageCodes do
     end
 
     it 'raises exception if :from or :to options are missing' do
-      [[:es, { :to => :bcp_47 }], [:es, { :from => :bcp_47 }], [:es]].each do |args|
+      [[:es, { to: :bcp_47 }], [:es, { from: :bcp_47 }], [:es]].each do |args|
         expect { LanguageCodes.convert(*args) }.to raise_exception(ArgumentError, "options :from and :to are required")
       end
     end
 
     it 'raises exception if :from or :to have invalid values' do
       [
-          [:es, { :from => :foobar, :to => :bcp_47 }],
-          [:es, { :from => :bcp_47, :to => :foobar }],
-          [:es, { :from => :foobar, :to => :foobar }]
+          [:es, { from: :foobar, to: :bcp_47 }],
+          [:es, { from: :bcp_47, to: :foobar }],
+          [:es, { from: :foobar, to: :foobar }]
       ].each do |args|
         expect { LanguageCodes.convert(*args) }.to raise_exception(ArgumentError, ':foobar is not a valid standard name')
       end

data/spec/shared/likely_subtags_spec.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Shared
+
+describe LikelySubtags do
+  def verify_subtags(locale, language, script, region)
+    expect(locale.language).to eq(language)
+    expect(locale.script).to eq(script)
+    expect(locale.region).to eq(region)
+  end
+
+  describe '.locale_for' do
+    it 'adds subtags when only the language is given' do
+      locale = LikelySubtags.locale_for('es')
+      verify_subtags(locale, 'es', 'Latn', 'ES')
+    end
+
+    it 'adds region subtag when only the language and script are given' do
+      locale = LikelySubtags.locale_for('sd')
+      verify_subtags(locale, 'sd', 'Arab', 'PK')
+
+      locale = LikelySubtags.locale_for('sd-Deva')
+      verify_subtags(locale, 'sd', 'Deva', 'IN')
+    end
+
+    it 'adds script subtag when only the language and region are given' do
+      locale = LikelySubtags.locale_for('ky')
+      verify_subtags(locale, 'ky', 'Cyrl', 'KG')
+
+      locale = LikelySubtags.locale_for('ky-TR')
+      verify_subtags(locale, 'ky', 'Latn', 'TR')
+    end
+
+    it 'corrects invalid (i.e. missing) subtags' do
+      locale = LikelySubtags.locale_for('en-foo-bar')
+      verify_subtags(locale, 'en', 'Latn', 'US')
+    end
+
+    it "doesn't add subtags when the language, script, and region are correct" do
+      locale = LikelySubtags.locale_for('en-latn-us')
+      verify_subtags(locale, 'en', 'Latn', 'US')
+    end
+
+    it "raises an error if the subtags can't be identified" do
+      locale = Locale.new('xz')
+
+      # bypass the Locale.parse in LikelySubtags.for_locale
+      expect { LikelySubtags.send(:lookup, locale) }.to(
+        raise_error(UnrecognizedSubtagsError)
+      )
+    end
+  end
+end

data/spec/shared/locale_spec.rb

@@ -0,0 +1,211 @@
+# encoding: UTF-8
+
+# Copyright 2012 Twitter, Inc
+# http://www.apache.org/licenses/LICENSE-2.0
+
+require 'spec_helper'
+
+include TwitterCldr::Shared
+
+describe Locale do
+  describe '.split' do
+    it 'splits by dashes' do
+      expect(Locale.split('pt-BR')).to eq(%w[pt BR])
+    end
+
+    it 'splits by underscores' do
+      expect(Locale.split('pt_BR')).to eq(%w[pt BR])
+    end
+
+    it 'splits by spaces' do
+      expect(Locale.split('pt BR')).to eq(%w[pt BR])
+    end
+
+    it 'splits by a combination of dashes, underscores, and spaces' do
+      expect(Locale.split('pt-Latn_BR FOO')).to eq(%w[pt Latn BR FOO])
+    end
+  end
+
+  describe '.parse' do
+    it 'correctly identifies language only' do
+      locale = Locale.parse('pt')
+      expect(locale.language).to eq('pt')
+    end
+
+    it 'correctly identifies language and region' do
+      locale = Locale.parse('pt-br')
+      expect(locale.language).to eq('pt')
+      expect(locale.region).to eq('BR')
+    end
+
+    it 'correctly identifies language and script' do
+      locale = Locale.parse('pt-latn')
+      expect(locale.language).to eq('pt')
+      expect(locale.script).to eq('Latn')
+    end
+
+    it 'correctly identifies language, script, and region' do
+      locale = Locale.parse('pt-latn-br')
+      expect(locale.language).to eq('pt')
+      expect(locale.script).to eq('Latn')
+      expect(locale.region).to eq('BR')
+    end
+
+    it 'correctly identifies variants' do
+      locale = Locale.parse('pt-fonipa')
+      expect(locale.language).to eq('pt')
+      expect(locale.variants).to eq(%w[FONIPA])
+    end
+
+    it 'correctly identifies language, script, region, and variants' do
+      locale = Locale.parse('pt-latn-br-fonipa')
+      expect(locale.language).to eq('pt')
+      expect(locale.script).to eq('Latn')
+      expect(locale.region).to eq('BR')
+      expect(locale.variants).to eq(%w[FONIPA])
+    end
+
+    it "sets the region to nil if it can't be identified" do
+      locale = Locale.parse('pt-$@')
+      expect(locale.language).to eq('pt')
+      expect(locale.region).to be_nil
+    end
+
+    it "sets the script to nil if it can't be identified" do
+      locale = Locale.parse('pt-$@-br')
+      expect(locale.language).to eq('pt')
+      expect(locale.region).to eq('BR')
+      expect(locale.script).to be_nil
+    end
+
+    it 'replaces deprecated language subtags' do
+      locale = Locale.parse('por')
+      expect(locale.language).to eq('pt')
+    end
+
+    it 'replaces deprecated region/territory subtags' do
+      locale = Locale.parse('pt-bra')
+      expect(locale.region).to eq('BR')
+    end
+
+    it 'does not modify grandfathered locales' do
+      locale = Locale.parse('i-navajo')
+      expect(locale.language).to eq('i-navajo')
+    end
+
+    it 'removes script placeholder subtags' do
+      locale = Locale.parse('zh-zzzz-sg')
+      expect(locale.script).to be_nil
+    end
+
+    it 'removes region placeholder subtags' do
+      locale = Locale.parse('zh-hans-zz')
+      expect(locale.region).to be_nil
+    end
+
+    it "sets language to 'und' if it can't be identified" do
+      locale = Locale.parse('$@')
+      expect(locale.language).to eq('und')
+    end
+  end
+
+  describe '.valid?' do
+    it 'returns true if all subtags are valid' do
+      expect(Locale.valid?('en')).to be_true
+      expect(Locale.valid?('en-latn')).to be_true
+      expect(Locale.valid?('en-latn-us')).to be_true
+      expect(Locale.valid?('en-latn-us-fonipa')).to be_true
+    end
+
+    it 'returns false if any subtag is invalid' do
+      expect(Locale.valid?('xz')).to be_false
+      expect(Locale.valid?('en-fooo')).to be_false
+      expect(Locale.valid?('en-latn-XZ')).to be_false
+      expect(Locale.valid?('en-latn-us-foooo')).to be_false
+    end
+  end
+
+  describe '.grandfathered?' do
+    it 'returns true if the given locale is considered "grandfathered"' do
+      expect(Locale.grandfathered?('i-navajo')).to be_true
+    end
+
+    it 'returns false if the given locale is not considered "grandfathered"' do
+      expect(Locale.grandfathered?('en-latn-us')).to be_false
+    end
+  end
+
+  # see likely_subtags_spec.rb for the complete likely subtags test suite
+  describe '.parse_likely' do
+    it 'returns a Locale instance' do
+      locale = Locale.parse_likely('zh')
+      expect(locale).to be_a(Locale)
+    end
+
+    it 'does not find subtags for grandfathered locales' do
+      locale = Locale.parse_likely('i-navajo')
+      expect(locale.language).to eq('i-navajo')
+    end
+  end
+
+  context 'with a locale instance' do
+    let(:locale) { Locale.new('ko', nil, 'KR') }
+
+    describe '#full_script' do
+      it 'calculates the long name of the script using Unicode property data' do
+        locale = Locale.new('ru_RU').maximize
+        expect(locale.script).to eq('Cyrl')
+        expect(locale.full_script).to eq('Cyrillic')
+      end
+
+      it 'returns the abbreviated name if no long name can be found in property data' do
+        max_locale = locale.maximize
+        expect(max_locale.script).to eq('Kore')
+        expect(max_locale.full_script).to eq('Kore')
+      end
+    end
+
+    # see likely_subtags_spec.rb for the complete likely subtags test suite
+    describe '#maximize' do
+      it 'returns a Locale instance' do
+        expect(locale.maximize).to be_a(Locale)
+      end
+
+      it 'does not modify grandfathered locales' do
+        locale = Locale.new('i-navajo').maximize
+        expect(locale.language).to eq('i-navajo')
+      end
+    end
+
+    describe '#dasherized' do
+      it 'adds dashes between the subtags' do
+        expect(locale.dasherized).to eq('ko-KR')
+      end
+    end
+
+    describe '#join' do
+      it 'adds a default underscore separator between the subtags' do
+        expect(locale.join).to eq('ko_KR')
+
+        # method aliases
+        expect(locale.underscored).to eq('ko_KR')
+        expect(locale.to_s).to eq('ko_KR')
+      end
+
+      it 'adds the given separator between the subtags' do
+        expect(locale.join('|')).to eq('ko|KR')
+      end
+    end
+
+    def to_a
+      it 'returns an array with all the subtags' do
+        expect(locale.to_a).to eq(%w[ko KR])
+      end
+
+      it 'includes variants if they are present' do
+        locale.variants << 'FONIPA'
+        expect(locale.to_a).to eq(%w[ko KR FONIPA])
+      end
+    end
+  end
+end

data/spec/shared/numbers_spec.rb

@@ -9,21 +9,21 @@ include TwitterCldr::Shared
 
 describe Numbers do
   describe "#symbols" do
-    let(:symbols) { { :nan => 'NaN', :minus_sign => '-' } }
+    let(:symbols) { { nan: 'NaN', minus_sign: '-' } }
 
     it 'returns numerical symbols for default locale' do
       stub(TwitterCldr).locale { :jp }
-      stub(TwitterCldr).get_locale_resource(:jp, :numbers) { { :jp => { :numbers => { :symbols => symbols } } } }
+      stub(TwitterCldr).get_locale_resource(:jp, :numbers) { { jp: { numbers: { symbols: symbols } } } }
       expect(TwitterCldr::Shared::Numbers.symbols).to eq(symbols)
     end
 
     it 'returns numerical symbols for default locale' do
-      stub(TwitterCldr).get_locale_resource(:np, :numbers) { { :np => { :numbers => { :symbols => symbols } } } }
+      stub(TwitterCldr).get_locale_resource(:np, :numbers) { { np: { numbers: { symbols: symbols } } } }
       expect(TwitterCldr::Shared::Numbers.symbols(:np)).to eq(symbols)
     end
 
     it 'converts locale' do
-      stub(TwitterCldr).get_locale_resource(:'zh-Hant', :numbers) { { :'zh-Hant' => { :numbers => { :symbols => symbols } } } }
+      stub(TwitterCldr).get_locale_resource(:'zh-Hant', :numbers) { { :'zh-Hant' => { numbers: { symbols: symbols } } } }
       expect(TwitterCldr::Shared::Numbers.symbols('zh-tw')).to eq(symbols)
     end