twitter_cldr 3.0.1 → 3.0.2

data/spec/collation/trie_spec.rb

@@ -28,37 +28,37 @@ describe Trie do
 
   describe '#initialize' do
     it 'initializes an empty trie by default' do
-      Trie.new.should be_empty
+      expect(Trie.new).to be_empty
     end
 
     it 'initializes with a root node' do
       trie = Trie.new(Trie::Node.new(nil, 1 => Trie::Node.new(nil, { 2 => Trie::Node.new('12')}), 2 => Trie::Node.new('2')))
 
-      trie.to_hash.should == {
+      expect(trie.to_hash).to eq({
           1 => [nil, { 2 => ['12', {}] }],
           2 => ['2', {}]
-      }
+      })
     end
   end
 
   describe '#lock and #locked?' do
     it 'trie is unlocked by default' do
-      trie.should_not be_locked
+      expect(trie).not_to be_locked
     end
 
     it '#lock locks the trie' do
       trie.lock
-      trie.should be_locked
+      expect(trie).to be_locked
     end
 
     it '#lock returns the trie' do
-      trie.lock.should == trie
+      expect(trie.lock).to eq(trie)
     end
   end
 
   describe '#starters' do
     it 'returns all unique first elements of the keys in the trie' do
-      trie.starters.should =~ [1, 2, 3, 4]
+      expect(trie.starters).to match_array([1, 2, 3, 4])
     end
   end
 
@@ -67,64 +67,64 @@ describe Trie do
       res = {}
       trie.each_starting_with(1) { |k, v| res[k] = v }
 
-      res.should == { [1] => '1', [1, 4] => '14', [1, 5] => '15', [1, 4, 8] => '148' }
+      expect(res).to eq({ [1] => '1', [1, 4] => '14', [1, 5] => '15', [1, 4, 8] => '148' })
     end
 
     it 'works when argument is not a starter' do
       res = {}
       trie.each_starting_with(42) { |k, v| res[k] = v }
 
-      res.should == {}
+      expect(res).to eq({})
     end
   end
 
   describe '#get' do
     it 'returns nil for non existing keys' do
-      [[6], [3], [1, 4, 3], [2, 7, 5, 6, 9]].each { |key| trie.get(key).should be_nil }
+      [[6], [3], [1, 4, 3], [2, 7, 5, 6, 9]].each { |key| expect(trie.get(key)).to be_nil }
     end
 
     it 'returns value for each existing key' do
-      values.each { |key, value| trie.get(key).should == value }
+      values.each { |key, value| expect(trie.get(key)).to eq(value) }
     end
   end
 
   describe '#add' do
     it 'does not override values' do
-      trie.get([1, 4]).should == '14'
+      expect(trie.get([1, 4])).to eq('14')
 
       trie.add([1, 4], '14-new')
-      trie.get([1, 4]).should == '14'
+      expect(trie.get([1, 4])).to eq('14')
     end
 
     it 'adds new values' do
-      trie.get([1, 9]).should be_nil
+      expect(trie.get([1, 9])).to be_nil
 
       trie.add([1, 9], '19')
-      trie.get([1, 9]).should == '19'
+      expect(trie.get([1, 9])).to eq('19')
     end
 
     it 'raises RuntimeError if called on a locked trie' do
-      lambda { trie.lock.add([1, 3], 'value') }.should raise_error(RuntimeError)
+      expect { trie.lock.add([1, 3], 'value') }.to raise_error(RuntimeError)
     end
   end
 
   describe '#set' do
     it 'overrides values' do
-      trie.get([1, 4]).should == '14'
+      expect(trie.get([1, 4])).to eq('14')
 
       trie.set([1, 4], '14-new')
-      trie.get([1, 4]).should == '14-new'
+      expect(trie.get([1, 4])).to eq('14-new')
     end
 
     it 'adds new values' do
-      trie.get([1, 9]).should be_nil
+      expect(trie.get([1, 9])).to be_nil
 
       trie.set([1, 9], '19')
-      trie.get([1, 9]).should == '19'
+      expect(trie.get([1, 9])).to eq('19')
     end
 
     it 'raises RuntimeError if called on a locked trie' do
-      lambda { trie.lock.set([1, 3], 'value') }.should raise_error(RuntimeError)
+      expect { trie.lock.set([1, 3], 'value') }.to raise_error(RuntimeError)
     end
   end
 
@@ -140,12 +140,12 @@ describe Trie do
 
     describe 'first two elements of the returned array (value and prefix size)' do
       it 'are nil and 0 if the prefix was not found' do
-        trie.find_prefix([42]).first(2).should == [nil, 0]
+        expect(trie.find_prefix([42]).first(2)).to eq([nil, 0])
       end
 
       it 'are the stored value and the key size if the whole key was found' do
         values.each do |key, value|
-          trie.find_prefix(key).first(2).should == [value, key.size]
+          expect(trie.find_prefix(key).first(2)).to eq([value, key.size])
         end
       end
 
@@ -158,12 +158,12 @@ describe Trie do
         }
 
         tests.each do |key, result|
-          trie.find_prefix(key).first(2).should == result
+          expect(trie.find_prefix(key).first(2)).to eq(result)
         end
       end
 
       def test_find_prefix(trie, key, value, size = key.size)
-        trie.find_prefix(key).first(2).should == [value, size]
+        expect(trie.find_prefix(key).first(2)).to eq([value, size])
       end
     end
 
@@ -175,23 +175,23 @@ describe Trie do
       it 'is always a locked trie' do
         [trie, trie.lock].each do |some_trie|
           [non_existing_key, key_with_suffixes, key_without_suffixes].each do |key|
-            some_trie.find_prefix(key).last.should be_locked
+            expect(some_trie.find_prefix(key).last).to be_locked
           end
         end
       end
 
       it 'is a locked empty subtrie if the prefix that was found does not have any suffixes' do
-        trie.find_prefix(key_without_suffixes).last.to_hash.should be_empty
+        expect(trie.find_prefix(key_without_suffixes).last.to_hash).to be_empty
       end
 
       it 'is a subtrie of possible suffixes for the prefix that was found' do
-        trie.find_prefix(key_with_suffixes).last.to_hash.should == { 7 => [nil, { 5 => ["275", {}] }] }
+        expect(trie.find_prefix(key_with_suffixes).last.to_hash).to eq({ 7 => [nil, { 5 => ["275", {}] }] })
       end
 
       it 'is a hash representing the whole trie if the prefix was not found' do
-        trie.get(non_existing_key).should be_nil
+        expect(trie.get(non_existing_key)).to be_nil
 
-        trie.find_prefix(non_existing_key).last.to_hash.should == root_subtrie
+        expect(trie.find_prefix(non_existing_key).last.to_hash).to eq(root_subtrie)
       end
 
     end
@@ -199,26 +199,26 @@ describe Trie do
     context 'argument does not match any value, but is a prefix of a longer key' do
       context 'argument has a shorter key as a prefix' do
         it 'returns value for the key, its size and suffixes subtrie' do
-          trie.get([2]).should_not be_nil
-          trie.get([2, 7, 5]).should_not be_nil
+          expect(trie.get([2])).not_to be_nil
+          expect(trie.get([2, 7, 5])).not_to be_nil
 
           result = trie.find_prefix([2, 7])
 
-          result.first(2).should == ['2', 1]
-          result.last.to_hash.should == { 7 => [nil, { 5 => ["275", {}] }] }
+          expect(result.first(2)).to eq(['2', 1])
+          expect(result.last.to_hash).to eq({ 7 => [nil, { 5 => ["275", {}] }] })
         end
       end
 
       context 'argument does not have a shorter key as a prefix' do
         it 'returns nil, 0 and suffixes subtrie for the root node' do
-          trie.get([3]).should be_nil
-          trie.get([3, 9]).should be_nil
-          trie.get([3, 9, 2]).should_not be_nil
+          expect(trie.get([3])).to be_nil
+          expect(trie.get([3, 9])).to be_nil
+          expect(trie.get([3, 9, 2])).not_to be_nil
 
           result = trie.find_prefix([3, 9])
 
-          result.first(2).should == [nil, 0]
-          result.last.to_hash.should == root_subtrie
+          expect(result.first(2)).to eq([nil, 0])
+          expect(result.last.to_hash).to eq(root_subtrie)
         end
       end
     end
@@ -231,11 +231,11 @@ describe Trie do
       trie.add([13, 37], 1337)
       trie.add([42], 42)
 
-      Marshal.load(Marshal.dump(trie)).to_hash.should == { 42 => [42, {}], 13 => [nil, { 37 => [1337, {}] }] }
+      expect(Marshal.load(Marshal.dump(trie)).to_hash).to eq({ 42 => [42, {}], 13 => [nil, { 37 => [1337, {}] }] })
     end
 
     it 'does not dump locked state' do
-      Marshal.load(Marshal.dump(Trie.new.lock)).should_not be_locked
+      expect(Marshal.load(Marshal.dump(Trie.new.lock))).not_to be_locked
     end
   end
 
@@ -288,36 +288,36 @@ describe Trie do
 
     describe '#initialize' do
       it 'initializes node with nil value and empty children hash by default' do
-        node.value.should be_nil
-        node.should_not have_children
+        expect(node.value).to be_nil
+        expect(node).not_to have_children
       end
 
       it 'initializes node with provided value and children hash' do
-        root_node.value.should == 'node-0'
-        root_node.should have_children
+        expect(root_node.value).to eq('node-0')
+        expect(root_node).to have_children
       end
     end
 
     describe '#child and #set_child' do
       it '#child returns nil if a child with a given key does not exist' do
-        node.child(42).should be_nil
+        expect(node.child(42)).to be_nil
       end
 
       it '#set_child saves a child by key and #child returns the child by key' do
         node.set_child(42, child)
-        node.child(42).should == child
+        expect(node.child(42)).to eq(child)
       end
 
       it '#set_child overrides a child by key' do
         node.set_child(42, child)
         node.set_child(42, another_child)
 
-        node.child(42).should_not == child
-        node.child(42).should == another_child
+        expect(node.child(42)).not_to eq(child)
+        expect(node.child(42)).to eq(another_child)
       end
 
       it '#set_child returns the child that was saved' do
-        node.set_child(42, child).should == child
+        expect(node.set_child(42, child)).to eq(child)
       end
     end
 
@@ -328,7 +328,7 @@ describe Trie do
         res = {}
         node.each_key_and_child { |key, child| res[key] = child }
 
-        res.should == { 42 => child, 13 => another_child }
+        expect(res).to eq({ 42 => child, 13 => another_child })
       end
     end
 
@@ -337,47 +337,47 @@ describe Trie do
         node.set_child(42, child)
         node.set_child(13, another_child)
 
-        node.keys.should =~ [13, 42]
+        expect(node.keys).to match_array([13, 42])
       end
     end
 
     describe '#has_children?' do
       it 'returns false if the node has no children' do
-        node.should_not have_children
+        expect(node).not_to have_children
       end
 
       it 'returns true if the node has children' do
         node.set_child(42, child)
-        node.should have_children
+        expect(node).to have_children
       end
     end
 
     describe '#to_trie' do
       it 'returns a trie' do
-        node.to_trie.should be_instance_of(Trie)
+        expect(node.to_trie).to be_instance_of(Trie)
       end
 
       it 'returns a locked trie' do
-        node.to_trie.should be_locked
+        expect(node.to_trie).to be_locked
       end
 
       it 'current node is a root of a new trie' do
-        root_node.to_trie.to_hash.should == subtrie_hash
+        expect(root_node.to_trie.to_hash).to eq(subtrie_hash)
       end
 
       it 'sets new trie root value to nil' do
-        root_node.value.should_not be_nil
-        root_node.to_trie.instance_variable_get(:@root).value.should be_nil
+        expect(root_node.value).not_to be_nil
+        expect(root_node.to_trie.instance_variable_get(:@root).value).to be_nil
       end
     end
 
     describe '#subtrie_hash' do
       it 'returns an empty hash if the node has no children' do
-        node.subtrie_hash.should == {}
+        expect(node.subtrie_hash).to eq({})
       end
 
       it 'returns a nested hash of children values' do
-        root_node.subtrie_hash.should == subtrie_hash
+        expect(root_node.subtrie_hash).to eq(subtrie_hash)
       end
     end
 

data/spec/collation/trie_with_fallback_spec.rb

@@ -17,30 +17,30 @@ describe TrieWithFallback do
   describe '#get' do
     it 'returns result if the key is present' do
       dont_allow(fallback).get
-      trie.get([1, 2, 3]).should == 'value'
+      expect(trie.get([1, 2, 3])).to eq('value')
     end
 
     it 'resorts to the fallback if the key is not present' do
       mock(fallback).get([3, 2, 1]) { 'fallback-value' }
-      trie.get([3, 2, 1]).should == 'fallback-value'
+      expect(trie.get([3, 2, 1])).to eq('fallback-value')
     end
   end
 
   describe '#find_prefix' do
     it 'returns result if the key is present' do
       dont_allow(fallback).find_prefix
-      trie.find_prefix([1, 2, 3, 4]).first(2).should == ['value', 3]
+      expect(trie.find_prefix([1, 2, 3, 4]).first(2)).to eq(['value', 3])
     end
 
     it 'resorts to the fallback if the key is not present' do
       mock(fallback).find_prefix([3, 2, 1]) { 'fallback-result' }
-      trie.find_prefix([3, 2, 1]).should == 'fallback-result'
+      expect(trie.find_prefix([3, 2, 1])).to eq('fallback-result')
     end
   end
 
   describe 'marshaling' do
     it 'does not dump fallback' do
-      Marshal.load(Marshal.dump(TrieWithFallback.new(Trie.new))).fallback.should be_nil
+      expect(Marshal.load(Marshal.dump(TrieWithFallback.new(Trie.new))).fallback).to be_nil
     end
   end
 

data/spec/core_ext_spec.rb

@@ -11,7 +11,7 @@ describe 'Core classes localization' do
     describe klass do
       it 'has public instance method #localize' do
         # convert methods names to symbols (they're strings in 1.8)
-        klass.public_instance_methods.map(&:to_sym).should include(:localize)
+        expect(klass.public_instance_methods.map(&:to_sym)).to include(:localize)
       end
     end
   end

data/spec/data_readers/additional_date_format_selector_spec.rb

@@ -18,13 +18,13 @@ describe AdditionalDateFormatSelector do
     it "calculates the score based on relative offset from actual position" do
       goal_entities = selector.send(:separate, "MMMyyd")
       entities      = selector.send(:separate, "d")
-      selector.send(:position_score, entities, goal_entities).should == 2
+      expect(selector.send(:position_score, entities, goal_entities)).to eq(2)
     end
 
     it "calculates a zero score if all entites are in the same positions" do
       goal_entities = selector.send(:separate, "MMMyyd")
       entities      = selector.send(:separate, "MMMyyd")
-      selector.send(:position_score, entities, goal_entities).should == 0
+      expect(selector.send(:position_score, entities, goal_entities)).to eq(0)
     end
   end
 
@@ -32,13 +32,13 @@ describe AdditionalDateFormatSelector do
     it "calculates a higher score if an entity doesn't exist" do
       goal_entities = selector.send(:separate, "MMMEd")
       entities      = selector.send(:separate, "d")
-      selector.send(:exist_score, entities, goal_entities).should == 2
+      expect(selector.send(:exist_score, entities, goal_entities)).to eq(2)
     end
 
     it "calculates a zero score if all entities exist" do
       goal_entities = selector.send(:separate, "MMMyyd")
       entities      = selector.send(:separate, "dMMMyy")
-      selector.send(:exist_score, entities, goal_entities).should == 0
+      expect(selector.send(:exist_score, entities, goal_entities)).to eq(0)
     end
   end
 
@@ -46,13 +46,13 @@ describe AdditionalDateFormatSelector do
     it "calculates the score based on the difference in the length of each matching entity" do
       goal_entities = selector.send(:separate, "MMMyyd")
       entities      = selector.send(:separate, "ddMMy")
-      selector.send(:count_score, entities, goal_entities).should == 3
+      expect(selector.send(:count_score, entities, goal_entities)).to eq(3)
     end
 
     it "calculates a zero score if all entities are the same length" do
       goal_entities = selector.send(:separate, "MMMyyd")
       entities      = selector.send(:separate, "d")
-      selector.send(:count_score, entities, goal_entities).should == 0
+      expect(selector.send(:count_score, entities, goal_entities)).to eq(0)
     end
   end
 
@@ -60,72 +60,72 @@ describe AdditionalDateFormatSelector do
     it "calculates a cumulative score from position and count" do
       goal_entities = selector.send(:separate, "MMMyydGG")
       entities      = selector.send(:separate, "ddMMGGyy")
-      selector.send(:exist_score, entities, goal_entities).should == 0
-      selector.send(:count_score, entities, goal_entities).should == 2
-      selector.send(:position_score, entities, goal_entities).should == 3
-      selector.send(:score, entities, goal_entities).should == 5
+      expect(selector.send(:exist_score, entities, goal_entities)).to eq(0)
+      expect(selector.send(:count_score, entities, goal_entities)).to eq(2)
+      expect(selector.send(:position_score, entities, goal_entities)).to eq(3)
+      expect(selector.send(:score, entities, goal_entities)).to eq(5)
     end
 
     it "calculates a cumulative score from position, count, and existence (existence weighted by 2)" do
       goal_entities = selector.send(:separate, "MMMyydGG")
       entities      = selector.send(:separate, "ddMMyy")
-      selector.send(:exist_score, entities, goal_entities).should == 1
-      selector.send(:count_score, entities, goal_entities).should == 2
-      selector.send(:position_score, entities, goal_entities).should == 1
+      expect(selector.send(:exist_score, entities, goal_entities)).to eq(1)
+      expect(selector.send(:count_score, entities, goal_entities)).to eq(2)
+      expect(selector.send(:position_score, entities, goal_entities)).to eq(1)
       # (exist_score * 2) + count_score + position_score
-      selector.send(:score, entities, goal_entities).should == 5
+      expect(selector.send(:score, entities, goal_entities)).to eq(5)
     end
   end
 
   describe "#rank" do
     it "returns a score for each available format" do
       ranked_formats = selector.send(:rank, "MMMd")
-      ranked_formats["MMMd"].should == 0
-      ranked_formats["yMEd"].should == 4
-      ranked_formats["y"].should == 4
-      ranked_formats["EHms"].should == 4
-      ranked_formats["MMM"].should == 2
+      expect(ranked_formats["MMMd"]).to eq(0)
+      expect(ranked_formats["yMEd"]).to eq(4)
+      expect(ranked_formats["y"]).to eq(4)
+      expect(ranked_formats["EHms"]).to eq(4)
+      expect(ranked_formats["MMM"]).to eq(2)
     end
   end
 
   describe "#find_closest" do
     it "returns an exact match if it exists" do
-      selector.find_closest("h").should == selector.pattern_hash[:h]
-      selector.find_closest("MMMd").should == selector.pattern_hash[:MMMd]
-      selector.find_closest("Hms").should == selector.pattern_hash[:Hms]
-      selector.find_closest("yQQQQ").should == selector.pattern_hash[:yQQQQ]
+      expect(selector.find_closest("h")).to eq(selector.pattern_hash[:h])
+      expect(selector.find_closest("MMMd")).to eq(selector.pattern_hash[:MMMd])
+      expect(selector.find_closest("Hms")).to eq(selector.pattern_hash[:Hms])
+      expect(selector.find_closest("yQQQQ")).to eq(selector.pattern_hash[:yQQQQ])
     end
 
     it "returns the next closest match (lowest score) if an exact match can't be found" do
-      selector.find_closest("MMMMd").should == selector.pattern_hash[:MMMd]
-      selector.find_closest("mHs").should == selector.pattern_hash[:Hms]
-      selector.find_closest("Med").should == selector.pattern_hash[:MEd]
+      expect(selector.find_closest("MMMMd")).to eq(selector.pattern_hash[:MMMd])
+      expect(selector.find_closest("mHs")).to eq(selector.pattern_hash[:Hms])
+      expect(selector.find_closest("Med")).to eq(selector.pattern_hash[:MEd])
     end
 
     it "returns nil if an empty pattern is given" do
-      selector.find_closest(nil).should be_nil
-      selector.find_closest("").should be_nil
-      selector.find_closest(" ").should be_nil
+      expect(selector.find_closest(nil)).to be_nil
+      expect(selector.find_closest("")).to be_nil
+      expect(selector.find_closest(" ")).to be_nil
     end
   end
 
   describe "#separate" do
     it "divides a string into entities by runs of equal characters" do
-      selector.send(:separate, "ddMMyy").should == ["dd", "MM", "yy"]
-      selector.send(:separate, "ddMMyyMM").should == ["dd", "MM", "yy", "MM"]
-      selector.send(:separate, "mmMM").should == ["mm", "MM"]
+      expect(selector.send(:separate, "ddMMyy")).to eq(["dd", "MM", "yy"])
+      expect(selector.send(:separate, "ddMMyyMM")).to eq(["dd", "MM", "yy", "MM"])
+      expect(selector.send(:separate, "mmMM")).to eq(["mm", "MM"])
     end
   end
 
   describe "#patterns" do
     it "returns a list of all available patterns" do
       patterns = selector.patterns
-      patterns.should be_a(Array)
-      patterns.should include("MMMd")
-      patterns.should include("yQQQ")
-      patterns.should include("yQQQQ")
-      patterns.should include("EHms")
-      patterns.should include("d")
+      expect(patterns).to be_a(Array)
+      expect(patterns).to include("MMMd")
+      expect(patterns).to include("yQQQ")
+      expect(patterns).to include("yQQQQ")
+      expect(patterns).to include("EHms")
+      expect(patterns).to include("d")
     end
   end
 

data/spec/data_readers/date_time_data_reader_spec.rb

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

data/spec/data_readers/number_data_reader_spec.rb

@@ -12,7 +12,7 @@ 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| data_reader.send(:get_key_for, "1337#{"0" * (i - 3)}").should == 10 ** i }
+      (3..15).each { |i| expect(data_reader.send(:get_key_for, "1337#{"0" * (i - 3)}")).to eq(10 ** i) }
     end
   end
 end