twitter_cldr 3.0.1 → 3.0.2

data/spec/localized/localized_timespan_spec.rb

@@ -10,8 +10,8 @@ include TwitterCldr::Localized
 describe LocalizedTimespan do
   it "should format a numer of seconds in different units" do
     timespan = LocalizedTimespan.new(-172800, :locale => :de)
-    timespan.to_s(:unit => :hour).should match_normalized("Vor 48 Stunden")
-    timespan.to_s(:unit => :day).should match_normalized("Vor 2 Tagen")
+    expect(timespan.to_s(:unit => :hour)).to match_normalized("Vor 48 Stunden")
+    expect(timespan.to_s(:unit => :day)).to match_normalized("Vor 2 Tagen")
   end
 
   it "approximates timespans accurately if explicity asked" do
@@ -37,7 +37,7 @@ describe LocalizedTimespan do
 
     expected.each_pair do |seconds, text|
       timespan = LocalizedTimespan.new(seconds, :locale => :de)
-      timespan.to_s(options).should match_normalized(text)
+      expect(timespan.to_s(options)).to match_normalized(text)
     end
   end
 
@@ -61,7 +61,7 @@ describe LocalizedTimespan do
 
     expected.each_pair do |seconds, text|
       timespan = LocalizedTimespan.new(seconds, :locale => :de)
-      timespan.to_s(options).should match_normalized(text)
+      expect(timespan.to_s(options)).to match_normalized(text)
     end
   end
 
@@ -80,7 +80,7 @@ describe LocalizedTimespan do
       }
 
       expected.each_pair do |unit, text|
-        timespan.to_s(options.merge(:unit => unit)).should match_normalized(text)
+        expect(timespan.to_s(options.merge(:unit => unit))).to match_normalized(text)
       end
     end
   end
@@ -99,7 +99,7 @@ describe LocalizedTimespan do
       }
 
       expected.each_pair do |unit, text|
-        timespan.to_s(:unit => unit).should match_normalized(text)
+        expect(timespan.to_s(:unit => unit)).to match_normalized(text)
       end
     end
   end
@@ -118,7 +118,7 @@ describe LocalizedTimespan do
       }
 
       expected.each_pair do |unit, text|
-        timespan.to_s(:unit => unit).should match_normalized(text)
+        expect(timespan.to_s(:unit => unit)).to match_normalized(text)
       end
     end
   end
@@ -137,7 +137,7 @@ describe LocalizedTimespan do
       }
 
       expected.each_pair do |unit, text|
-        timespan.to_s(options.merge(:unit => unit)).should match_normalized(text)
+        expect(timespan.to_s(options.merge(:unit => unit))).to match_normalized(text)
       end
     end
   end

data/spec/normalization_spec.rb

@@ -13,28 +13,28 @@ describe TwitterCldr::Normalization do
 
     it 'it uses NFD by default' do
       mock(Eprun).normalize(string, :nfd) { normalized_string }
-      TwitterCldr::Normalization.normalize(string).should == normalized_string
+      expect(TwitterCldr::Normalization.normalize(string)).to eq(normalized_string)
     end
 
     it "uses specified algorithm if there is any" do
       mock(Eprun).normalize(string, :nfkd) { normalized_string }
-      TwitterCldr::Normalization.normalize(string, :using => :nfkd).should == normalized_string
+      expect(TwitterCldr::Normalization.normalize(string, :using => :nfkd)).to eq(normalized_string)
     end
 
     it "raises an ArgumentError if passed an unsupported normalizer name" do
-      lambda do
+      expect do
         TwitterCldr::Normalization.normalize(string, :using => :blarg)
-      end.should raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it 'accepts normalizer name in upper case' do
       mock(Eprun).normalize(string, :nfkd) { normalized_string }
-      TwitterCldr::Normalization.normalize(string, :using => :NFKD).should == normalized_string
+      expect(TwitterCldr::Normalization.normalize(string, :using => :NFKD)).to eq(normalized_string)
     end
 
     it 'accepts a string' do
       mock(Eprun).normalize(string, :nfkd) { normalized_string }
-      TwitterCldr::Normalization.normalize(string, :using => 'nfkd').should == normalized_string
+      expect(TwitterCldr::Normalization.normalize(string, :using => 'nfkd')).to eq(normalized_string)
     end
 
   end

data/spec/parsers/number_parser_spec.rb

@@ -16,112 +16,112 @@ describe NumberParser do
 
   describe "#group_separator" do
     it "returns the correct group separator" do
-      @parser.send(:group_separator).should match_normalized(" ")
+      expect(@parser.send(:group_separator)).to match_normalized(" ")
     end
   end
 
   describe "#decimal_separator" do
     it "returns the correct decimal separator" do
-      @parser.send(:decimal_separator).should == ","
+      expect(@parser.send(:decimal_separator)).to eq(",")
     end
   end
 
   describe "#identify" do
     it "properly identifies a numeric value" do
-      @parser.send(:identify, "7841", *separators).should == { :value => "7841", :type => :numeric }
+      expect(@parser.send(:identify, "7841", *separators)).to eq({ :value => "7841", :type => :numeric })
     end
 
     it "properly identifies a decimal separator" do
-      @parser.send(:identify, ",", *separators).should == { :value => ",", :type => :decimal }
+      expect(@parser.send(:identify, ",", *separators)).to eq({ :value => ",", :type => :decimal })
     end
 
     it "properly identifies a group separator" do
-      @parser.send(:identify, ".", *separators).should == { :value => ".", :type => :group }
+      expect(@parser.send(:identify, ".", *separators)).to eq({ :value => ".", :type => :group })
     end
 
     it "returns nil if the text doesn't match a number or either separators" do
-      @parser.send(:identify, "abc", *separators).should == { :value => "abc", :type => nil }
+      expect(@parser.send(:identify, "abc", *separators)).to eq({ :value => "abc", :type => nil })
     end
   end
 
   describe "#tokenize" do
     it "splits text by numericality and group/decimal separators" do
-      @parser.send(:tokenize, "1,33.00", *separators).should == [
+      expect(@parser.send(:tokenize, "1,33.00", *separators)).to eq([
         { :value => "1",  :type => :numeric },
         { :value => ",",  :type => :decimal },
         { :value => "33", :type => :numeric },
         { :value => ".",  :type => :group },
         { :value => "00", :type => :numeric }
-      ]
+      ])
     end
 
     it "returns an empty array for a non-numeric string" do
-      @parser.send(:tokenize, "abc", *separators).should be_empty
+      expect(@parser.send(:tokenize, "abc", *separators)).to be_empty
     end
   end
 
   describe "#separators" do
     it "returns all separators when strict mode is off" do
       group, decimal = @parser.send(:separators, false)
-      group.should == '\.,\s'
-      decimal.should == '\.,\s'
+      expect(group).to eq('\.,\s')
+      expect(decimal).to eq('\.,\s')
     end
 
     it "returns only locale-specific separators when strict mode is on" do
       group, decimal = @parser.send(:separators, true)
-      group.should match_normalized(" ")
-      decimal.should == ','
+      expect(group).to match_normalized(" ")
+      expect(decimal).to eq(',')
     end
   end
 
   describe "#punct_valid" do
     it "correctly validates a number with no decimal" do
       tokens = @parser.send(:tokenize, "1.337", *separators).reject { |t| t[:type] == :numeric }
-      @parser.send(:punct_valid?, tokens).should be_true
+      expect(@parser.send(:punct_valid?, tokens)).to be_true
     end
 
     it "correctly validates a number with a decimal" do
       tokens = @parser.send(:tokenize, "1.337,00", *separators).reject { |t| t[:type] == :numeric }
-      @parser.send(:punct_valid?, tokens).should be_true
+      expect(@parser.send(:punct_valid?, tokens)).to be_true
     end
 
     it "reports on an invalid number when it has more than one decimal" do
       tokens = @parser.send(:tokenize, "1,337,00", *separators).reject { |t| t[:type] == :numeric }
-      @parser.send(:punct_valid?, tokens).should be_false
+      expect(@parser.send(:punct_valid?, tokens)).to be_false
     end
   end
 
   describe "#is_numeric?" do
     it "returns true if the text is numeric" do
-      NumberParser.is_numeric?("4839", "").should be_true
-      NumberParser.is_numeric?("1", "").should be_true
+      expect(NumberParser.is_numeric?("4839", "")).to be_true
+      expect(NumberParser.is_numeric?("1", "")).to be_true
     end
 
     it "returns false if the text is not purely numeric" do
-      NumberParser.is_numeric?("abc", "").should be_false
-      NumberParser.is_numeric?("123abc", "").should be_false
+      expect(NumberParser.is_numeric?("abc", "")).to be_false
+      expect(NumberParser.is_numeric?("123abc", "")).to be_false
     end
 
     it "returns false if the text is blank" do
-      NumberParser.is_numeric?("", "").should be_false
+      expect(NumberParser.is_numeric?("", "")).to be_false
     end
 
     it "accepts the given characters as valid numerics" do
-      NumberParser.is_numeric?("a123a", "a").should be_true
-      NumberParser.is_numeric?("1.234,56").should be_true  # default separator chars used here
+      expect(NumberParser.is_numeric?("a123a", "a")).to be_true
+      expect(NumberParser.is_numeric?("1.234,56")).to be_true  # default separator chars used here
     end
   end
 
   describe "#valid?" do
     it "correctly identifies a series of valid cases" do
       ["5", "5,0", "1.337", "1.337,0", "0,05", ",5", "1.337.000,00"].each do |num|
-        @parser.valid?(num).should be_true
+        expect(@parser.valid?(num)).to be_true
       end
     end
 
     it "correctly identifies a series of invalid cases" do
       ["12,0,0", "5,", "5#{[160].pack("U*")}"].each do |num|
-        @parser.valid?(num).should be_false
+        expect(@parser.valid?(num)).to be_false
       end
     end
   end
@@ -139,49 +139,49 @@ describe NumberParser do
       }
 
       cases.each do |text, expected|
-        @parser.parse(text).should == expected
+        expect(@parser.parse(text)).to eq(expected)
       end
     end
 
     it "correctly raises an error when asked to parse invalid numbers" do
       cases = ["12,0,0", "5,", "5#{[160].pack("U*")}"]
       cases.each do |text|
-        lambda { @parser.parse(text) }.should raise_error(InvalidNumberError)
+        expect { @parser.parse(text) }.to raise_error(InvalidNumberError)
       end
     end
 
     context "non-strict" do
       it "succeeds in parsing even if inexact punctuation is used" do
-        @parser.parse("5 100", :strict => false).should == 5100
+        expect(@parser.parse("5 100", :strict => false)).to eq(5100)
       end
     end
   end
 
   describe "#try_parse" do
     it "parses correctly with a valid number" do
-      @parser.try_parse("1.234").should == 1234
+      expect(@parser.try_parse("1.234")).to eq(1234)
     end
 
     it "parses correctly with a valid number and yields to the given block" do
       pre_result = nil
-      @parser.try_parse("1.234") do |result|
+      expect(@parser.try_parse("1.234") do |result|
         pre_result = result
         9
-      end.should == 9
-      pre_result.should == 1234
+      end).to eq(9)
+      expect(pre_result).to eq(1234)
     end
 
     it "falls back on the default value if the number is invalid" do
-      @parser.try_parse("5,").should be_nil
-      @parser.try_parse("5,", 0).should == 0
+      expect(@parser.try_parse("5,")).to be_nil
+      expect(@parser.try_parse("5,", 0)).to eq(0)
     end
 
     it "falls back on the block if the number is invalid" do
-      @parser.try_parse("5,") { |result| 9 }.should == 9
+      expect(@parser.try_parse("5,") { |result| 9 }).to eq(9)
     end
 
     it "doesn't catch anything but an InvalidNumberError" do
-      lambda { @parser.try_parse(Object.new) }.should raise_error(NoMethodError)
+      expect { @parser.try_parse(Object.new) }.to raise_error(NoMethodError)
     end
   end
 end

data/spec/parsers/parser_spec.rb

@@ -32,9 +32,9 @@ describe Parser do
     it "should reset the token index" do
       parser.parse(tokens)
       parser.send(:next_token, :a)
-      parser.send(:current_token).type.should == :b
+      expect(parser.send(:current_token).type).to eq(:b)
       parser.reset
-      parser.send(:current_token).type.should == :a
+      expect(parser.send(:current_token).type).to eq(:a)
     end
   end
 
@@ -42,19 +42,19 @@ describe Parser do
     it "should advance to the next token" do
       parser.parse(tokens)
       parser.send(:next_token, :a)
-      parser.send(:current_token).type.should == :b
+      expect(parser.send(:current_token).type).to eq(:b)
     end
 
     it "should raise an error after encountering an unexpected token" do
       parser.parse(tokens)
-      lambda { parser.send(:next_token, :z) }.should raise_error(UnexpectedTokenError)
+      expect { parser.send(:next_token, :z) }.to raise_error(UnexpectedTokenError)
     end
   end
 
   describe "#current_token" do
     it "returns the current token" do
       parser.parse(tokens)
-      parser.send(:current_token).type.should == :a
+      expect(parser.send(:current_token).type).to eq(:a)
     end
   end
 end

data/spec/parsers/segmentation_parser_spec.rb

@@ -30,21 +30,21 @@ describe "Segmentation" do
     describe "#parse" do
       it "should parse a rule with a break" do
         rule = parse(tokenize("[a-z] ÷ [0-9]"))
-        rule.left.to_regexp_str.should == "\\A(?:[\\141-\\172])"
-        rule.right.to_regexp_str.should == "\\A(?:[\\60-\\71])"
-        rule.boundary_symbol.should == :break
+        expect(rule.left.to_regexp_str).to eq("\\A(?:[\\141-\\172])")
+        expect(rule.right.to_regexp_str).to eq("\\A(?:[\\60-\\71])")
+        expect(rule.boundary_symbol).to eq(:break)
       end
 
       it "should parse a rule with a non-break" do
         rule = parse(tokenize("[a-z] × [0-9]"))
-        rule.regex.to_regexp_str.should == "\\A(?:[\\141-\\172])(?:[\\60-\\71])"
-        rule.boundary_symbol.should == :no_break
+        expect(rule.regex.to_regexp_str).to eq("\\A(?:[\\141-\\172])(?:[\\60-\\71])")
+        expect(rule.boundary_symbol).to eq(:no_break)
       end
 
       it "should parse a rule containing a variable" do
         rule = parse(tokenize("$FOO × bar"), :symbol_table => symbol_table)
-        rule.regex.to_regexp_str.should == "\\A(?:[\\141-\\143])(?:\\142)(?:\\141)(?:\\162)"
-        rule.boundary_symbol.should == :no_break
+        expect(rule.regex.to_regexp_str).to eq("\\A(?:[\\141-\\143])(?:\\142)(?:\\141)(?:\\162)")
+        expect(rule.boundary_symbol).to eq(:no_break)
       end
     end
   end
@@ -54,19 +54,19 @@ describe "Segmentation" do
       let(:rule) { parse(tokenize("[a-z] ÷ [0-9]")) }
 
       it "rule should be the right type" do
-        rule.should be_a(SegmentationParser::BreakRule)
+        expect(rule).to be_a(SegmentationParser::BreakRule)
       end
 
       it "should match and return the right offset and text" do
         match = rule.match("c7")
-        match.boundary_offset.should == 1
-        match.text.should == "c7"
+        expect(match.boundary_offset).to eq(1)
+        expect(match.text).to eq("c7")
       end
 
       it "should not match if the input string doesn't contain a matching right- and/or left-hand side" do
-        rule.match("C7").should be_nil
-        rule.match("cc").should be_nil
-        rule.match("CC").should be_nil
+        expect(rule.match("C7")).to be_nil
+        expect(rule.match("cc")).to be_nil
+        expect(rule.match("CC")).to be_nil
       end
     end
   end
@@ -76,20 +76,20 @@ describe "Segmentation" do
       let(:rule) { parse(tokenize("[a-z] × [0-9]")) }
 
       it "rule should be the right type" do
-        rule.should be_a(SegmentationParser::NoBreakRule)
+        expect(rule).to be_a(SegmentationParser::NoBreakRule)
       end
 
       it "should match and return the right offset and text" do
         match = rule.match("c7")
         # non-break rules send you to the end of the match (maybe that's wrong?)
-        match.boundary_offset.should == 2
-        match.text.should == "c7"
+        expect(match.boundary_offset).to eq(2)
+        expect(match.text).to eq("c7")
       end
 
       it "should not match if the input string doesn't contain matching text" do
-        rule.match("C7").should be_nil
-        rule.match("cc").should be_nil
-        rule.match("CC").should be_nil
+        expect(rule.match("C7")).to be_nil
+        expect(rule.match("cc")).to be_nil
+        expect(rule.match("CC")).to be_nil
       end
     end
   end

data/spec/parsers/symbol_table_spec.rb

@@ -12,13 +12,13 @@ describe SymbolTable do
 
   describe "#fetch" do
     it "should be able to retrieve values for symbols" do
-      table.fetch(:a).should == "b"
+      expect(table.fetch(:a)).to eq("b")
       fetch = lambda { table.fetch(:z) }
 
       if RUBY_VERSION > "1.8.7"
-        fetch.should raise_error(KeyError)
+        expect(fetch).to raise_error(KeyError)
       else
-        fetch.should raise_error(IndexError)
+        expect(fetch).to raise_error(IndexError)
       end
     end
   end
@@ -26,7 +26,7 @@ describe SymbolTable do
   describe "#add" do
     it "should be able to add then fetch new values for symbols" do
       table.add(:e, "f")
-      table.fetch(:e).should == "f"
+      expect(table.fetch(:e)).to eq("f")
     end
   end
 end

data/spec/parsers/unicode_regex/character_class_spec.rb

@@ -26,22 +26,22 @@ describe UnicodeRegexParser::CharacterClass do
   describe "#to_set" do
     it "unions together char classes with no explicit operator" do
       char_class = char_class_from(parse(tokenize("[[a][b]]")))
-      char_class.to_set.to_a.should == [97..98]
+      expect(char_class.to_set.to_a).to eq([97..98])
     end
 
     it "unions together other entities within char classes when operator is not explicit" do
       char_class = char_class_from(parse(tokenize("[a-z0-9\\u0123]")))
-      char_class.to_set.to_a(true).should == [48..57, 97..122, 291]
+      expect(char_class.to_set.to_a(true)).to eq([48..57, 97..122, 291])
     end
 
     it "intersects correctly" do
       char_class = char_class_from(parse(tokenize("[[a-m]&[g-z]]")))
-      char_class.to_set.to_a.should == [103..109]
+      expect(char_class.to_set.to_a).to eq([103..109])
     end
 
     it "finds symmetric differences correctly" do
       char_class = char_class_from(parse(tokenize("[[a-m]-[g-z]]")))
-      char_class.to_set.to_a.should == [97..102, 110..122]
+      expect(char_class.to_set.to_a).to eq([97..102, 110..122])
     end
 
     it "computes sets for nested expressions" do
@@ -51,67 +51,67 @@ describe UnicodeRegexParser::CharacterClass do
       # = (104..122) subtr ()
       # = (104..122)
       char_class = char_class_from(parse(tokenize("[[[a-m]&[h-j]]-[k-z]]")))
-      char_class.to_set.to_a.should == [104..122]
+      expect(char_class.to_set.to_a).to eq([104..122])
     end
 
     it "pulls in ranges for unicode character sets" do
       char_class = char_class_from(parse(tokenize("[\\p{Zs}]")))
-      char_class.to_set.to_a(true).should == [
+      expect(char_class.to_set.to_a(true)).to eq([
         32, 160, 5760, 6158, 8192..8202, 8239, 8287, 12288
-      ]
+      ])
     end
 
     it "computes unions between unicode character sets" do
       char_class = char_class_from(parse(tokenize("[[\\p{Zs}][\\p{Cc}]]")))
-      char_class.to_set.to_a(true).should == [
+      expect(char_class.to_set.to_a(true)).to eq([
         0..1, 8..32, 127..160, 5760, 6158, 8192..8202, 8239, 8287, 12288
-      ]
+      ])
     end
 
     it "computes intersections between unicode character sets" do
       char_class = char_class_from(parse(tokenize("[[\\p{Zs}]&[\\u2000-\\u202B]]")))
-      char_class.to_set.to_a(true).should == [8192..8202]
+      expect(char_class.to_set.to_a(true)).to eq([8192..8202])
     end
 
     it "supports negating character sets" do
       char_class = char_class_from(parse(tokenize("[^\\u2000-\\u202B]")))
-      char_class.to_set.to_a(true).should == [
+      expect(char_class.to_set.to_a(true)).to eq([
         0..1, 8..8191, 8236..55295, 57344..1114111
-      ]
+      ])
     end
 
     it "supports literal and escaped characters" do
       char_class = char_class_from(parse(tokenize("[abc\\edf\\g]")))
-      char_class.to_set.to_a(true).should == [97..103]
+      expect(char_class.to_set.to_a(true)).to eq([97..103])
     end
 
     it "supports special switch characters" do
       char_class = char_class_from(parse(tokenize("[\\w]")))  # a-z, A-Z, 0-9, _
-      char_class.to_set.to_a(true).should == [48..57, 65..90, 95, 97..122]
+      expect(char_class.to_set.to_a(true)).to eq([48..57, 65..90, 95, 97..122])
     end
 
     it "supports negated switch characters" do
       char_class = char_class_from(parse(tokenize("[\\D]")))  # i.e. NOT \w
-      char_class.to_set.to_a(true).should == [
+      expect(char_class.to_set.to_a(true)).to eq([
         0..1, 8..47, 58..55295, 57344..1114111
-      ]
+      ])
     end
   end
 
   describe "#to_regexp_str" do
     it "wraps ranges in square brackets" do
       char_class = char_class_from(parse(tokenize("[a-z]")))
-      char_class.to_regexp_str.should == "(?:[\\141-\\172])"
+      expect(char_class.to_regexp_str).to eq("(?:[\\141-\\172])")
     end
 
     it "octal-encodes and wraps sequential characters to isolate bytes" do
       char_class = char_class_from(parse(tokenize("[{foo}]")))
-      char_class.to_regexp_str.should == "(?:(?:\\146)(?:\\157)(?:\\157))"
+      expect(char_class.to_regexp_str).to eq("(?:(?:\\146)(?:\\157)(?:\\157))")
     end
 
     it "combines multiple components with 'or' pipe characters" do
       char_class = char_class_from(parse(tokenize("[{foo}abc]")))
-      char_class.to_regexp_str.should == "(?:(?:\\146)(?:\\157)(?:\\157)|[\\141-\\143])"
+      expect(char_class.to_regexp_str).to eq("(?:(?:\\146)(?:\\157)(?:\\157)|[\\141-\\143])")
     end
   end
 end

data/spec/parsers/unicode_regex/character_range_spec.rb

@@ -15,7 +15,7 @@ describe UnicodeRegexParser::CharacterRange do
         UnicodeRegexParser::UnicodeString.new([98])
       )
 
-      range.to_set.to_a(true).should == [97..98]
+      expect(range.to_set.to_a(true)).to eq([97..98])
     end
   end
 end

data/spec/parsers/unicode_regex/character_set_spec.rb

@@ -11,26 +11,26 @@ describe UnicodeRegexParser::CharacterSet do
   describe "#to_set" do
     it "should return a set containing codepoints for the given general property" do
       char_set = UnicodeRegexParser::CharacterSet.new("Zs")
-      char_set.to_set.to_a(true).should == [
+      expect(char_set.to_set.to_a(true)).to eq([
         32, 160, 5760, 6158, 8192..8202, 8239, 8287, 12288
-      ]
+      ])
     end
 
     it "should return a set containing codepoints for the given named property" do
       char_set = UnicodeRegexParser::CharacterSet.new("Sentence_Break=Sp")
-      char_set.to_set.to_a(true).should == [
+      expect(char_set.to_set.to_a(true)).to eq([
         9, 11..12, 32, 160, 5760, 8192..8202, 8239, 8287, 12288
-      ]
+      ])
     end
 
     it "should raise an exception when given an invalid property name or value" do
-      lambda do
+      expect do
         UnicodeRegexParser::CharacterSet.new("Foobar=Sp").to_set
-      end.should raise_error(UnicodeRegexParserError)
+      end.to raise_error(UnicodeRegexParserError)
 
-      lambda do
+      expect do
         UnicodeRegexParser::CharacterSet.new("Sentence_Break=Foo").to_set
-      end.should raise_error(UnicodeRegexParserError)
+      end.to raise_error(UnicodeRegexParserError)
     end
   end
 end

data/spec/parsers/unicode_regex/literal_spec.rb

@@ -11,24 +11,24 @@ describe UnicodeRegexParser::Literal do
   describe "#to_set" do
     it "should return literal characters as codepoints" do
       literal = UnicodeRegexParser::Literal.new("a")
-      literal.to_set.to_a(true).should == [97]
+      expect(literal.to_set.to_a(true)).to eq([97])
     end
 
     it "should return escaped characters with no special meaning as codepoints" do
       literal = UnicodeRegexParser::Literal.new("\\a")
-      literal.to_set.to_a(true).should == [97]
+      expect(literal.to_set.to_a(true)).to eq([97])
     end
 
     it "should convert special regex switches to their range equivalents" do
       literal = UnicodeRegexParser::Literal.new("\\d")  # digit
-      literal.to_set.to_a(true).should == [48..57]
+      expect(literal.to_set.to_a(true)).to eq([48..57])
     end
 
     it "should convert negated special regex switches to their range equivalents" do
       literal = UnicodeRegexParser::Literal.new("\\D")  # NOT digit
-      literal.to_set.to_a(true).should == [
+      expect(literal.to_set.to_a(true)).to eq([
         0..1, 8..47, 58..55295, 57344..1114111
-      ]
+      ])
     end
   end
 end

data/spec/parsers/unicode_regex/unicode_string_spec.rb

@@ -11,12 +11,12 @@ describe UnicodeRegexParser::UnicodeString do
   describe "#to_set" do
     it "should return a zero-length range when representing a single codepoint" do
       str = UnicodeRegexParser::UnicodeString.new([97])
-      str.to_set.to_a.should == [97..97]
+      expect(str.to_set.to_a).to eq([97..97])
     end
 
     it "should return a range containing the codepoint array as both the first and last elements" do
       str = UnicodeRegexParser::UnicodeString.new([97, 98, 99])
-      str.to_set.to_a.should == [[97, 98, 99]..[97, 98, 99]]
+      expect(str.to_set.to_a).to eq([[97, 98, 99]..[97, 98, 99]])
     end
   end
 end