twitter_cldr 3.2.1 → 3.3.0

data/spec/bidi/bidi_spec.rb

@@ -20,7 +20,7 @@ def expand_bitset_str(bitset)
 end
 
 describe Bidi do
-  it "should pass the derived tests in classpath_bidi_test.txt", :slow => true do
+  it "should pass the derived tests in classpath_bidi_test.txt", slow: true do
     expected_level_data = []
     expected_reorder_data = []
     num_failed = 0
@@ -47,7 +47,7 @@ describe Bidi do
           expand_bitset_str(bitset).each_with_index do |check, index|
             if check
               types = input.split(" ").map(&:to_sym)
-              bidi = TwitterCldr::Shared::Bidi.from_type_array(types, :direction => DIRECTIONS[index], :default_direction => :LTR)
+              bidi = TwitterCldr::Shared::Bidi.from_type_array(types, direction: DIRECTIONS[index], default_direction: :LTR)
 
               passed = bidi.levels.each_with_index.all? do |level, idx|
                 level == expected_level_data[idx]

data/spec/collation/collation_spec.rb

@@ -20,7 +20,7 @@ describe 'Unicode Collation Algorithm' do
     run_test(SHORT_COLLATION_TEST_PATH)
   end
 
-  it 'passes all the tests in CollationTest_CLDR_NON_IGNORABLE.txt', :slow => true do
+  it 'passes all the tests in CollationTest_CLDR_NON_IGNORABLE.txt', slow: true do
     prepare_full_test
     run_test(FULL_COLLATION_TEST_PATH)
   end

data/spec/collation/collator_spec.rb

@@ -108,7 +108,7 @@ describe Collator do
     before(:each) { mock(TrieLoader).load_default_trie { trie } }
 
     describe 'calculating sort key' do
-      before(:each) { mock(TwitterCldr::Collation::SortKeyBuilder).build(collation_elements, :case_first => nil, :maximum_level => nil) { sort_key } }
+      before(:each) { mock(TwitterCldr::Collation::SortKeyBuilder).build(collation_elements, case_first: nil, maximum_level: nil) { sort_key } }
 
       it 'calculates sort key for a string' do
         mock(collator).get_collation_elements(string) { collation_elements }
@@ -128,26 +128,26 @@ describe Collator do
       
       it 'passes case-first sort option to sort key builder' do
         mock(TwitterCldr::Collation::TrieLoader).load_tailored_trie(locale, trie) { Trie.new }
-        mock(TwitterCldr::Collation::TrieBuilder).tailoring_data(locale) { { :collator_options => { :case_first => case_first } } }
+        mock(TwitterCldr::Collation::TrieBuilder).tailoring_data(locale) { { collator_options: { case_first: case_first } } }
 
         collator = Collator.new(locale)
 
         mock(collator).get_collation_elements(code_points) { collation_elements }
-        mock(TwitterCldr::Collation::SortKeyBuilder).build(collation_elements, :case_first => case_first, :maximum_level => nil) { sort_key }
+        mock(TwitterCldr::Collation::SortKeyBuilder).build(collation_elements, case_first: case_first, maximum_level: nil) { sort_key }
 
         expect(collator.get_sort_key(code_points)).to eq(sort_key)
       end
 
       it 'passes maximum_level option to sort key builder' do 
         mock(TwitterCldr::Collation::TrieLoader).load_tailored_trie(locale, trie) { Trie.new }
-        mock(TwitterCldr::Collation::TrieBuilder).tailoring_data(locale) { { :collator_options => { :case_first => case_first } } }
+        mock(TwitterCldr::Collation::TrieBuilder).tailoring_data(locale) { { collator_options: { case_first: case_first } } }
 
         collator = Collator.new(locale)
 
         mock(collator).get_collation_elements(code_points) { collation_elements }
-        mock(TwitterCldr::Collation::SortKeyBuilder).build(collation_elements, :case_first => case_first, :maximum_level => maximum_level) { sort_key }
+        mock(TwitterCldr::Collation::SortKeyBuilder).build(collation_elements, case_first: case_first, maximum_level: maximum_level) { sort_key }
 
-        expect(collator.get_sort_key(code_points, :maximum_level => maximum_level)).to eq(sort_key)
+        expect(collator.get_sort_key(code_points, maximum_level: maximum_level)).to eq(sort_key)
       end
 
     end

data/spec/collation/sort_key_builder_spec.rb

@@ -31,16 +31,16 @@ describe SortKeyBuilder do
 
     it 'accepts case-first option as an option' do
       SortKeyBuilder::VALID_CASE_FIRST_OPTIONS.each do |case_first|
-        expect { SortKeyBuilder.new([], :case_first => case_first) }.not_to raise_error
+        expect { SortKeyBuilder.new([], case_first: case_first) }.not_to raise_error
       end
     end
 
     it 'raises an ArgumentError for invalid case-first option' do
-      expect { SortKeyBuilder.new([], :case_first => :wat) }.to raise_error(ArgumentError)
+      expect { SortKeyBuilder.new([], case_first: :wat) }.to raise_error(ArgumentError)
     end
 
     it 'raises an ArgumentError for an invalid maximum_level option' do
-      expect { SortKeyBuilder.new([], :maximum_level => :wat) }.to raise_error(ArgumentError)
+      expect { SortKeyBuilder.new([], maximum_level: :wat) }.to raise_error(ArgumentError)
     end
 
     it 'raises an ArgumentError for non-hash second argument' do
@@ -113,29 +113,29 @@ describe SortKeyBuilder do
 
       context 'when case_first is :upper' do
         it 'inverts case bits and subtract bottom addition from bytes that are smaller than common' do
-          expect(SortKeyBuilder.new([[0, 0, 9], [0, 0, 80], [0, 0, 143]], :case_first => :upper).bytes_array).to eq([1, 1, 201, 80, 15])
+          expect(SortKeyBuilder.new([[0, 0, 9], [0, 0, 80], [0, 0, 143]], case_first: :upper).bytes_array).to eq([1, 1, 201, 80, 15])
         end
 
         it 'compresses tertiary weights' do
-          expect(SortKeyBuilder.new([[0, 0, 5], [0, 0, 5], [0, 0, 39], [0, 0, 5], [0, 0, 5]], :case_first => :upper).bytes_array).to eq([1, 1, 0xC4, 0xE7, 0xC3])
+          expect(SortKeyBuilder.new([[0, 0, 5], [0, 0, 5], [0, 0, 39], [0, 0, 5], [0, 0, 5]], case_first: :upper).bytes_array).to eq([1, 1, 0xC4, 0xE7, 0xC3])
         end
 
         it 'compresses tertiary weights into multiple bytes if necessary' do
-          expect(SortKeyBuilder.new([[0, 0, 5]] * 100, :case_first => :upper).bytes_array).to eq([1, 1, 0x9C, 0x9C, 0xB3])
+          expect(SortKeyBuilder.new([[0, 0, 5]] * 100, case_first: :upper).bytes_array).to eq([1, 1, 0x9C, 0x9C, 0xB3])
         end
       end
 
       context 'when case_first is :lower' do
         it 'leaves case bits and adds top addition to bytes that are greater than common' do
-          expect(SortKeyBuilder.new([[0, 0, 9], [0, 0, 80], [0, 0, 143]], :case_first => :lower).bytes_array).to eq([1, 1, 73, 144, 207])
+          expect(SortKeyBuilder.new([[0, 0, 9], [0, 0, 80], [0, 0, 143]], case_first: :lower).bytes_array).to eq([1, 1, 73, 144, 207])
         end
 
         it 'compresses tertiary weights' do
-          expect(SortKeyBuilder.new([[0, 0, 5], [0, 0, 5], [0, 0, 39], [0, 0, 5], [0, 0, 5]], :case_first => :lower).bytes_array).to eq([1, 1, 0x44, 0x67, 6])
+          expect(SortKeyBuilder.new([[0, 0, 5], [0, 0, 5], [0, 0, 39], [0, 0, 5], [0, 0, 5]], case_first: :lower).bytes_array).to eq([1, 1, 0x44, 0x67, 6])
         end
 
         it 'compresses tertiary weights into multiple bytes if necessary' do
-          expect(SortKeyBuilder.new([[0, 0, 5]] * 100, :case_first => :lower).bytes_array).to eq([1, 1, 0x1A, 0x1A, 0x1A, 0x1A, 0x14])
+          expect(SortKeyBuilder.new([[0, 0, 5]] * 100, case_first: :lower).bytes_array).to eq([1, 1, 0x1A, 0x1A, 0x1A, 0x1A, 0x14])
         end
       end
     end
@@ -143,12 +143,12 @@ describe SortKeyBuilder do
     describe ":maximum_level option" do
       context "when :maximum_level is 2" do
         it 'does not include tertiary weights' do
-          expect(SortKeyBuilder.new([[63, 13, 149], [66, 81, 143]], :maximum_level => 2).bytes_array).to eq([63, 66, 1, 13, 81])
+          expect(SortKeyBuilder.new([[63, 13, 149], [66, 81, 143]], maximum_level: 2).bytes_array).to eq([63, 66, 1, 13, 81])
         end
       end
       context "when :maximum_level is 1" do
         it 'only includes primary weights' do
-          expect(SortKeyBuilder.new([[63, 13, 149], [66, 81, 143]], :maximum_level => 1).bytes_array).to eq([63, 66])
+          expect(SortKeyBuilder.new([[63, 13, 149], [66, 81, 143]], maximum_level: 1).bytes_array).to eq([63, 66])
         end
       end
     end

data/spec/collation/tailoring_spec.rb

@@ -12,7 +12,7 @@ describe 'Unicode collation tailoring' do
   # Test data is taken from http://unicode.org/cldr/trac/browser/tags/release-2-0-1/test/
   # Test files format: # - comments, // - pending tests.
   #
-  it 'passes tailoring test for each supported locale', :slow => true do
+  it 'passes tailoring test for each supported locale', slow: true do
     TwitterCldr.supported_locales.each do |locale|
       tailor_file = File.join(File.dirname(__FILE__), 'tailoring_tests', "#{locale}.txt")
 

data/spec/collation/trie_dumps_spec.rb

@@ -7,7 +7,7 @@ require 'spec_helper'
 
 include TwitterCldr::Collation
 
-describe 'trie dumps', :slow => true do
+describe 'trie dumps', slow: true do
   let(:default_trie) { TrieBuilder.load_default_trie }
   let(:error_message) { 'expected trie dump to be up-to-date.' }
 

data/spec/data_readers/date_time_data_reader_spec.rb

@@ -13,7 +13,7 @@ describe DateTimeDataReader do
   describe "#initialize" do
     it "chooses gregorian as the calendar type if none is specified" do
       expect(DateTimeDataReader.new(:es).calendar_type).to eq(:gregorian)
-      expect(DateTimeDataReader.new(:es, :calendar_type => :julian).calendar_type).to eq(:julian)
+      expect(DateTimeDataReader.new(:es, calendar_type: :julian).calendar_type).to eq(:julian)
     end
   end
 

data/spec/data_readers/number_data_reader_spec.rb

@@ -12,20 +12,33 @@ describe NumberDataReader do
 
   describe "#get_key_for" do
     it "builds a power-of-ten key based on the number of digits in the input" do
-      (3..15).each { |i| expect(data_reader.send(:get_key_for, "1337#{"0" * (i - 3)}")).to eq(10 ** i) }
+      (3..15).each do |i|
+        value = data_reader.send(:get_key_for, "1337#{"0" * (i - 3)}")
+        expect(value).to eq((10 ** i).to_s.to_sym)
+      end
+    end
+  end
+
+  describe '#format_number' do
+    it 'works with options' do
+      expect(data_reader.format_number(1000, precision: 2)).to eq('1,000.00')
+    end
+
+    it "works when options aren't specified" do
+      expect(data_reader.format_number(1000)).to eq('1,000')
     end
   end
 
   describe "#pattern" do
-    let(:symbols) { { :nan => 'NaN', :minus_sign => '<->' } } # unique locale-specific minus sign
+    let(:symbols) { { nan: 'NaN', minus_sign: '<->' } } # unique locale-specific minus sign
 
     before(:each) do
       stub(TwitterCldr).get_locale_resource(:en, :numbers) {
         {
-          :en => {
-            :numbers => {
-              :formats => { :decimal => { :patterns => { :default => "#,##0.###" } } },
-              :symbols => symbols
+          en: {
+            numbers: {
+              formats: { decimal: { patterns: { default: "#,##0.###" } } },
+              symbols: symbols
             }
           }
         }

data/spec/formatters/calendars/datetime_formatter_spec.rb

@@ -16,7 +16,7 @@ describe DateTimeFormatter do
 
   describe 'plaintext' do
     it "removes single quotes around plaintext tokens" do
-      tokens = [Token.new(:value => "'at'", :type => 'plaintext')]
+      tokens = [Token.new(value: "'at'", type: 'plaintext')]
       date = Date.new(2010, 1, 10)
       expect(@formatter.format(tokens, date, {})).to eq("at")
     end

data/spec/formatters/numbers/abbreviated/abbreviated_number_formatter_spec.rb

@@ -9,7 +9,7 @@ include TwitterCldr::Formatters
 include TwitterCldr::Tokenizers
 
 describe AbbreviatedNumberFormatter do
-  let(:formatter) { AbbreviatedNumberFormatter.new(:locale => :en) }
+  let(:formatter) { AbbreviatedNumberFormatter.new(locale: :en) }
   let(:number) { 123456 }
 
   describe "#truncate_number" do

data/spec/formatters/numbers/abbreviated/long_decimal_formatter_spec.rb

@@ -9,7 +9,7 @@ include TwitterCldr::Formatters
 
 describe LongDecimalFormatter do
   let(:data_reader) do
-    TwitterCldr::DataReaders::NumberDataReader.new(locale, :type => :long_decimal)
+    TwitterCldr::DataReaders::NumberDataReader.new(locale, type: :long_decimal)
   end
 
   def format_number(number, options = {})
@@ -65,11 +65,11 @@ describe LongDecimalFormatter do
     end
 
     it "respects the :precision option" do
-      expect(format_number(12345, :precision => 3)).to match_normalized("12.345 thousand")
+      expect(format_number(12345, precision: 3)).to match_normalized("12.345 thousand")
     end
 
     it "respects the :precision option for negative numbers" do
-      expect(format_number(-12345, :precision => 3)).to match_normalized("-12.345 thousand")
+      expect(format_number(-12345, precision: 3)).to match_normalized("-12.345 thousand")
     end
   end
 
@@ -78,11 +78,11 @@ describe LongDecimalFormatter do
 
     it "respects pluralization rules" do
       expect(format_number(1123)).to match_normalized("1 тысяча")
-      expect(format_number(1123, :precision => 3)).to match_normalized("1,123 тысячи")
+      expect(format_number(1123, precision: 3)).to match_normalized("1,123 тысячи")
     end
 
     it 'works with :few in Russian' do
-      expect(format_number(7123, :precision => 3)).to match_normalized("7,123 тысячи")
+      expect(format_number(7123, precision: 3)).to match_normalized("7,123 тысячи")
       expect(format_number(7123)).to match_normalized("7 тысяч") # different pluralization when precision is 0
     end
   end

data/spec/formatters/numbers/abbreviated/short_decimal_formatter_spec.rb

@@ -9,7 +9,7 @@ include TwitterCldr::Formatters
 
 describe ShortDecimalFormatter do
   let(:data_reader) do
-    TwitterCldr::DataReaders::NumberDataReader.new(locale, :type => :short_decimal)
+    TwitterCldr::DataReaders::NumberDataReader.new(locale, type: :short_decimal)
   end
 
   def format_number(number, options = {})
@@ -70,12 +70,12 @@ describe ShortDecimalFormatter do
 
     it "respects the :precision option" do
       number = 12345
-      expect(format_number(number, :precision => 3)).to match_normalized("12.345K")
+      expect(format_number(number, precision: 3)).to match_normalized("12.345K")
     end
 
     it "respects the :precision option for negative numbers" do
       number = -12345
-      expect(format_number(number, :precision => 3)).to match_normalized("-12.345K")
+      expect(format_number(number, precision: 3)).to match_normalized("-12.345K")
     end
   end
 
@@ -107,4 +107,4 @@ describe ShortDecimalFormatter do
   end
 
   xit 'respects pluralization rules'
-end
+end

data/spec/formatters/numbers/currency_formatter_spec.rb

@@ -9,7 +9,7 @@ include TwitterCldr::Formatters
 
 describe CurrencyFormatter do
   describe "#format" do
-    let(:data_reader) { TwitterCldr::DataReaders::NumberDataReader.new(:msa, :type => :currency) }
+    let(:data_reader) { TwitterCldr::DataReaders::NumberDataReader.new(:msa, type: :currency) }
     let(:tokenizer) { data_reader.tokenizer }
     let(:formatter) { data_reader.formatter }
 
@@ -29,35 +29,35 @@ 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
-      expect(format_currency(12, :symbol => "S/.")).to eq("S/.12.00")
+      expect(format_currency(12, symbol: "S/.")).to eq("S/.12.00")
     end
 
     it "should use the currency code as the symbol if the currency code can't be identified" do
-      expect(format_currency(12, :currency => "XYZ")).to eq("XYZ12.00")
+      expect(format_currency(12, currency: "XYZ")).to eq("XYZ12.00")
     end
 
     it "should respect the :use_cldr_symbol option" do
-      expect(format_currency(12, :currency => "CAD")).to eq("$12.00")
-      expect(format_currency(12, :currency => "CAD", :use_cldr_symbol => true)).to eq("CA$12.00")
+      expect(format_currency(12, currency: "CAD")).to eq("$12.00")
+      expect(format_currency(12, currency: "CAD", use_cldr_symbol: true)).to eq("CA$12.00")
     end
 
     it "should use the currency symbol for the corresponding currency code" do
-      expect(format_currency(12, :currency => "THB")).to eq("฿12.00")
+      expect(format_currency(12, currency: "THB")).to eq("฿12.00")
     end
 
     it "overrides the default precision" do
-      expect(format_currency(12, :precision => 3)).to eq("$12.000")
+      expect(format_currency(12, precision: 3)).to eq("$12.000")
     end
 
     it "should use the currency-specific default precision" do
-      expect(format_currency(12, :currency => "TND")).to eq("TND12.000")
+      expect(format_currency(12, currency: "TND")).to eq("TND12.000")
     end
 
     it "should use the currency rounding for the currency code" do
       # The rounding value for CHF changed from 5 to 0 in CLDR 23, so we have to pass
       # :rounding explicitly to test its effects.
-      expect(format_currency(12.03, :currency => "CHF", :rounding => 5)).to eq("CHF12.05")
-      expect(format_currency(12.02, :currency => "CHF", :rounding => 5)).to eq("CHF12.00")
+      expect(format_currency(12.03, currency: "CHF", rounding: 5)).to eq("CHF12.05")
+      expect(format_currency(12.02, currency: "CHF", rounding: 5)).to eq("CHF12.00")
     end
   end
 end

data/spec/formatters/numbers/decimal_formatter_spec.rb

@@ -8,7 +8,7 @@ require 'spec_helper'
 include TwitterCldr::Formatters
 
 describe DecimalFormatter do
-  let(:data_reader) { TwitterCldr::DataReaders::NumberDataReader.new(:nl, :type => :decimal) }
+  let(:data_reader) { TwitterCldr::DataReaders::NumberDataReader.new(:nl, type: :decimal) }
   let(:formatter) { data_reader.formatter }
   let(:tokenizer) { data_reader.tokenizer }
   let(:negative_number) { -12 }
@@ -31,7 +31,7 @@ describe DecimalFormatter do
       { number => "12,000", negative_number => "-12,000" }.each_pair do |num, formatted|
         pattern = data_reader.pattern(num)
         tokens = tokenizer.tokenize(pattern)
-        expect(formatter.format(tokens, num, :precision => 3)).to eq(formatted)
+        expect(formatter.format(tokens, num, precision: 3)).to eq(formatted)
       end
     end
   end

data/spec/formatters/numbers/helpers/fraction_spec.rb

@@ -11,18 +11,18 @@ include TwitterCldr::Tokenizers
 describe Fraction do
   describe "#apply" do
     it "test: formats a fraction" do
-      token = Token.new(:value => '###.##', :type => :pattern)
+      token = Token.new(value: '###.##', type: :pattern)
       expect(Fraction.new(token).apply('45')).to eq('.45')
     end
 
     it "test: pads zero digits on the right side" do
-      token = Token.new(:value => '###.0000#', :type => :pattern)
+      token = Token.new(value: '###.0000#', type: :pattern)
       expect(Fraction.new(token).apply('45')).to eq('.45000')
     end
 
     it "test: :precision option overrides format precision" do
-      token = Token.new(:value => '###.##', :type => :pattern)
-      expect(Fraction.new(token).apply('78901', :precision => 5)).to eq('.78901')
+      token = Token.new(value: '###.##', type: :pattern)
+      expect(Fraction.new(token).apply('78901', precision: 5)).to eq('.78901')
     end
   end
 end

data/spec/formatters/numbers/helpers/integer_spec.rb

@@ -12,7 +12,7 @@ describe Integer do
   describe "#apply" do
     context "with the ### format" do
       before(:each) do
-        @token = Token.new(:value => "###", :type => :pattern)
+        @token = Token.new(value: "###", type: :pattern)
       end
 
       it "test: interpolates a number" do
@@ -28,13 +28,13 @@ describe Integer do
       end
 
       it "test: does not round with :precision => 1" do
-        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123.55, :precision => 1)).to eq('123')
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123.55, precision: 1)).to eq('123')
       end
     end
 
     context "with the #,## format" do
       before(:each) do
-        @token = Token.new(:value => "#,##", :type => :pattern)
+        @token = Token.new(value: "#,##", type: :pattern)
       end
 
       it "test: single group" do
@@ -48,7 +48,7 @@ describe Integer do
 
     context "with the #,##0.## format" do
       before(:each) do
-        @token = Token.new(:value => "#,##0.##", :type => :pattern)
+        @token = Token.new(value: "#,##0.##", type: :pattern)
       end
 
       it "test: ignores a fraction part given in the format string" do
@@ -62,43 +62,48 @@ describe Integer do
 
     context "miscellaneous formats" do
       it "test: interpolates a number on the right side" do
-        token = Token.new(:value => "0###", :type => :pattern)
+        token = Token.new(value: "0###", type: :pattern)
         expect(TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123)).to eq('0123')
       end
 
       it "test: strips optional digits" do
-        token = Token.new(:value => "######", :type => :pattern)
+        token = Token.new(value: "######", type: :pattern)
         expect(TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123)).to eq('123')
       end
 
       it "test: multiple groups with a primary and secondary group size" do
-        token = Token.new(:value => "#,##,##0", :type => :pattern)
+        token = Token.new(value: "#,##,##0", type: :pattern)
         expect(TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123456789)).to eq('12,34,56,789')
       end
 
+      it "test: multiple groups with a primary and secondary group size and a short string" do
+        token = Token.new(value: "#,##,##0", type: :pattern)
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123)).to eq('123')
+      end
+
       it "test: does not group when no digits left of the grouping position" do
-        token = Token.new(:value => "#,###", :type => :pattern)
+        token = Token.new(value: "#,###", type: :pattern)
         expect(TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123)).to eq('123')
       end
 
       it "test: cldr example #,##0.### => 1 234" do
-        token = Token.new(:value => "#,##0.###", :type => :pattern)
-        expect(TwitterCldr::Formatters::Numbers::Integer.new(token, :group => ' ').apply(1234.567)).to eq('1 234')
+        token = Token.new(value: "#,##0.###", type: :pattern)
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(token, group: ' ').apply(1234.567)).to eq('1 234')
       end
 
       it "test: cldr example ###0.##### => 1234" do
-        token = Token.new(:value => "###0.#####", :type => :pattern)
-        expect(TwitterCldr::Formatters::Numbers::Integer.new(token, :group => ' ').apply(1234.567)).to eq('1234')
+        token = Token.new(value: "###0.#####", type: :pattern)
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(token, group: ' ').apply(1234.567)).to eq('1234')
       end
 
       it "test: cldr example ###0.0000# => 1234" do
-        token = Token.new(:value => "###0.0000#", :type => :pattern)
-        expect(TwitterCldr::Formatters::Numbers::Integer.new(token, :group => ' ').apply(1234.567)).to eq('1234')
+        token = Token.new(value: "###0.0000#", type: :pattern)
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(token, group: ' ').apply(1234.567)).to eq('1234')
       end
 
       it "test: cldr example 00000.0000 => 01234" do
-        token = Token.new(:value => "00000.0000", :type => :pattern)
-        expect(TwitterCldr::Formatters::Numbers::Integer.new(token, :group => ' ').apply(1234.567)).to eq('01234')
+        token = Token.new(value: "00000.0000", type: :pattern)
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(token, group: ' ').apply(1234.567)).to eq('01234')
       end
     end
   end

data/spec/formatters/numbers/number_formatter_spec.rb

@@ -8,7 +8,7 @@ require 'spec_helper'
 include TwitterCldr::Formatters
 
 describe NumberFormatter do
-  let(:data_reader) { TwitterCldr::DataReaders::NumberDataReader.new(:sv, :type => :decimal) }
+  let(:data_reader) { TwitterCldr::DataReaders::NumberDataReader.new(:sv, type: :decimal) }
   let(:formatter) { data_reader.formatter }
   let(:tokenizer) { data_reader.tokenizer }
 
@@ -46,12 +46,12 @@ describe NumberFormatter do
 
   describe "#parse_number" do
     it "should round and split the given number by decimal" do
-      expect(formatter.send(:parse_number, 12, :precision => 0)).to eq(["12"])
-      expect(formatter.send(:parse_number, 12.2, :precision => 0)).to eq(["12"])
-      expect(formatter.send(:parse_number, 12.5, :precision => 0)).to eq(["13"])
-      expect(formatter.send(:parse_number, 12.25, :precision => 1)).to eq(["12", "3"])
-      expect(formatter.send(:parse_number, 12.25, :precision => 2)).to eq(["12", "25"])
-      expect(formatter.send(:parse_number, 12.25, :precision => 3)).to eq(["12", "250"])
+      expect(formatter.send(:parse_number, 12, precision: 0)).to eq(["12"])
+      expect(formatter.send(:parse_number, 12.2, precision: 0)).to eq(["12"])
+      expect(formatter.send(:parse_number, 12.5, precision: 0)).to eq(["13"])
+      expect(formatter.send(:parse_number, 12.25, precision: 1)).to eq(["12", "3"])
+      expect(formatter.send(:parse_number, 12.25, precision: 2)).to eq(["12", "25"])
+      expect(formatter.send(:parse_number, 12.25, precision: 3)).to eq(["12", "250"])
     end
   end
 
@@ -71,11 +71,11 @@ describe NumberFormatter do
 
     context "should respect the :precision option" do
       it "formats with precision of 0" do
-        expect(format_number(12.1, :precision => 0)).to eq("12")
+        expect(format_number(12.1, precision: 0)).to eq("12")
       end
 
       it "rounds and formats with precision of 1" do
-        expect(format_number(12.25, :precision => 1)).to eq("12,3")
+        expect(format_number(12.25, precision: 1)).to eq("12,3")
       end
     end
 

data/spec/formatters/numbers/percent_formatter_spec.rb

@@ -8,7 +8,7 @@ require 'spec_helper'
 include TwitterCldr::Formatters
 
 describe PercentFormatter do
-  let(:data_reader) { TwitterCldr::DataReaders::NumberDataReader.new(:da, :type => :percent) }
+  let(:data_reader) { TwitterCldr::DataReaders::NumberDataReader.new(:da, type: :percent) }
   let(:formatter) { data_reader.formatter }
   let(:tokenizer) { data_reader.tokenizer }
   let(:negative_number) { -12 }
@@ -29,6 +29,6 @@ describe PercentFormatter do
   it "should respect the :precision option" do
     pattern = data_reader.pattern(negative_number)
     tokens = tokenizer.tokenize(pattern)
-    expect(formatter.format(tokens, negative_number, :precision => 3)).to match_normalized("-12,000 %")
+    expect(formatter.format(tokens, negative_number, precision: 3)).to match_normalized("-12,000 %")
   end
 end

data/spec/formatters/numbers/rbnf/rbnf_spec.rb

@@ -54,17 +54,17 @@ describe RbnfFormatter do
             describe rule_set_name.gsub("-", " ") do
 
               # running basic test suite only runs spellout-numbering tests (for speed)
-              it "formats correctly", :slow => rule_set_name != "spellout-numbering" do
+              it "formats correctly", slow: rule_set_name != "spellout-numbering" do
                 test_data[group_name][rule_set_name].each_pair do |number, expected|
                   got = formatter.format(number, {
-                    :rule_group => group_name,
-                    :rule_set => rule_set_name
+                    rule_group: group_name,
+                    rule_set: rule_set_name
                   })
 
                   if got != expected
                     opts = {
-                      :locale => locale, :group => group_name,
-                      :rule_set => rule_set_name, :number => number
+                      locale: locale, group: group_name,
+                      rule_set: rule_set_name, number: number
                     }
 
                     unless allowed_failure?(opts)