twitter_cldr 3.0.1 → 3.0.2

data/spec/formatters/list_formatter_spec.rb

@@ -10,11 +10,11 @@ include TwitterCldr::Formatters
 describe ListFormatter do
   describe '#initialize' do
     it 'fetches locale from options hash' do
-      ListFormatter.new(:pt).locale.should == :pt
+      expect(ListFormatter.new(:pt).locale).to eq(:pt)
     end
 
     it "uses default locale if it's not passed in options hash" do
-      ListFormatter.new.locale.should == TwitterCldr.locale
+      expect(ListFormatter.new.locale).to eq(TwitterCldr.locale)
     end
   end
 
@@ -27,9 +27,9 @@ describe ListFormatter do
       end
 
       it "formats English lists correctly using various types" do
-        @formatter.format(list).should == "larry, curly, and moe"
-        @formatter.format(list, :unit).should == "larry, curly, moe"
-        @formatter.format(list, :"unit-narrow").should == "larry curly moe"
+        expect(@formatter.format(list)).to eq("larry, curly, and moe")
+        expect(@formatter.format(list, :unit)).to eq("larry, curly, moe")
+        expect(@formatter.format(list, :"unit-narrow")).to eq("larry curly moe")
       end
     end
 
@@ -39,9 +39,9 @@ describe ListFormatter do
       end
 
       it "formats Spanish lists correctly using various types" do
-        @formatter.format(list).should == "larry, curly y moe"
-        @formatter.format(list, :unit).should == "larry, curly y moe"
-        @formatter.format(list, :"unit-narrow").should == "larry curly moe"
+        expect(@formatter.format(list)).to eq("larry, curly y moe")
+        expect(@formatter.format(list, :unit)).to eq("larry, curly y moe")
+        expect(@formatter.format(list, :"unit-narrow")).to eq("larry curly moe")
       end
     end
   end

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

@@ -12,26 +12,26 @@ describe AbbreviatedNumberFormatter do
 
   describe "#transform_number" do
     it "chops off the number to the necessary number of sig figs" do
-      formatter.send(:transform_number, 10 ** 3).should == 1
-      formatter.send(:transform_number, 10 ** 4).should == 10
-      formatter.send(:transform_number, 10 ** 5).should == 100
-      formatter.send(:transform_number, 10 ** 6).should == 1
-      formatter.send(:transform_number, 10 ** 7).should == 10
-      formatter.send(:transform_number, 10 ** 8).should == 100
-      formatter.send(:transform_number, 10 ** 9).should == 1
-      formatter.send(:transform_number, 10 ** 10).should == 10
-      formatter.send(:transform_number, 10 ** 11).should == 100
-      formatter.send(:transform_number, 10 ** 12).should == 1
-      formatter.send(:transform_number, 10 ** 13).should == 10
-      formatter.send(:transform_number, 10 ** 14).should == 100
+      expect(formatter.send(:transform_number, 10 ** 3)).to eq(1)
+      expect(formatter.send(:transform_number, 10 ** 4)).to eq(10)
+      expect(formatter.send(:transform_number, 10 ** 5)).to eq(100)
+      expect(formatter.send(:transform_number, 10 ** 6)).to eq(1)
+      expect(formatter.send(:transform_number, 10 ** 7)).to eq(10)
+      expect(formatter.send(:transform_number, 10 ** 8)).to eq(100)
+      expect(formatter.send(:transform_number, 10 ** 9)).to eq(1)
+      expect(formatter.send(:transform_number, 10 ** 10)).to eq(10)
+      expect(formatter.send(:transform_number, 10 ** 11)).to eq(100)
+      expect(formatter.send(:transform_number, 10 ** 12)).to eq(1)
+      expect(formatter.send(:transform_number, 10 ** 13)).to eq(10)
+      expect(formatter.send(:transform_number, 10 ** 14)).to eq(100)
     end
 
     it "returns the original number if greater than 10^15" do
-      formatter.send(:transform_number, 10 ** 15).should == 10 ** 15
+      expect(formatter.send(:transform_number, 10 ** 15)).to eq(10 ** 15)
     end
 
     it "returns the original number if less than 10^3" do
-      formatter.send(:transform_number, 999).should == 999
+      expect(formatter.send(:transform_number, 999)).to eq(999)
     end
   end
 end

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

@@ -33,7 +33,7 @@ describe LongDecimalFormatter do
 
     expected.each do |num, text|
       pattern = data_reader.pattern(num)
-      formatter.format(tokenizer.tokenize(pattern), num).should == text
+      expect(formatter.format(tokenizer.tokenize(pattern), num)).to eq(text)
     end
   end
 
@@ -43,14 +43,14 @@ describe LongDecimalFormatter do
   end
 
   it "formats the number as if it were a straight decimal if it exceeds 10^15" do
-    format_number(10**15).should == "1,000,000,000,000,000"
+    expect(format_number(10**15)).to eq("1,000,000,000,000,000")
   end
 
   it "formats the number as if it were a straight decimal if it's less than 1000" do
-    format_number(500).should == "500"
+    expect(format_number(500)).to eq("500")
   end
 
   it "respects the :precision option" do
-    format_number(12345, :precision => 3).should match_normalized("12.345 thousand")
+    expect(format_number(12345, :precision => 3)).to match_normalized("12.345 thousand")
   end
 end

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

@@ -33,25 +33,25 @@ describe ShortDecimalFormatter do
 
     expected.each do |num, text|
       pattern = data_reader.pattern(num)
-      formatter.format(tokenizer.tokenize(pattern), num).should == text
+      expect(formatter.format(tokenizer.tokenize(pattern), num)).to eq(text)
     end
   end
 
   it "formats the number as if it were a straight decimal if it exceeds 10^15" do
     number = 10**15
     pattern = data_reader.pattern(number)
-    formatter.format(tokenizer.tokenize(pattern), number).should == "1,000,000,000,000,000"
+    expect(formatter.format(tokenizer.tokenize(pattern), number)).to eq("1,000,000,000,000,000")
   end
 
   it "formats the number as if it were a straight decimal if it's less than 1000" do
     number = 500
     pattern = data_reader.pattern(number)
-    formatter.format(tokenizer.tokenize(pattern), number).should == "500"
+    expect(formatter.format(tokenizer.tokenize(pattern), number)).to eq("500")
   end
 
   it "respects the :precision option" do
     number = 12345
     pattern = data_reader.pattern(number)
-    formatter.format(tokenizer.tokenize(pattern), number, :precision => 3).should match_normalized("12.345K")
+    expect(formatter.format(tokenizer.tokenize(pattern), number, :precision => 3)).to match_normalized("12.345K")
   end
 end

data/spec/formatters/numbers/currency_formatter_spec.rb

@@ -19,45 +19,45 @@ describe CurrencyFormatter do
     end
 
     it "should use a dollar sign when no other currency symbol is given (and default to a precision of 2)" do
-      format_currency(12).should == "$12.00"
+      expect(format_currency(12)).to eq("$12.00")
     end
 
     it "handles negative numbers" do
       # yes, the parentheses really are part of the format, don't worry about it
-      format_currency(-12).should == "($12.00)"
+      expect(format_currency(-12)).to eq("($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
-      format_currency(12, :symbol => "S/.").should == "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
-      format_currency(12, :currency => "XYZ").should == "XYZ12.00"
+      expect(format_currency(12, :currency => "XYZ")).to eq("XYZ12.00")
     end
 
     it "should respect the :use_cldr_symbol option" do
-      format_currency(12, :currency => "CAD").should == "$12.00"
-      format_currency(12, :currency => "CAD", :use_cldr_symbol => true).should == "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
-      format_currency(12, :currency => "THB").should == "฿12.00"
+      expect(format_currency(12, :currency => "THB")).to eq("฿12.00")
     end
 
     it "overrides the default precision" do
-      format_currency(12, :precision => 3).should == "$12.000"
+      expect(format_currency(12, :precision => 3)).to eq("$12.000")
     end
 
     it "should use the currency-specific default precision" do
-      format_currency(12, :currency => "TND").should == "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.
-      format_currency(12.03, :currency => "CHF", :rounding => 5).should == "CHF12.05"
-      format_currency(12.02, :currency => "CHF", :rounding => 5).should == "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

@@ -18,20 +18,20 @@ describe DecimalFormatter do
     it "should format positive decimals correctly" do
       pattern = data_reader.pattern(number)
       tokens = tokenizer.tokenize(pattern)
-      formatter.format(tokens, number).should == "12"
+      expect(formatter.format(tokens, number)).to eq("12")
     end
 
     it "should format negative decimals correctly" do
       pattern = data_reader.pattern(negative_number)
       tokens = tokenizer.tokenize(pattern)
-      formatter.format(tokens, negative_number).should == "-12"
+      expect(formatter.format(tokens, negative_number)).to eq("-12")
     end
 
     it "should respect the :precision option" do
       { number => "12,000", negative_number => "-12,000" }.each_pair do |num, formatted|
         pattern = data_reader.pattern(num)
         tokens = tokenizer.tokenize(pattern)
-        formatter.format(tokens, num, :precision => 3).should == formatted
+        expect(formatter.format(tokens, num, :precision => 3)).to eq(formatted)
       end
     end
   end

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

@@ -12,17 +12,17 @@ describe Fraction do
   describe "#apply" do
     it "test: formats a fraction" do
       token = Token.new(:value => '###.##', :type => :pattern)
-      Fraction.new(token).apply('45').should == '.45'
+      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)
-      Fraction.new(token).apply('45').should == '.45000'
+      expect(Fraction.new(token).apply('45')).to eq('.45000')
     end
 
     it "test: :precision option overrides format precision" do
       token = Token.new(:value => '###.##', :type => :pattern)
-      Fraction.new(token).apply('78901', :precision => 5).should == '.78901'
+      expect(Fraction.new(token).apply('78901', :precision => 5)).to eq('.78901')
     end
   end
 end

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

@@ -16,19 +16,19 @@ describe Integer do
       end
 
       it "test: interpolates a number" do
-        TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123).should == '123'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123)).to eq('123')
       end
 
       it "test: does not include a fraction for a float" do
-        TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123.45).should == '123'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123.45)).to eq('123')
       end
 
       it "test: does not round when given a float" do
-        TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123.55).should == '123'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123.55)).to eq('123')
       end
 
       it "test: does not round with :precision => 1" do
-        TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123.55, :precision => 1).should == '123'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123.55, :precision => 1)).to eq('123')
       end
     end
 
@@ -38,11 +38,11 @@ describe Integer do
       end
 
       it "test: single group" do
-        TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123).should == '1,23'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123)).to eq('1,23')
       end
 
       it "test: multiple groups with a primary group size" do
-        TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123456789).should == '1,23,45,67,89'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(123456789)).to eq('1,23,45,67,89')
       end
     end
 
@@ -52,53 +52,53 @@ describe Integer do
       end
 
       it "test: ignores a fraction part given in the format string" do
-        TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(1234.567).should == '1,234'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(1234.567)).to eq('1,234')
       end
 
       it "test: cldr example #,##0.## => 1 234" do
-        TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(1234.567).should == '1,234'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(@token).apply(1234.567)).to eq('1,234')
       end
     end
 
     context "miscellaneous formats" do
       it "test: interpolates a number on the right side" do
         token = Token.new(:value => "0###", :type => :pattern)
-        TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123).should == '0123'
+        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)
-        TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123).should == '123'
+        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)
-        TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123456789).should == '12,34,56,789'
+        expect(TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123456789)).to eq('12,34,56,789')
       end
 
       it "test: does not group when no digits left of the grouping position" do
         token = Token.new(:value => "#,###", :type => :pattern)
-        TwitterCldr::Formatters::Numbers::Integer.new(token).apply(123).should == '123'
+        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)
-        TwitterCldr::Formatters::Numbers::Integer.new(token, :group => ' ').apply(1234.567).should == '1 234'
+        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)
-        TwitterCldr::Formatters::Numbers::Integer.new(token, :group => ' ').apply(1234.567).should == '1234'
+        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)
-        TwitterCldr::Formatters::Numbers::Integer.new(token, :group => ' ').apply(1234.567).should == '1234'
+        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)
-        TwitterCldr::Formatters::Numbers::Integer.new(token, :group => ' ').apply(1234.567).should == '01234'
+        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

@@ -25,33 +25,33 @@ describe NumberFormatter do
 
   describe "#precision_from" do
     it "should return the correct precision" do
-      formatter.send(:precision_from, 12.123).should == 3
+      expect(formatter.send(:precision_from, 12.123)).to eq(3)
     end
 
     it "should return zero precision if the number isn't a decimal" do
-      formatter.send(:precision_from, 12).should == 0
+      expect(formatter.send(:precision_from, 12)).to eq(0)
     end
   end
 
   describe "#round_to" do
     it "should round a number to the given precision" do
-      formatter.send(:round_to, 12, 0).should == 12
-      formatter.send(:round_to, 12.2, 0).should == 12
-      formatter.send(:round_to, 12.5, 0).should == 13
-      formatter.send(:round_to, 12.25, 1).should == 12.3
-      formatter.send(:round_to, 12.25, 2).should == 12.25
-      formatter.send(:round_to, 12.25, 3).should == 12.25
+      expect(formatter.send(:round_to, 12, 0)).to eq(12)
+      expect(formatter.send(:round_to, 12.2, 0)).to eq(12)
+      expect(formatter.send(:round_to, 12.5, 0)).to eq(13)
+      expect(formatter.send(:round_to, 12.25, 1)).to eq(12.3)
+      expect(formatter.send(:round_to, 12.25, 2)).to eq(12.25)
+      expect(formatter.send(:round_to, 12.25, 3)).to eq(12.25)
     end
   end
 
   describe "#parse_number" do
     it "should round and split the given number by decimal" do
-      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", "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
 
@@ -62,33 +62,33 @@ describe NumberFormatter do
     end
 
     it "should format a basic integer" do
-      format_number(12).should == "12"
+      expect(format_number(12)).to eq("12")
     end
 
     it "should format a basic decimal" do
-      format_number(12.0).should == "12,0"
+      expect(format_number(12.0)).to eq("12,0")
     end
 
     context "should respect the :precision option" do
       it "formats with precision of 0" do
-        format_number(12.1, :precision => 0).should == "12"
+        expect(format_number(12.1, :precision => 0)).to eq("12")
       end
 
       it "rounds and formats with precision of 1" do
-        format_number(12.25, :precision => 1).should == "12,3"
+        expect(format_number(12.25, :precision => 1)).to eq("12,3")
       end
     end
 
     it "uses the length of the original decimal as the precision" do
-      format_number(12.8543).should == "12,8543"
+      expect(format_number(12.8543)).to eq("12,8543")
     end
 
     it "formats an integer larger than 999" do
-      format_number(1337).should == "1 337"
+      expect(format_number(1337)).to eq("1 337")
     end
 
     it "formats a decimal larger than 999.9" do
-      format_number(1337.37).should == "1 337,37"
+      expect(format_number(1337.37)).to eq("1 337,37")
     end
   end
 end

data/spec/formatters/numbers/percent_formatter_spec.rb

@@ -17,18 +17,18 @@ describe PercentFormatter do
   it "should format the number correctly" do
     pattern = data_reader.pattern(number)
     tokens = tokenizer.tokenize(pattern)
-    formatter.format(tokens, number).should == "12 %"
+    expect(formatter.format(tokens, number)).to eq("12 %")
   end
 
   it "should format negative numbers correctly" do
     pattern = data_reader.pattern(negative_number)
     tokens = tokenizer.tokenize(pattern)
-    formatter.format(tokens, negative_number).should == "-12 %"
+    expect(formatter.format(tokens, negative_number)).to eq("-12 %")
   end
 
   it "should respect the :precision option" do
     pattern = data_reader.pattern(negative_number)
     tokens = tokenizer.tokenize(pattern)
-    formatter.format(tokens, negative_number, :precision => 3).should 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

@@ -72,10 +72,10 @@ describe RbnfFormatter do
                       failures[locale][group_name] ||= {}
                       failures[locale][group_name][rule_set_name] ||= []
                       failures[locale][group_name][rule_set_name] << number
-                      got.should == expected
+                      expect(got).to eq(expected)
                     end
                   else
-                    got.should == expected
+                    expect(got).to eq(expected)
                   end
 
                 end