twitter_cldr 3.0.1 → 3.0.2

data/spec/parsers/unicode_regex_parser_spec.rb

@@ -23,64 +23,64 @@ describe UnicodeRegexParser do
   describe "#parse" do
     it "identifies ranges" do
       elements = parse(tokenize("[a-z]"))
-      elements.first.should be_a(UnicodeRegexParser::CharacterClass)
+      expect(elements.first).to be_a(UnicodeRegexParser::CharacterClass)
       root = elements.first.send(:root)
-      root.should be_a(UnicodeRegexParser::CharacterRange)
-      root.initial.codepoints.should == "a".unpack("U*")
-      root.final.codepoints.should == "z".unpack("U*")
+      expect(root).to be_a(UnicodeRegexParser::CharacterRange)
+      expect(root.initial.codepoints).to eq("a".unpack("U*"))
+      expect(root.final.codepoints).to eq("z".unpack("U*"))
     end
 
     it "replaces variables" do
       symbol_table = SymbolTable.new("$VAR" => tokenize("\\p{L}"))
       elements = parse(tokenize("($VAR)?"), :symbol_table => symbol_table)
-      elements[1].should be_a(UnicodeRegexParser::CharacterSet)
-      elements[1].property_value.should == "L"
+      expect(elements[1]).to be_a(UnicodeRegexParser::CharacterSet)
+      expect(elements[1].property_value).to eq("L")
     end
 
     it "handles character and negated character sets" do
       elements = parse(tokenize("\\p{L}[:^P:]\\P{L}[:P:]"))
 
       element = elements[0]
-      element.should be_a(UnicodeRegexParser::CharacterSet)
-      element.property_value.should == "L"
+      expect(element).to be_a(UnicodeRegexParser::CharacterSet)
+      expect(element.property_value).to eq("L")
 
       element = elements[1]
-      element.should be_a(UnicodeRegexParser::CharacterClass)
-      element.send(:root).child.property_value.should == "P"
-      element.send(:root).operator.should == :negate
+      expect(element).to be_a(UnicodeRegexParser::CharacterClass)
+      expect(element.send(:root).child.property_value).to eq("P")
+      expect(element.send(:root).operator).to eq(:negate)
 
       element = elements[2]
-      element.should be_a(UnicodeRegexParser::CharacterClass)
-      element.send(:root).child.property_value.should == "L"
+      expect(element).to be_a(UnicodeRegexParser::CharacterClass)
+      expect(element.send(:root).child.property_value).to eq("L")
 
       element = elements[3]
-      element.should be_a(UnicodeRegexParser::CharacterSet)
-      element.property_value.should == "P"
+      expect(element).to be_a(UnicodeRegexParser::CharacterSet)
+      expect(element.property_value).to eq("P")
     end
 
     it "handles unicode characters" do
       elements = parse(tokenize("\\u0123"))
-      elements[0].should be_a(UnicodeRegexParser::UnicodeString)
-      elements[0].codepoints.should == [291]
+      expect(elements[0]).to be_a(UnicodeRegexParser::UnicodeString)
+      expect(elements[0].codepoints).to eq([291])
     end
 
     it "handles multichar and escaped unicode strings" do
       elements = parse(tokenize("\\g{abc}"))
-      elements[0].should be_a(UnicodeRegexParser::Literal)
-      elements[0].text.should == "\\g"
-      elements[1].should be_a(UnicodeRegexParser::UnicodeString)
-      elements[1].codepoints.should == [97, 98, 99]
+      expect(elements[0]).to be_a(UnicodeRegexParser::Literal)
+      expect(elements[0].text).to eq("\\g")
+      expect(elements[1]).to be_a(UnicodeRegexParser::UnicodeString)
+      expect(elements[1].codepoints).to eq([97, 98, 99])
     end
 
     it "handles special chars" do
       elements = parse(tokenize("^(?:)$"))
-      elements.each { |elem| elem.should be_a(UnicodeRegexParser::Literal) }
-      elements[0].text.should == "^"
-      elements[1].text.should == "("
-      elements[2].text.should == "?"
-      elements[3].text.should == ":"
-      elements[4].text.should == ")"
-      elements[5].text.should == "$"
+      elements.each { |elem| expect(elem).to be_a(UnicodeRegexParser::Literal) }
+      expect(elements[0].text).to eq("^")
+      expect(elements[1].text).to eq("(")
+      expect(elements[2].text).to eq("?")
+      expect(elements[3].text).to eq(":")
+      expect(elements[4].text).to eq(")")
+      expect(elements[5].text).to eq("$")
     end
   end
 end

data/spec/resources/loader_spec.rb

@@ -16,37 +16,37 @@ describe Loader do
 
     it 'loads the correct YAML file' do
       stub_resource_file(resource_path, "---\n- 1\n- 2\n")
-      loader.get_resource(:random, :resource).should == [1, 2]
+      expect(loader.get_resource(:random, :resource)).to eq([1, 2])
     end
 
     it 'symbolizes hash keys' do
       stub_resource_file(resource_path, "---\n:a:\n  :b: 3\n")
-      loader.get_resource(:random, :resource).should == { :a => { :b => 3 } }
+      expect(loader.get_resource(:random, :resource)).to eq({ :a => { :b => 3 } })
     end
 
     it 'loads the resource only once' do
       mock(loader).load_resource(resource_path).once { resource_content }
 
       result = loader.get_resource(:random, :resource)
-      result.should == resource_content
+      expect(result).to eq(resource_content)
       # second time load_resource is not called but we get the same object as before
-      loader.get_resource(:random, :resource).object_id.should == result.object_id
+      expect(loader.get_resource(:random, :resource).object_id).to eq(result.object_id)
     end
 
     it 'accepts a variable length resource path both in symbols and strings' do
       stub(loader).load_resource('foo/bar/baz.yml') { 'foo-bar-baz' }
-      loader.get_resource('foo', :bar, 'baz').should == 'foo-bar-baz'
+      expect(loader.get_resource('foo', :bar, 'baz')).to eq('foo-bar-baz')
     end
 
     it 'raises an exception if resource file is missing' do
       mock(File).file?(File.join(TwitterCldr::RESOURCES_DIR, 'foo/bar.yml')) { false }
-      lambda { loader.get_resource(:foo, :bar) }.should raise_error(ArgumentError, "Resource 'foo/bar.yml' not found.")
+      expect { loader.get_resource(:foo, :bar) }.to raise_error(ArgumentError, "Resource 'foo/bar.yml' not found.")
     end
 
     context 'custom resources' do
       it "doesn't merge the custom resource if it doesn't exist" do
         mock(loader).read_resource_file('foo/bar.yml') { ":foo: bar" }
-        loader.get_resource(:foo, :bar).should == { :foo => "bar" }
+        expect(loader.get_resource(:foo, :bar)).to eq({ :foo => "bar" })
       end
 
       context 'with a custom resource' do
@@ -61,12 +61,12 @@ describe Loader do
           mock.proxy(loader).load_resource("foo/bar.yml")
           mock.proxy(loader).load_resource("custom/foo/bar.yml", false)
 
-          loader.get_resource(:foo, :bar).should == { :foo => "bar", :bar => "baz" }
+          expect(loader.get_resource(:foo, :bar)).to eq({ :foo => "bar", :bar => "baz" })
         end
 
         it 'does not merge the custom resource if custom resources are disabled' do
           TwitterCldr.disable_custom_locale_resources = true
-          loader.get_resource(:foo, :bar).should == { :foo => "bar" }
+          expect(loader.get_resource(:foo, :bar)).to eq({ :foo => "bar" })
           TwitterCldr.disable_custom_locale_resources = false
         end
       end
@@ -76,7 +76,7 @@ describe Loader do
   describe '#get_locale_resource' do
     it 'loads the correct locale resource file' do
       stub(loader).get_resource(:locales, :de, :numbers) { 'foo' }
-      loader.get_locale_resource(:de, :numbers).should == 'foo'
+      expect(loader.get_locale_resource(:de, :numbers)).to eq('foo')
     end
 
     it 'loads the resource only once' do
@@ -84,56 +84,56 @@ describe Loader do
 
       result = loader.get_locale_resource(:de, :numbers)
       # second time get_resource is not called but we get the same object as before
-      loader.get_locale_resource(:de, :numbers).object_id.should == result.object_id
+      expect(loader.get_locale_resource(:de, :numbers).object_id).to eq(result.object_id)
     end
 
     it 'converts locales' do
       mock(TwitterCldr).convert_locale('zh-tw') { :'zh-Hant' }
       mock(loader).get_resource(:locales, :'zh-Hant', :numbers) { 'foo' }
 
-      loader.get_locale_resource('zh-tw', :numbers).should == 'foo'
+      expect(loader.get_locale_resource('zh-tw', :numbers)).to eq('foo')
     end
   end
 
   describe '#resource_loaded' do
     it 'should return true if the resource is cached, false otherwise' do
       loader.preload_resources_for_locale(:de, :numbers)
-      loader.resource_loaded?(:locales, :de, :numbers).should be_true
-      loader.resource_loaded?(:locales, :de, :calendars).should be_false
+      expect(loader.resource_loaded?(:locales, :de, :numbers)).to be_true
+      expect(loader.resource_loaded?(:locales, :de, :calendars)).to be_false
     end
   end
 
   describe '#locale_resource_loaded' do
     it 'should return true if the locale resource is cached, false otherwise' do
       loader.preload_resources_for_locale(:de, :numbers)
-      loader.locale_resource_loaded?(:de, :numbers).should be_true
-      loader.locale_resource_loaded?(:de, :calendars).should be_false
+      expect(loader.locale_resource_loaded?(:de, :numbers)).to be_true
+      expect(loader.locale_resource_loaded?(:de, :calendars)).to be_false
     end
   end
 
   describe '#resource_types' do
     it 'returns the list of available resource types' do
       types = loader.resource_types
-      types.should be_a(Array)
-      types.should include(:calendars)
-      types.should include(:numbers)
-      types.should include(:units)
+      expect(types).to be_a(Array)
+      expect(types).to include(:calendars)
+      expect(types).to include(:numbers)
+      expect(types).to include(:units)
     end
   end
 
   describe '#preload_resources_for_locale' do
     it 'loads potentially multiple resources into the cache' do
       loader.preload_resources_for_locale(:ar, :calendars, :units)
-      loader.locale_resource_loaded?(:ar, :calendars).should be_true
-      loader.locale_resource_loaded?(:ar, :units).should be_true
-      loader.locale_resource_loaded?(:en, :units).should be_false
+      expect(loader.locale_resource_loaded?(:ar, :calendars)).to be_true
+      expect(loader.locale_resource_loaded?(:ar, :units)).to be_true
+      expect(loader.locale_resource_loaded?(:en, :units)).to be_false
     end
 
     it 'loads all resources for the locale if the :all resource type is specified' do
       loader.preload_resources_for_locale(:ar, :all)
       loader.resource_types.each do |resource_type|
-        loader.locale_resource_loaded?(:ar, resource_type).should be_true
-        loader.locale_resource_loaded?(:en, resource_type).should be_false
+        expect(loader.locale_resource_loaded?(:ar, resource_type)).to be_true
+        expect(loader.locale_resource_loaded?(:en, resource_type)).to be_false
       end
     end
   end
@@ -141,9 +141,9 @@ describe Loader do
   describe '#preload_resource_for_locales' do
     it 'loads a single resource for potentially multiple locales into the cache' do
       loader.preload_resource_for_locales(:calendars, :sv, :bn)
-      loader.locale_resource_loaded?(:sv, :calendars).should be_true
-      loader.locale_resource_loaded?(:bn, :calendars).should be_true
-      loader.locale_resource_loaded?(:sv, :units).should be_false
+      expect(loader.locale_resource_loaded?(:sv, :calendars)).to be_true
+      expect(loader.locale_resource_loaded?(:bn, :calendars)).to be_true
+      expect(loader.locale_resource_loaded?(:sv, :units)).to be_false
     end
   end
 
@@ -151,9 +151,9 @@ describe Loader do
     it 'loads potentially multiple resources for all locales' do
       loader.preload_resources_for_all_locales(:plurals, :lists)
       TwitterCldr.supported_locales.each do |locale|
-        loader.locale_resource_loaded?(locale, :plurals).should be_true
-        loader.locale_resource_loaded?(locale, :lists).should be_true
-        loader.locale_resource_loaded?(locale, :calendars).should be_false
+        expect(loader.locale_resource_loaded?(locale, :plurals)).to be_true
+        expect(loader.locale_resource_loaded?(locale, :lists)).to be_true
+        expect(loader.locale_resource_loaded?(locale, :calendars)).to be_false
       end
     end
   end
@@ -163,7 +163,7 @@ describe Loader do
       loader.preload_all_resources
       TwitterCldr.supported_locales.each do |locale|
         loader.resource_types.each do |resource_type|
-          loader.locale_resource_loaded?(locale, resource_type).should be_true
+          expect(loader.locale_resource_loaded?(locale, resource_type)).to be_true
         end
       end
     end

data/spec/shared/break_iterator_spec.rb

@@ -12,47 +12,47 @@ describe BreakIterator do
     let(:iterator) { BreakIterator.new(:en, :use_uli_exceptions => true) }
 
     it "should return an enumerator if called without a block" do
-      iterator.each_sentence("foo bar").should be_a(Enumerator)
+      expect(iterator.each_sentence("foo bar")).to be_a(Enumerator)
     end
 
     it "splits a simple string into sentences" do
       str = "The. Quick. Brown. Fox."
-      iterator.each_sentence(str).to_a.should == [
+      expect(iterator.each_sentence(str).to_a).to eq([
         "The.", " Quick.", " Brown.", " Fox."
-      ]
+      ])
     end
 
     it "does not split on commas, for example" do
       str = "The. Quick, brown. Fox."
-      iterator.each_sentence(str).to_a.should == [
+      expect(iterator.each_sentence(str).to_a).to eq([
         "The.", " Quick, brown.", " Fox."
-      ]
+      ])
     end
 
     it "does not split periods in the midst of other letters, eg. in a URL" do
       str = "Visit us. Go to http://translate.twitter.com."
-      iterator.each_sentence(str).to_a.should == [
+      expect(iterator.each_sentence(str).to_a).to eq([
         "Visit us.",
         " Go to http://translate.twitter.com."
-      ]
+      ])
     end
 
     it "splits on sentences that end with other kinds of punctuation" do
       str = "Help us translate! Speak another language? You really, really rock."
-      iterator.each_sentence(str).to_a.should == [
+      expect(iterator.each_sentence(str).to_a).to eq([
         "Help us translate!",
         " Speak another language?",
         " You really, really rock."
-      ]
+      ])
     end
 
     context "with ULI exceptions" do
       it "does not split on certain abbreviations like Mr. and Mrs." do
         str = "I really like Mrs. Patterson. She's nice."
-        iterator.each_sentence(str).to_a.should == [
+        expect(iterator.each_sentence(str).to_a).to eq([
           "I really like Mrs. Patterson.",
           " She's nice."
-        ]
+        ])
       end
     end
 
@@ -61,11 +61,11 @@ describe BreakIterator do
 
       it "splits on certain abbreviations like Mr. and Mrs. (use ULI rules to avoid this behavior)" do
         str = "I really like Mrs. Patterson. She's nice."
-        iterator.each_sentence(str).to_a.should == [
+        expect(iterator.each_sentence(str).to_a).to eq([
           "I really like Mrs.",
           " Patterson.",
           " She's nice."
-        ]
+        ])
       end
     end
   end

data/spec/shared/calendar_spec.rb

@@ -22,20 +22,20 @@ describe Calendar do
       stub(TwitterCldr).locale { :fr }
       cal = Calendar.new
 
-      cal.locale.should == :fr
-      cal.calendar_type.should == TwitterCldr::DEFAULT_CALENDAR_TYPE
+      expect(cal.locale).to eq(:fr)
+      expect(cal.calendar_type).to eq(TwitterCldr::DEFAULT_CALENDAR_TYPE)
     end
 
     it 'returns calendar for a specific locale' do
-      Calendar.new(:jp).locale.should == :jp
+      expect(Calendar.new(:jp).locale).to eq(:jp)
     end
 
     it 'uses TwitterCldr.convert_locale' do
-      Calendar.new(:'zh-cn').locale.should == :zh
+      expect(Calendar.new(:'zh-cn').locale).to eq(:zh)
     end
 
     it 'returns calendar of a specific type' do
-      Calendar.new(:th, :buddhist).calendar_type.should == :buddhist
+      expect(Calendar.new(:th, :buddhist).calendar_type).to eq(:buddhist)
     end
 
   end
@@ -43,35 +43,35 @@ describe Calendar do
   describe '#months' do
     context 'when data is available' do
       it 'returns months list in a wide names form by default' do
-        calendar.months.should == %w[Januar Februar März April Mai Juni Juli August September Oktober November Dezember]
+        expect(calendar.months).to eq(%w[Januar Februar März April Mai Juni Juli August September Oktober November Dezember])
       end
 
       it 'supports wide names form' do
-        calendar.months(:wide).should == %w[Januar Februar März April Mai Juni Juli August September Oktober November Dezember]
+        expect(calendar.months(:wide)).to eq(%w[Januar Februar März April Mai Juni Juli August September Oktober November Dezember])
       end
 
       it 'supports narrow names form' do
-        calendar.months(:narrow).should == %w[J F M A M J J A S O N D]
+        expect(calendar.months(:narrow)).to eq(%w[J F M A M J J A S O N D])
       end
 
       it 'supports abbreviated names form' do
-        calendar.months(:abbreviated).should == %w[Jan Feb Mär Apr Mai Jun Jul Aug Sep Okt Nov Dez]
+        expect(calendar.months(:abbreviated)).to eq(%w[Jan Feb Mär Apr Mai Jun Jul Aug Sep Okt Nov Dez])
       end
 
       it 'returns nil if invalid names form is passed' do
-        calendar.months(:wat).should == nil
+        expect(calendar.months(:wat)).to eq(nil)
       end
     end
 
     context 'when some data is missing' do
       it 'returns nil if some names format is missing' do
         stub(TwitterCldr).get_locale_resource { { :de => { :calendars => { :gregorian => { :months => { :'stand-alone' => {} } } } } } }
-        calendar.months(:wide).should == nil
+        expect(calendar.months(:wide)).to eq(nil)
       end
 
       it 'returns nil if calendars data is missing' do
         stub(TwitterCldr).get_locale_resource { { :de => {} } }
-        calendar.months(:wide).should == nil
+        expect(calendar.months(:wide)).to eq(nil)
       end
     end
   end
@@ -79,7 +79,7 @@ describe Calendar do
   describe '#weekdays' do
     context 'when data is available' do
       it 'returns weekdays list in a wide names form by default' do
-        calendar.weekdays.should == {
+        expect(calendar.weekdays).to eq({
             :sun => 'Sonntag',
             :mon => 'Montag',
             :tue => 'Dienstag',
@@ -87,11 +87,11 @@ describe Calendar do
             :thu => 'Donnerstag',
             :fri => 'Freitag',
             :sat => 'Samstag'
-        }
+        })
       end
 
       it 'supports wide names form' do
-        calendar.weekdays(:wide).should == {
+        expect(calendar.weekdays(:wide)).to eq({
             :sun => 'Sonntag',
             :mon => 'Montag',
             :tue => 'Dienstag',
@@ -99,15 +99,15 @@ describe Calendar do
             :thu => 'Donnerstag',
             :fri => 'Freitag',
             :sat => 'Samstag'
-        }
+        })
       end
 
       it 'supports narrow names form' do
-        calendar.weekdays(:narrow).should == { :sun => 'S', :mon => 'M', :tue => 'D', :wed => 'M', :thu => 'D', :fri => 'F', :sat => 'S' }
+        expect(calendar.weekdays(:narrow)).to eq({ :sun => 'S', :mon => 'M', :tue => 'D', :wed => 'M', :thu => 'D', :fri => 'F', :sat => 'S' })
       end
 
       it 'supports abbreviated names form' do
-        calendar.weekdays(:abbreviated).should == {
+        expect(calendar.weekdays(:abbreviated)).to eq({
             :sun => 'So',
             :mon => 'Mo',
             :tue => 'Di',
@@ -115,23 +115,23 @@ describe Calendar do
             :thu => 'Do',
             :fri => 'Fr',
             :sat => 'Sa'
-        }
+        })
       end
 
       it 'returns nil if invalid names form is passed' do
-        calendar.weekdays(:wat).should == nil
+        expect(calendar.weekdays(:wat)).to eq(nil)
       end
     end
 
     context 'when some data is missing' do
       it 'returns nil if some names format is missing' do
         stub(TwitterCldr).get_locale_resource { { :de => { :calendars => { :gregorian => { :days => { :'stand-alone' => {} } } } } } }
-        calendar.weekdays(:wide).should == nil
+        expect(calendar.weekdays(:wide)).to eq(nil)
       end
 
       it 'returns nil if calendars data is missing' do
         stub(TwitterCldr).get_locale_resource { { :de => {} } }
-        calendar.weekdays(:wide).should == nil
+        expect(calendar.weekdays(:wide)).to eq(nil)
       end
     end
   end
@@ -139,117 +139,117 @@ describe Calendar do
   describe '#fields' do
     it 'returns the list of fields for the locale (eg. weekday, month, etc)' do
       fields = calendar.fields
-      fields[:hour].should match_normalized("Stunde")
-      fields[:dayperiod].should match_normalized("Tageshälfte")
-      fields[:weekday].should match_normalized("Wochentag")
+      expect(fields[:hour]).to match_normalized("Stunde")
+      expect(fields[:dayperiod]).to match_normalized("Tageshälfte")
+      expect(fields[:weekday]).to match_normalized("Wochentag")
 
       fields = Calendar.new(:ja).fields
-      fields[:hour].should match_normalized("時")
-      fields[:dayperiod].should match_normalized("午前/午後")
-      fields[:weekday].should match_normalized("曜日")
+      expect(fields[:hour]).to match_normalized("時")
+      expect(fields[:dayperiod]).to match_normalized("午前/午後")
+      expect(fields[:weekday]).to match_normalized("曜日")
     end
   end
 
   describe '#quarters' do
     it 'returns default quarters' do
-      calendar.quarters.should == {
+      expect(calendar.quarters).to eq({
         1 => "1. Quartal",
         2 => "2. Quartal",
         3 => "3. Quartal",
         4 => "4. Quartal"
-      }
+      })
     end
 
     it 'returns quarters with other name forms' do
-      calendar.quarters(:abbreviated).should == {
+      expect(calendar.quarters(:abbreviated)).to eq({
         1 => "Q1", 2 => "Q2",
         3 => "Q3", 4 => "Q4"
-      }
+      })
 
-      calendar.quarters(:narrow).should == {
+      expect(calendar.quarters(:narrow)).to eq({
         1 => 1, 2 => 2,
         3 => 3, 4 => 4
-      }
+      })
     end
   end
 
   describe '#periods' do
     it 'returns default periods' do
       periods = calendar.periods
-      periods[:am].should == "vorm."
-      periods[:pm].should == "nachm."
+      expect(periods[:am]).to eq("vorm.")
+      expect(periods[:pm]).to eq("nachm.")
     end
 
     it 'returns quarters with other name forms' do
       periods = calendar.periods(:abbreviated)
-      periods[:am].should == "vorm."
-      periods[:pm].should == "nachm."
+      expect(periods[:am]).to eq("vorm.")
+      expect(periods[:pm]).to eq("nachm.")
     end
   end
 
   describe '#eras' do
     it 'returns default eras' do
-      calendar.eras.should == {
+      expect(calendar.eras).to eq({
         0 => "vor der gewöhnlichen Zeitrechnung",
         1 => "der gewöhnlichen Zeitrechnung"
-      }
+      })
     end
 
     it 'returns eras with other name forms' do
-      calendar.eras(:abbr).should == {
+      expect(calendar.eras(:abbr)).to eq({
         0 => "v. u. Z.",
         1 => "u. Z."
-      }
+      })
     end
   end
 
   describe '#date_order' do
     it 'should return the correct date order for a few different locales' do
-      Calendar.new(:en).date_order.should == [:month, :day, :year]
-      Calendar.new(:ja).date_order.should == [:year, :month, :day]
-      Calendar.new(:ar).date_order.should == [:day, :month, :year]
+      expect(Calendar.new(:en).date_order).to eq([:month, :day, :year])
+      expect(Calendar.new(:ja).date_order).to eq([:year, :month, :day])
+      expect(Calendar.new(:ar).date_order).to eq([:day, :month, :year])
     end
   end
 
   describe '#time_order' do
     it 'should return the correct time order for a few different locales' do
-      Calendar.new(:en).time_order.should == [:hour, :minute, :second, :period]
-      Calendar.new(:ja).time_order.should == [:hour, :minute, :second]
-      Calendar.new(:ar).time_order.should == [:hour, :minute, :second, :period]
+      expect(Calendar.new(:en).time_order).to eq([:hour, :minute, :second, :period])
+      expect(Calendar.new(:ja).time_order).to eq([:hour, :minute, :second])
+      expect(Calendar.new(:ar).time_order).to eq([:hour, :minute, :second, :period])
     end
   end
 
   describe '#datetime_order' do
     it 'should return the correct date and time order for a few different locales' do
-      Calendar.new(:en).datetime_order.should == [:month, :day, :year, :hour, :minute, :second, :period]
-      Calendar.new(:ja).datetime_order.should == [:year, :month, :day, :hour, :minute, :second]
-      Calendar.new(:ar).datetime_order.should == [:day, :month, :year, :hour, :minute, :second, :period]
+      expect(Calendar.new(:en).datetime_order).to eq([:month, :day, :year, :hour, :minute, :second, :period])
+      expect(Calendar.new(:ja).datetime_order).to eq([:year, :month, :day, :hour, :minute, :second])
+      expect(Calendar.new(:ar).datetime_order).to eq([:day, :month, :year, :hour, :minute, :second, :period])
     end
   end
 
   describe '#methods_for_tokens' do
     it 'converts pattern tokens into their corresponding method names' do
       tokens = [TwitterCldr::Tokenizers::Token.new(:value => "YYYY", :type => :pattern)]
-      calendar.send(:methods_for_tokens, tokens).should == [:year_of_week_of_year]
+      expect(calendar.send(:methods_for_tokens, tokens)).to eq([:year_of_week_of_year])
     end
 
     it 'ignores plaintext tokens' do
       tokens = [TwitterCldr::Tokenizers::Token.new(:value => "blarg", :type => :plaintext)]
-      calendar.send(:methods_for_tokens, tokens).should == []
+      expect(calendar.send(:methods_for_tokens, tokens)).to eq([])
     end
   end
 
   describe '#resolve_methods' do
     it 'converts certain method names to their basic equivalents' do
-      calendar.send(:resolve_methods, [:year_of_week_of_year]).should == [:year]
-      calendar.send(:resolve_methods, [:weekday_local]).should == [:weekday]
-      calendar.send(:resolve_methods, [:day_of_month, :second_fraction]).should == [:day, :second]
+      expect(calendar.send(:resolve_methods, [:year_of_week_of_year])).to eq([:year])
+      expect(calendar.send(:resolve_methods, [:weekday_local])).to eq([:weekday])
+      expect(calendar.send(:resolve_methods, [:day_of_month, :second_fraction])).to eq([:day, :second])
     end
 
     it 'does not convert basic method names' do
-      calendar.send(:resolve_methods, [:year]).should == [:year]
-      calendar.send(:resolve_methods, [:day, :month]).should == [:day, :month]
-      calendar.send(:resolve_methods, [:minute, :hour, :second]).should == [:minute, :hour, :second]
+      expect(calendar.send(:resolve_methods, [:year])).to eq([:year])
+      expect(calendar.send(:resolve_methods, [:day, :month])).to eq([:day, :month])
+      expect(calendar.send(:resolve_methods, [:minute, :hour, :second])).to eq([:minute, :hour, :second])
     end
   end