twitter_cldr 3.0.1 → 3.0.2

data/spec/bidi/bidi_spec.rb

@@ -67,6 +67,6 @@ describe Bidi do
       end
     end
 
-    num_failed.should == 0
+    expect(num_failed).to eq(0)
   end
 end

data/spec/collation/collation_spec.rb

@@ -41,7 +41,7 @@ describe 'Unicode Collation Algorithm' do
 
         if previous_sort_key
           result = (previous_sort_key <=> current_sort_key).nonzero? || (previous_code_points <=> current_code_points)
-          result.should(eq(-1), error_message(previous_str_code_points, previous_sort_key, current_str_code_points, current_sort_key))
+          expect(result).to(eq(-1), error_message(previous_str_code_points, previous_sort_key, current_str_code_points, current_sort_key))
         end
 
         previous_sort_key        = current_sort_key

data/spec/collation/collator_spec.rb

@@ -21,15 +21,15 @@ describe Collator do
     end
 
     it 'returns default fractional collation elements trie' do
-      Collator.default_trie.should == trie
+      expect(Collator.default_trie).to eq(trie)
     end
 
     it 'loads the trie only once' do
-      Collator.default_trie.object_id.should == Collator.default_trie.object_id
+      expect(Collator.default_trie.object_id).to eq(Collator.default_trie.object_id)
     end
 
     it 'locks the trie' do
-      Collator.default_trie.should be_locked
+      expect(Collator.default_trie).to be_locked
     end
   end
 
@@ -43,15 +43,15 @@ describe Collator do
     end
 
     it 'returns default fractional collation elements trie' do
-      Collator.tailored_trie(locale).should == trie
+      expect(Collator.tailored_trie(locale)).to eq(trie)
     end
 
     it 'loads the trie only once' do
-      Collator.tailored_trie(locale).object_id.should == Collator.tailored_trie(locale).object_id
+      expect(Collator.tailored_trie(locale).object_id).to eq(Collator.tailored_trie(locale).object_id)
     end
 
     it 'locks the trie' do
-      Collator.tailored_trie(locale).should be_locked
+      expect(Collator.tailored_trie(locale)).to be_locked
     end
   end
 
@@ -62,17 +62,17 @@ describe Collator do
 
     context 'without locale' do
       it 'initializes default collator' do
-        Collator.new.locale.should be_nil
+        expect(Collator.new.locale).to be_nil
       end
     end
 
     context 'with locale' do
       it 'initialized tailored collator with provided locale' do
-        Collator.new(:ru).locale.should == :ru
+        expect(Collator.new(:ru).locale).to eq(:ru)
       end
 
       it 'converts locale' do
-        Collator.new(:no).locale.should == :nb
+        expect(Collator.new(:no).locale).to eq(:nb)
       end
     end
   end
@@ -90,11 +90,11 @@ describe Collator do
     end
 
     it 'returns collation elements for a string' do
-      collator.get_collation_elements(string).should == collation_elements
+      expect(collator.get_collation_elements(string)).to eq(collation_elements)
     end
 
     it 'returns collation elements for an array of code points (represented as hex strings)' do
-      collator.get_collation_elements(code_points).should == collation_elements
+      expect(collator.get_collation_elements(code_points)).to eq(collation_elements)
     end
   end
 
@@ -112,12 +112,12 @@ describe Collator do
 
       it 'calculates sort key for a string' do
         mock(collator).get_collation_elements(string) { collation_elements }
-        collator.get_sort_key(string).should == sort_key
+        expect(collator.get_sort_key(string)).to eq(sort_key)
       end
 
       it 'calculates sort key for an array of code points (represented as hex strings)' do
         mock(collator).get_collation_elements(code_points) { collation_elements }
-        collator.get_sort_key(code_points).should == sort_key
+        expect(collator.get_sort_key(code_points)).to eq(sort_key)
       end
     end
 
@@ -135,7 +135,7 @@ describe Collator do
         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 }
 
-        collator.get_sort_key(code_points).should == sort_key
+        expect(collator.get_sort_key(code_points)).to eq(sort_key)
       end
 
       it 'passes maximum_level option to sort key builder' do 
@@ -147,7 +147,7 @@ describe Collator do
         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 }
 
-        collator.get_sort_key(code_points, :maximum_level => maximum_level).should == sort_key
+        expect(collator.get_sort_key(code_points, :maximum_level => maximum_level)).to eq(sort_key)
       end
 
     end
@@ -164,14 +164,14 @@ describe Collator do
       stub_sort_key(collator, 'foo', sort_key)
       stub_sort_key(collator, 'bar', another_sort_key)
 
-      collator.compare('foo', 'bar').should == -1
-      collator.compare('bar', 'foo').should == 1
+      expect(collator.compare('foo', 'bar')).to eq(-1)
+      expect(collator.compare('bar', 'foo')).to eq(1)
     end
 
     it 'returns 0 without computing sort keys if the strings are equal' do
       dont_allow(collator).get_sort_key
 
-      collator.compare('foo', 'foo').should == 0
+      expect(collator.compare('foo', 'foo')).to eq(0)
     end
   end
 
@@ -188,18 +188,18 @@ describe Collator do
 
     describe '#sort' do
       it 'sorts strings by sort keys' do
-        collator.sort(array).should == sorted
+        expect(collator.sort(array)).to eq(sorted)
       end
 
       it 'does not change the original array' do
-        lambda { collator.sort(array) }.should_not change { array }
+        expect { collator.sort(array) }.not_to change { array }
       end
     end
 
     describe '#sort!' do
       it 'sorts strings array by sort keys in-place ' do
         collator.sort!(array)
-        array.should == sorted
+        expect(array).to eq(sorted)
       end
     end
   end
@@ -224,28 +224,28 @@ describe Collator do
 
     describe 'tailoring rules support' do
       it 'tailored collation elements are used' do
-        default_collator.get_collation_elements([0x490]).should  == [[0x5C1A, 5, 0x93], [0, 0xDBB9, 9]]
-        tailored_collator.get_collation_elements([0x490]).should == [[0x5C1B, 5, 0x86]]
+        expect(default_collator.get_collation_elements([0x490])).to  eq([[0x5C1A, 5, 0x93], [0, 0xDBB9, 9]])
+        expect(tailored_collator.get_collation_elements([0x490])).to eq([[0x5C1B, 5, 0x86]])
 
-        default_collator.get_collation_elements([0x491]).should  == [[0x5C1A, 5, 9], [0, 0xDBB9, 9]]
-        tailored_collator.get_collation_elements([0x491]).should == [[0x5C1B, 5, 5]]
+        expect(default_collator.get_collation_elements([0x491])).to  eq([[0x5C1A, 5, 9], [0, 0xDBB9, 9]])
+        expect(tailored_collator.get_collation_elements([0x491])).to eq([[0x5C1B, 5, 5]])
       end
 
       it 'original contractions for tailored elements are applied' do
-        default_collator.get_collation_elements([0x491, 0x306]).should  == [[0x5C, 0xDB, 9]]
-        tailored_collator.get_collation_elements([0x491, 0x306]).should == [[0x5C, 0xDB, 9]]
+        expect(default_collator.get_collation_elements([0x491, 0x306])).to  eq([[0x5C, 0xDB, 9]])
+        expect(tailored_collator.get_collation_elements([0x491, 0x306])).to eq([[0x5C, 0xDB, 9]])
       end
     end
 
     describe 'contractions suppressing support' do
       it 'suppressed contractions are ignored' do
-        default_collator.get_collation_elements([0x41A, 0x301]).should  == [[0x5CCC, 5, 0x8F]]
-        tailored_collator.get_collation_elements([0x41A, 0x301]).should == [[0x5C6C, 5, 0x8F], [0, 0x8D, 5]]
+        expect(default_collator.get_collation_elements([0x41A, 0x301])).to  eq([[0x5CCC, 5, 0x8F]])
+        expect(tailored_collator.get_collation_elements([0x41A, 0x301])).to eq([[0x5C6C, 5, 0x8F], [0, 0x8D, 5]])
       end
 
       it 'non-suppressed contractions are used' do
-        default_collator.get_collation_elements([0x415, 0x306]).should  == [[0x5C36, 5, 0x8F]]
-        tailored_collator.get_collation_elements([0x415, 0x306]).should == [[0x5C36, 5, 0x8F]]
+        expect(default_collator.get_collation_elements([0x415, 0x306])).to  eq([[0x5C36, 5, 0x8F]])
+        expect(tailored_collator.get_collation_elements([0x415, 0x306])).to eq([[0x5C36, 5, 0x8F]])
       end
     end
 

data/spec/collation/implicit_collation_elements_spec.rb

@@ -10,15 +10,15 @@ include TwitterCldr::Collation
 describe ImplicitCollationElements do
 
   it 'computes correct implicit value for non-CJK code points' do
-    ImplicitCollationElements.for_code_point(0xD801).should  == [[0xE305C758, 0x5, 0x5]]
-    ImplicitCollationElements.for_code_point(0xC0001).should == [[0xE44E70AC, 0x5, 0x5]]
-    ImplicitCollationElements.for_code_point(0xFFF02).should == [[0xE4C25F74, 0x5, 0x5]]
+    expect(ImplicitCollationElements.for_code_point(0xD801)).to  eq([[0xE305C758, 0x5, 0x5]])
+    expect(ImplicitCollationElements.for_code_point(0xC0001)).to eq([[0xE44E70AC, 0x5, 0x5]])
+    expect(ImplicitCollationElements.for_code_point(0xFFF02)).to eq([[0xE4C25F74, 0x5, 0x5]])
   end
 
   it 'computes correct implicit values for CJK code points' do
-    ImplicitCollationElements.for_code_point(0x4E00).should  == [[0xE00406, 0x5, 0x5]]
-    ImplicitCollationElements.for_code_point(0x3400).should  == [[0xE0ABCE, 0x5, 0x5]]
-    ImplicitCollationElements.for_code_point(0x20000).should == [[0xE1302590, 0x5, 0x5]]
+    expect(ImplicitCollationElements.for_code_point(0x4E00)).to  eq([[0xE00406, 0x5, 0x5]])
+    expect(ImplicitCollationElements.for_code_point(0x3400)).to  eq([[0xE0ABCE, 0x5, 0x5]])
+    expect(ImplicitCollationElements.for_code_point(0x20000)).to eq([[0xE1302590, 0x5, 0x5]])
   end
 
 end

data/spec/collation/sort_key_builder_spec.rb

@@ -20,37 +20,37 @@ describe SortKeyBuilder do
       mock(SortKeyBuilder).new(collation_elements, nil) { sort_key }
       mock(sort_key).bytes_array { sort_key_bytes }
 
-      SortKeyBuilder.build(collation_elements).should == sort_key_bytes
+      expect(SortKeyBuilder.build(collation_elements)).to eq(sort_key_bytes)
     end
   end
 
   describe '#initialize' do
     it 'assigns collation elements array' do
-      SortKeyBuilder.new(collation_elements).collation_elements.should == collation_elements
+      expect(SortKeyBuilder.new(collation_elements).collation_elements).to eq(collation_elements)
     end
 
     it 'accepts case-first option as an option' do
       SortKeyBuilder::VALID_CASE_FIRST_OPTIONS.each do |case_first|
-        lambda { SortKeyBuilder.new([], :case_first => case_first) }.should_not 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
-      lambda { SortKeyBuilder.new([], :case_first => :wat) }.should 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
-      lambda { SortKeyBuilder.new([], :maximum_level => :wat) }.should raise_error(ArgumentError)
+      expect { SortKeyBuilder.new([], :maximum_level => :wat) }.to raise_error(ArgumentError)
     end
 
     it 'raises an ArgumentError for non-hash second argument' do
-      lambda { SortKeyBuilder.new([], :upper) }.should raise_error(ArgumentError)
+      expect { SortKeyBuilder.new([], :upper) }.to raise_error(ArgumentError)
     end
   end
 
   describe '#bytes_array' do
     it 'builds sort key bytes' do
-      sort_key.bytes_array.should == sort_key_bytes
+      expect(sort_key.bytes_array).to eq(sort_key_bytes)
     end
 
     it 'builds bytes array only once' do
@@ -60,80 +60,82 @@ describe SortKeyBuilder do
 
     describe 'primary weights' do
       it 'compresses primary weights' do
-        SortKeyBuilder.new([[0x7A72,     0, 0], [0x7A73, 0, 0], [0x7A75, 0, 0], [0x908, 0, 0], [0x7A73, 0, 0]]).bytes_array.should ==
+        expect(SortKeyBuilder.new([[0x7A72,     0, 0], [0x7A73, 0, 0], [0x7A75, 0, 0], [0x908, 0, 0], [0x7A73, 0, 0]]).bytes_array).to eq(
                             [0x7A, 0x72,           0x73,           0x75, 0x3,    0x9, 0x08,     0x7A, 0x73, 1, 1]
+        )
 
-        SortKeyBuilder.new([[0x7A72,     0, 0], [0x7A73, 0, 0], [0x7A75, 0, 0], [0x9508, 0, 0], [0x7A73, 0, 0]]).bytes_array.should ==
+        expect(SortKeyBuilder.new([[0x7A72,     0, 0], [0x7A73, 0, 0], [0x7A75, 0, 0], [0x9508, 0, 0], [0x7A73, 0, 0]]).bytes_array).to eq(
                             [0x7A, 0x72,           0x73,           0x75, 0xFF,   0x95, 0x08,     0x7A, 0x73, 1, 1]
+        )
       end
 
       it 'works when there is an ignorable primary weight in the middle' do
-        SortKeyBuilder.new([[0x1312, 0, 0], [0, 0, 0], [0x1415, 0, 0]]).bytes_array.should == [0x13, 0x12, 0x14, 0x15, 1, 1]
+        expect(SortKeyBuilder.new([[0x1312, 0, 0], [0, 0, 0], [0x1415, 0, 0]]).bytes_array).to eq([0x13, 0x12, 0x14, 0x15, 1, 1])
       end
 
       it 'do not compress single byte primary weights' do
-        SortKeyBuilder.new([[0x13, 0, 0], [0x13, 0, 0]]).bytes_array.should == [0x13, 0x13, 1, 1]
+        expect(SortKeyBuilder.new([[0x13, 0, 0], [0x13, 0, 0]]).bytes_array).to eq([0x13, 0x13, 1, 1])
       end
 
       it 'resets primary lead bytes counter after a single byte weight' do
-        SortKeyBuilder.new([[0x1415, 0, 0], [0x13, 0, 0], [0x13, 0, 0], [0x1412, 0, 0]]).bytes_array.should == [0x14, 0x15, 0x13, 0x13, 0x14, 0x12, 1, 1]
+        expect(SortKeyBuilder.new([[0x1415, 0, 0], [0x13, 0, 0], [0x13, 0, 0], [0x1412, 0, 0]]).bytes_array).to eq([0x14, 0x15, 0x13, 0x13, 0x14, 0x12, 1, 1])
       end
 
       it 'compresses only compressible primary weights' do
-        SortKeyBuilder.new([[0x812, 0, 0], [0x811, 0, 0]]).bytes_array.should == [0x8, 0x12, 0x8, 0x11, 1, 1]
+        expect(SortKeyBuilder.new([[0x812, 0, 0], [0x811, 0, 0]]).bytes_array).to eq([0x8, 0x12, 0x8, 0x11, 1, 1])
       end
     end
 
     describe 'secondary weights' do
       it 'compresses secondary weights' do
-        SortKeyBuilder.new([[0, 5, 0], [0, 5, 0], [0, 141, 0], [0, 5, 0], [0, 5, 0]]).bytes_array.should == [1, 133, 141, 6, 1]
+        expect(SortKeyBuilder.new([[0, 5, 0], [0, 5, 0], [0, 141, 0], [0, 5, 0], [0, 5, 0]]).bytes_array).to eq([1, 133, 141, 6, 1])
       end
 
       it 'compresses secondary weights into multiple bytes if necessary' do
-        SortKeyBuilder.new([[0, 5, 0]] * 100).bytes_array.should == [1, 69, 40, 1]
+        expect(SortKeyBuilder.new([[0, 5, 0]] * 100).bytes_array).to eq([1, 69, 40, 1])
       end
     end
 
     describe 'tertiary weights' do
       context 'when case_first is not set' do
         it 'removes case bits and adds top addition to bytes that are greater than common' do
-          SortKeyBuilder.new([[0, 0, 9], [0, 0, 73], [0, 0, 137], [0, 0, 201]]).bytes_array.should == [1, 1, 137, 137, 137, 137]
+          expect(SortKeyBuilder.new([[0, 0, 9], [0, 0, 73], [0, 0, 137], [0, 0, 201]]).bytes_array).to eq([1, 1, 137, 137, 137, 137])
         end
 
         it 'compresses tertiary weights' do
-          SortKeyBuilder.new([[0, 0, 5], [0, 0, 5], [0, 0, 39], [0, 0, 5], [0, 0, 5]]).bytes_array.should == [1, 1, 0x84, 0xA7, 6]
+          expect(SortKeyBuilder.new([[0, 0, 5], [0, 0, 5], [0, 0, 39], [0, 0, 5], [0, 0, 5]]).bytes_array).to eq([1, 1, 0x84, 0xA7, 6])
         end
 
         it 'compresses tertiary weights into multiple bytes if necessary' do
-          SortKeyBuilder.new([[0, 0, 5]] * 100).bytes_array.should == [1, 1, 0x30, 0x30, 0x12]
+          expect(SortKeyBuilder.new([[0, 0, 5]] * 100).bytes_array).to eq([1, 1, 0x30, 0x30, 0x12])
         end
       end
 
       context 'when case_first is :upper' do
         it 'inverts case bits and subtract bottom addition from bytes that are smaller than common' do
-          SortKeyBuilder.new([[0, 0, 9], [0, 0, 80], [0, 0, 143]], :case_first => :upper).bytes_array.should == [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
-          SortKeyBuilder.new([[0, 0, 5], [0, 0, 5], [0, 0, 39], [0, 0, 5], [0, 0, 5]], :case_first => :upper).bytes_array.should == [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
-          SortKeyBuilder.new([[0, 0, 5]] * 100, :case_first => :upper).bytes_array.should == [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
-          SortKeyBuilder.new([[0, 0, 9], [0, 0, 80], [0, 0, 143]], :case_first => :lower).bytes_array.should == [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
-          SortKeyBuilder.new([[0, 0, 5], [0, 0, 5], [0, 0, 39], [0, 0, 5], [0, 0, 5]], :case_first => :lower).bytes_array.should == [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
-          SortKeyBuilder.new([[0, 0, 5]] * 100, :case_first => :lower).bytes_array.should == [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
@@ -141,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
-          SortKeyBuilder.new([[63, 13, 149], [66, 81, 143]], :maximum_level => 2).bytes_array.should == [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
-          SortKeyBuilder.new([[63, 13, 149], [66, 81, 143]], :maximum_level => 1).bytes_array.should == [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

@@ -49,7 +49,7 @@ describe 'Unicode collation tailoring' do
         else
           failures_info = "#{failures.size} failures: #{failures.inspect}"
           puts failures_info
-          failures.should(be_empty, "#{locale} - #{failures_info}")
+          expect(failures).to(be_empty, "#{locale} - #{failures_info}")
         end
       end
     end

data/spec/collation/trie_builder_spec.rb

@@ -15,12 +15,12 @@ describe TrieBuilder do
     before(:each) { mock_default_table }
 
     it 'returns a Trie' do
-      trie.should be_instance_of(Trie)
+      expect(trie).to be_instance_of(Trie)
     end
 
     it 'adds every collation element from the fractional collation elements table to the trie' do
       collation_elements_table.each do |code_points, collation_elements|
-        trie.get(code_points).should == collation_elements
+        expect(trie.get(code_points)).to eq(collation_elements)
       end
     end
 
@@ -124,34 +124,34 @@ END
     end
 
     it 'returns a TrieWithFallback' do
-      tailored_trie.should be_instance_of(TrieWithFallback)
+      expect(tailored_trie).to be_instance_of(TrieWithFallback)
     end
 
     it 'tailors elements in the trie' do
-      fallback.get([0x0491]).should == [[0x5C1A, 5, 9], [0, 0xDBB9, 9]]
-      fallback.get([0x0490]).should == [[0x5C1A, 5, 0x93], [0, 0xDBB9, 9]]
+      expect(fallback.get([0x0491])).to eq([[0x5C1A, 5, 9], [0, 0xDBB9, 9]])
+      expect(fallback.get([0x0490])).to eq([[0x5C1A, 5, 0x93], [0, 0xDBB9, 9]])
 
-      tailored_trie.get([0x0491]).should == [[0x5C1B, 5, 5]]
-      tailored_trie.get([0x0490]).should == [[0x5C1B, 5, 0x86]]
+      expect(tailored_trie.get([0x0491])).to eq([[0x5C1B, 5, 5]])
+      expect(tailored_trie.get([0x0490])).to eq([[0x5C1B, 5, 0x86]])
     end
 
     it 'makes contractions available in the tailored trie' do
-      tailored_trie.get([0x491, 0x306]).should == [[0x5C, 0xDB, 9]]
-      tailored_trie.get([0x415, 0x306]).should == [[0x5C36, 5, 0x8F]]
+      expect(tailored_trie.get([0x491, 0x306])).to eq([[0x5C, 0xDB, 9]])
+      expect(tailored_trie.get([0x415, 0x306])).to eq([[0x5C36, 5, 0x8F]])
     end
 
     it 'suppresses required contractions' do
-      fallback.find_prefix([0x41A, 0x301]).first(2).should == [[[0x5CCC, 5, 0x8F]], 2]
-      fallback.find_prefix([0x413, 0x301]).first(2).should == [[[0x5C30, 5, 0x8F]], 2]
+      expect(fallback.find_prefix([0x41A, 0x301]).first(2)).to eq([[[0x5CCC, 5, 0x8F]], 2])
+      expect(fallback.find_prefix([0x413, 0x301]).first(2)).to eq([[[0x5C30, 5, 0x8F]], 2])
 
-      tailored_trie.find_prefix([0x41A, 0x301]).first(2).should == [[[0x5C6C, 5, 0x8F]], 1]
-      tailored_trie.find_prefix([0x413, 0x301]).first(2).should == [[[0x5C1A, 5, 0x8F]], 1]
+      expect(tailored_trie.find_prefix([0x41A, 0x301]).first(2)).to eq([[[0x5C6C, 5, 0x8F]], 1])
+      expect(tailored_trie.find_prefix([0x413, 0x301]).first(2)).to eq([[[0x5C1A, 5, 0x8F]], 1])
     end
 
     it 'do not copy other collation elements from the fallback' do
       [0x301, 0x306, 0x41A, 0x413, 0x415].each_slice(1) do |code_points|
-        tailored_trie.get(code_points).should_not be_nil
-        tailored_trie.get(code_points).object_id.should == fallback.get(code_points).object_id
+        expect(tailored_trie.get(code_points)).not_to be_nil
+        expect(tailored_trie.get(code_points).object_id).to eq(fallback.get(code_points).object_id)
       end
     end
 
@@ -187,7 +187,7 @@ END
 
     it 'loads tailoring data' do
       mock(TwitterCldr).get_resource(:collation, :tailoring, locale) { tailoring_data }
-      TrieBuilder.tailoring_data(locale).should == tailoring_data
+      expect(TrieBuilder.tailoring_data(locale)).to eq(tailoring_data)
     end
   end
 

data/spec/collation/trie_dumps_spec.rb

@@ -12,7 +12,7 @@ describe 'trie dumps', :slow => true do
   let(:error_message) { 'expected trie dump to be up-to-date.' }
 
   it 'has a valid default Fractional Collation Elements trie dump' do
-    TrieLoader.load_default_trie.to_hash.should(eq(default_trie.to_hash), error_message)
+    expect(TrieLoader.load_default_trie.to_hash).to(eq(default_trie.to_hash), error_message)
   end
 
   TwitterCldr.supported_locales.each do |locale|
@@ -20,7 +20,7 @@ describe 'trie dumps', :slow => true do
       loaded_trie = TrieLoader.load_tailored_trie(locale, Trie.new)
       fresh_trie  = TrieBuilder.load_tailored_trie(locale, default_trie)
 
-      loaded_trie.to_hash.should(eq(fresh_trie.to_hash), error_message)
+      expect(loaded_trie.to_hash).to(eq(fresh_trie.to_hash), error_message)
     end
   end
 end

data/spec/collation/trie_loader_spec.rb

@@ -19,15 +19,15 @@ describe TrieLoader do
     before(:each) { mock_trie_dump }
 
     it 'loads a Trie' do
-      loaded_trie.should be_instance_of(Trie)
+      expect(loaded_trie).to be_instance_of(Trie)
     end
 
     it 'loads trie root' do
-      loaded_trie.instance_variable_get(:@root).should == root
+      expect(loaded_trie.instance_variable_get(:@root)).to eq(root)
     end
 
     it 'loads trie as unlocked' do
-      loaded_trie.should_not be_locked
+      expect(loaded_trie).not_to be_locked
     end
   end
 
@@ -43,25 +43,25 @@ describe TrieLoader do
     before(:each) { mock_trie_dump }
 
     it 'loads a TrieWithFallback' do
-      loaded_trie.should be_instance_of(TrieWithFallback)
+      expect(loaded_trie).to be_instance_of(TrieWithFallback)
     end
 
     it 'loads trie root' do
-      loaded_trie.instance_variable_get(:@root).should == root
+      expect(loaded_trie.instance_variable_get(:@root)).to eq(root)
     end
 
     it 'loads trie as unlocked' do
-      loaded_trie.should_not be_locked
+      expect(loaded_trie).not_to be_locked
     end
 
     it 'sets trie fallback' do
-      loaded_trie.fallback.should == new_fallback
+      expect(loaded_trie.fallback).to eq(new_fallback)
     end
   end
 
   describe '.dump_path' do
     it 'returns path to a trie dump for a specific locale' do
-      TrieLoader.dump_path(:foo).should == File.join(TwitterCldr::RESOURCES_DIR, 'collation', 'tries', 'foo.dump')
+      expect(TrieLoader.dump_path(:foo)).to eq(File.join(TwitterCldr::RESOURCES_DIR, 'collation', 'tries', 'foo.dump'))
     end
   end