timeliness 0.3.6 → 0.3.7

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+= 0.3.7 - 2012-10-03
+* Change to a hot switch between US and Euro formats without a compile.
+* Fix date parsing with bad month name defaulting to 1 if year and day present.
+* Fix date parsing with nil month.
+
 = 0.3.6 - 2012-03-29
 * Fix bug with month_index using Integer method and leading zeroes treated as octal.
 

data/Rakefile

@@ -1,7 +1,7 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-require 'rake/rdoctask'
+require 'rdoc/task'
 require 'rspec/core/rake_task'
 
 desc "Run specs"

data/lib/timeliness.rb

@@ -24,20 +24,11 @@ module Timeliness
   #   - :current
   #   - 'Zone name'
   #
-  @default_timezone = :local
+  self.default_timezone = :local
 
   # Set the default date part for a time type values.
-  @date_for_time_type = lambda { Time.now }
-
-  def self.date_for_time_type
-    case @date_for_time_type
-    when Array
-      @date_for_time_type
-    when Proc
-      v = @date_for_time_type.call
-      [v.year, v.month, v.day]
-    end
-  end
+  #
+  self.date_for_time_type = lambda { Time.now }
 
   # Set the threshold value for a two digit year to be considered last century
   #
@@ -47,7 +38,7 @@ module Timeliness
   #     year = '29' is considered 2029
   #     year = '30' is considered 1930
   #
-  @ambiguous_year_threshold = 30
+  self.ambiguous_year_threshold = 30
 end
 
 Timeliness::Definitions.compile_formats

data/lib/timeliness/definitions.rb

@@ -130,6 +130,7 @@ module Timeliness
 
     # Mapping some common timezone abbreviations which are not mapped or
     # mapped inconsistenly in ActiveSupport (TzInfo).
+    #
     @timezone_mapping = {
       'AEST' => 'Australia/Sydney',
       'AEDT' => 'Australia/Sydney',
@@ -184,22 +185,28 @@ module Timeliness
       # Removes US date formats so that ambiguous dates are parsed as European format
       #
       def use_euro_formats
-        @date_format_set     = FormatSet.compile(date_formats.select { |format| US_FORMAT_REGEXP !~ format })
-        @datetime_format_set = FormatSet.compile(datetime_formats.select { |format| US_FORMAT_REGEXP !~ format })
+        @date_format_set     = @euro_date_format_set
+        @datetime_format_set = @euro_datetime_format_set
       end
 
       # Restores default to parse ambiguous dates as US format
       #
       def use_us_formats
-        @date_format_set     = FormatSet.compile(date_formats)
-        @datetime_format_set = FormatSet.compile(datetime_formats)
+        @date_format_set     = @us_date_format_set
+        @datetime_format_set = @us_datetime_format_set
       end
 
       def compile_formats
-        @sorted_token_keys   = nil
-        @time_format_set     = FormatSet.compile(time_formats)
-        @date_format_set     = FormatSet.compile(date_formats)
-        @datetime_format_set = FormatSet.compile(datetime_formats)
+        @sorted_token_keys = nil
+        @time_format_set   = FormatSet.compile(time_formats)
+
+        @us_date_format_set       = FormatSet.compile(date_formats)
+        @us_datetime_format_set   = FormatSet.compile(datetime_formats)
+        @euro_date_format_set     = FormatSet.compile(date_formats.select { |format| US_FORMAT_REGEXP !~ format })
+        @euro_datetime_format_set = FormatSet.compile(datetime_formats.select { |format| US_FORMAT_REGEXP !~ format })
+
+        @date_format_set     = @us_date_format_set
+        @datetime_format_set = @us_datetime_format_set
       end
 
       def sorted_token_keys
@@ -208,6 +215,7 @@ module Timeliness
 
       # Returns format for type and other possible matching format set based on type
       # and value length. Gives minor speed-up by checking string length.
+      #
       def format_sets(type, string)
         case type
         when :date

data/lib/timeliness/format_set.rb

@@ -41,7 +41,7 @@ module Timeliness
     end
 
     def single_format(format_string)
-       @formats_hash[format_string] || Format.new(format_string).compile!
+       @formats_hash.fetch(format_string) { Format.new(format_string).compile! }
     end
   end
 end

data/lib/timeliness/parser.rb

@@ -67,7 +67,7 @@ module Timeliness
         when nil
           dummy_date = current_date(options)
           values[0] ||= dummy_date[0]
-          values[1] ||= dummy_date[1]
+          values[1] ||= dummy_date[1] unless values.values_at(0,2).all?
           values[2] ||= dummy_date[2]
         end
       end
@@ -78,7 +78,7 @@ module Timeliness
         elsif options[:zone]
           current_time_in_zone(options[:zone])
         else
-          Timeliness.date_for_time_type
+          evaluate_date_for_time_type
         end
         now.is_a?(Array) ? now[0..2] : [now.year, now.month, now.day]
       end
@@ -139,7 +139,17 @@ module Timeliness
       # Enforce strict date part validity which the Time class does not.
       # Only does full date check if month and day are possibly invalid.
       def fast_date_valid_with_fallback(year, month, day)
-        month < 13 && (day < 29 || Date.valid_civil?(year, month, day))
+        month && month < 13 && (day < 29 || Date.valid_civil?(year, month, day))
+      end
+
+      def evaluate_date_for_time_type
+        case Timeliness.date_for_time_type
+        when Array
+          Timeliness.date_for_time_type
+        when Proc
+          v = Timeliness.date_for_time_type.call
+          [v.year, v.month, v.day]
+        end
       end
 
     end

data/lib/timeliness/version.rb

@@ -1,3 +1,3 @@
 module Timeliness
-  VERSION = '0.3.6'
+  VERSION = '0.3.7'
 end

data/spec/timeliness/core_ext/string_spec.rb

@@ -5,29 +5,29 @@ describe Timeliness::CoreExt, 'String' do
 
   describe "#to_time" do
     it 'should convert valid string to Time object in default zone' do
-      "2005-02-27 23:50".to_time.should == Time.utc(2005, 2, 27, 23, 50)
+      "2005-02-27 23:50".to_time.should eq Time.utc(2005, 2, 27, 23, 50)
     end
 
     it 'should convert ISO 8601 string to Time object' do
-      "2005-02-27T23:50:19.275038".to_time.should == Time.utc(2005, 2, 27, 23, 50, 19, 275038)
+      "2005-02-27T23:50:19.275038".to_time.should eq Time.utc(2005, 2, 27, 23, 50, 19, 275038)
     end
 
     context "with :local" do
       it 'should convert valid string to local time' do
-        "2005-02-27 23:50".to_time(:local).should == Time.local(2005, 2, 27, 23, 50)
+        "2005-02-27 23:50".to_time(:local).should eq Time.local(2005, 2, 27, 23, 50)
       end
 
       it 'should convert ISO 8601 string to local time' do
-        "2005-02-27T23:50:19.275038".to_time(:local).should == Time.local(2005, 2, 27, 23, 50, 19, 275038)
+        "2005-02-27T23:50:19.275038".to_time(:local).should eq Time.local(2005, 2, 27, 23, 50, 19, 275038)
       end
     end
 
     it 'should convert valid future string to Time object' do
-      "2039-02-27 23:50".to_time(:local).should == Time.local_time(2039, 2, 27, 23, 50)
+      "2039-02-27 23:50".to_time(:local).should eq Time.local_time(2039, 2, 27, 23, 50)
     end
 
     it 'should convert valid future string to Time object' do
-      "2039-02-27 23:50".to_time.should == DateTime.civil(2039, 2, 27, 23, 50)
+      "2039-02-27 23:50".to_time.should eq DateTime.civil(2039, 2, 27, 23, 50)
     end
 
     it 'should convert empty string to nil' do
@@ -37,21 +37,21 @@ describe Timeliness::CoreExt, 'String' do
 
   describe "#to_datetime" do
     it 'should convert valid string to DateTime object' do
-      "2039-02-27 23:50".to_datetime.should == DateTime.civil(2039, 2, 27, 23, 50)
+      "2039-02-27 23:50".to_datetime.should eq DateTime.civil(2039, 2, 27, 23, 50)
     end
 
     it 'should convert to DateTime object with UTC offset' do
-      "2039-02-27 23:50".to_datetime.offset.should == 0
+      "2039-02-27 23:50".to_datetime.offset.should eq 0
     end
 
     it 'should convert ISO 8601 string to DateTime object' do
       datetime = DateTime.civil(2039, 2, 27, 23, 50, 19 + Rational(275038, 1000000), "-04:00")
-      "2039-02-27T23:50:19.275038-04:00".to_datetime.should == datetime
+      "2039-02-27T23:50:19.275038-04:00".to_datetime.should eq datetime
     end
 
     it 'should use Rubys default start value' do
       # Taken from ActiveSupport unit tests. Not sure on the implication.
-      "2039-02-27 23:50".to_datetime.start.should == ::Date::ITALY
+      "2039-02-27 23:50".to_datetime.start.should eq ::Date::ITALY
     end
 
     it 'should convert empty string to nil' do
@@ -61,7 +61,7 @@ describe Timeliness::CoreExt, 'String' do
 
   describe "#to_date" do
     it 'should convert string to Date object' do
-      "2005-02-27".to_date.should == Date.new(2005, 2, 27)
+      "2005-02-27".to_date.should eq Date.new(2005, 2, 27)
     end
 
     it 'should convert empty string to nil' do

data/spec/timeliness/definitions_spec.rb

@@ -19,18 +19,18 @@ describe Timeliness::Definitions do
     end
 
     it "should raise error if format exists" do
-      expect { definitions.add_formats(:time, "hh:nn:ss") }.should raise_error
+      expect { definitions.add_formats(:time, "hh:nn:ss") }.to raise_error
     end
 
     context "with :before option" do
       it "should add new format with higher precedence" do
         definitions.add_formats(:time, "ss:hh:nn", :before => 'hh:nn:ss')
         time_array = parser._parse('59:23:58', :time)
-        time_array.should == [nil,nil,nil,23,58,59,nil,nil]
+        time_array.should eq [nil,nil,nil,23,58,59,nil,nil]
       end
 
       it "should raise error if :before format does not exist" do
-        expect { definitions.add_formats(:time, "ss:hh:nn", :before => 'nn:hh:ss') }.should raise_error
+        expect { definitions.add_formats(:time, "ss:hh:nn", :before => 'nn:hh:ss') }.to raise_error
       end
     end
 
@@ -63,7 +63,7 @@ describe Timeliness::Definitions do
     end
 
     it "should raise error if format does not exist" do
-      expect { definitions.remove_formats(:time, "ss:hh:nn") }.should raise_error()
+      expect { definitions.remove_formats(:time, "ss:hh:nn") }.to raise_error()
     end
 
     after do
@@ -74,21 +74,33 @@ describe Timeliness::Definitions do
 
   context "use_euro_formats" do
     it "should allow ambiguous date to be parsed as European format" do
-      parser._parse('01/02/2000', :date).should == [2000,1,2,nil,nil,nil,nil,nil]
+      parser._parse('01/02/2000', :date).should eq [2000,1,2,nil,nil,nil,nil,nil]
+      definitions.use_euro_formats
+      parser._parse('01/02/2000', :date).should eq [2000,2,1,nil,nil,nil,nil,nil]
+    end
+
+    it "should not parse formats on switch to euro after initial compile" do
+      definitions.compile_formats
+      Timeliness::FormatSet.should_not_receive(:compile)
       definitions.use_euro_formats
-      parser._parse('01/02/2000', :date).should == [2000,2,1,nil,nil,nil,nil,nil]
     end
   end
 
-  context "use_use_formats" do
+  context "use_us_formats" do
     before do
       definitions.use_euro_formats
     end
 
     it "should allow ambiguous date to be parsed as European format" do
-      parser._parse('01/02/2000', :date).should == [2000,2,1,nil,nil,nil,nil,nil]
+      parser._parse('01/02/2000', :date).should eq [2000,2,1,nil,nil,nil,nil,nil]
+      definitions.use_us_formats
+      parser._parse('01/02/2000', :date).should eq [2000,1,2,nil,nil,nil,nil,nil]
+    end
+
+    it "should not parse formats on switch to euro after initial compile" do
+      definitions.compile_formats
+      Timeliness::FormatSet.should_not_receive(:compile)
       definitions.use_us_formats
-      parser._parse('01/02/2000', :date).should == [2000,1,2,nil,nil,nil,nil,nil]
     end
   end
 end

data/spec/timeliness/format_spec.rb

@@ -5,60 +5,60 @@ describe Timeliness::Format do
     it 'should compile valid string format' do
       expect { 
         Timeliness::Format.new('yyyy-mm-dd hh:nn:ss.u zo').compile!
-      }.should_not raise_error
+      }.to_not raise_error
     end
 
     it 'should return self' do
       format = Timeliness::Format.new('yyyy-mm-dd hh:nn:ss.u zo')
-      format.compile!.should == format
+      format.compile!.should eq format
     end
 
     it 'should raise compilation error for bad format' do
       expect { 
         Timeliness::Format.new('|--[)').compile!
-      }.should raise_error(Timeliness::CompilationError)
+      }.to raise_error(Timeliness::CompilationError)
     end
   end
 
   describe "#process" do
     it "should define method which outputs date array with values in correct order" do
-      format_for('yyyy-mm-dd').process('2000', '1', '2').should == [2000,1,2,nil,nil,nil,nil,nil]
+      format_for('yyyy-mm-dd').process('2000', '1', '2').should eq [2000,1,2,nil,nil,nil,nil,nil]
     end
 
     it "should define method which outputs date array from format with different order" do
-      format_for('dd/mm/yyyy').process('2', '1', '2000').should == [2000,1,2,nil,nil,nil,nil,nil]
+      format_for('dd/mm/yyyy').process('2', '1', '2000').should eq [2000,1,2,nil,nil,nil,nil,nil]
     end
 
     it "should define method which outputs date array with zeros when month and day are '0'" do
-      format_for('m/d/yy').process('0', '0', '0000').should == [0,0,0,nil,nil,nil,nil,nil]
+      format_for('m/d/yy').process('0', '0', '0000').should eq [0,0,0,nil,nil,nil,nil,nil]
     end
 
     it "should define method which outputs date array with zeros when month and day are '00'" do
-      format_for('m/d/yy').process('00', '00', '0000').should == [0,0,0,nil,nil,nil,nil,nil]
+      format_for('m/d/yy').process('00', '00', '0000').should eq [0,0,0,nil,nil,nil,nil,nil]
     end
 
     it "should define method which outputs time array" do
-      format_for('hh:nn:ss').process('01', '02', '03').should == [nil,nil,nil,1,2,3,nil,nil]
+      format_for('hh:nn:ss').process('01', '02', '03').should eq [nil,nil,nil,1,2,3,nil,nil]
     end
 
     it "should define method which outputs time array with meridian 'pm' adjusted hour" do
-      format_for('hh:nn:ss ampm').process('01', '02', '03', 'pm').should == [nil,nil,nil,13,2,3,nil,nil]
+      format_for('hh:nn:ss ampm').process('01', '02', '03', 'pm').should eq [nil,nil,nil,13,2,3,nil,nil]
     end
 
     it "should define method which outputs time array with meridian 'am' unadjusted hour" do
-      format_for('hh:nn:ss ampm').process('01', '02', '03', 'am').should == [nil,nil,nil,1,2,3,nil,nil]
+      format_for('hh:nn:ss ampm').process('01', '02', '03', 'am').should eq [nil,nil,nil,1,2,3,nil,nil]
     end
 
     it "should define method which outputs time array with microseconds" do
-      format_for('hh:nn:ss.u').process('01', '02', '03', '99').should == [nil,nil,nil,1,2,3,990000,nil]
+      format_for('hh:nn:ss.u').process('01', '02', '03', '99').should eq [nil,nil,nil,1,2,3,990000,nil]
     end
 
     it "should define method which outputs datetime array with zone offset" do
-      format_for('yyyy-mm-dd hh:nn:ss.u zo').process('2001', '02', '03', '04', '05', '06', '99', '+10:00').should == [2001,2,3,4,5,6,990000,36000]
+      format_for('yyyy-mm-dd hh:nn:ss.u zo').process('2001', '02', '03', '04', '05', '06', '99', '+10:00').should eq [2001,2,3,4,5,6,990000,36000]
     end
 
     it "should define method which outputs datetime array with timezone string" do
-      format_for('yyyy-mm-dd hh:nn:ss.u tz').process('2001', '02', '03', '04', '05', '06', '99', 'EST').should == [2001,2,3,4,5,6,990000,'EST']
+      format_for('yyyy-mm-dd hh:nn:ss.u tz').process('2001', '02', '03', '04', '05', '06', '99', 'EST').should eq [2001,2,3,4,5,6,990000,'EST']
     end
 
     context "with long month" do
@@ -72,11 +72,11 @@ describe Timeliness::Format do
         end
 
         it 'should parse abbreviated month for current locale to correct value' do
-          format.process('2', 'Ene', '2000').should == [2000,1,2,nil,nil,nil,nil,nil]
+          format.process('2', 'Ene', '2000').should eq [2000,1,2,nil,nil,nil,nil,nil]
         end
 
         it 'should parse full month for current locale to correct value' do
-          format.process('2', 'Enero', '2000').should == [2000,1,2,nil,nil,nil,nil,nil]
+          format.process('2', 'Enero', '2000').should eq [2000,1,2,nil,nil,nil,nil,nil]
         end
 
         after(:all) do
@@ -91,11 +91,11 @@ describe Timeliness::Format do
         end
 
         it 'should parse abbreviated month to correct value' do
-          format.process('2', 'Jan', '2000').should == [2000,1,2,nil,nil,nil,nil,nil]
+          format.process('2', 'Jan', '2000').should eq [2000,1,2,nil,nil,nil,nil,nil]
         end
 
         it 'should parse full month to correct value' do
-          format.process('2', 'January', '2000').should == [2000,1,2,nil,nil,nil,nil,nil]
+          format.process('2', 'January', '2000').should eq [2000,1,2,nil,nil,nil,nil,nil]
         end
       end
     end

data/spec/timeliness/parser_spec.rb

@@ -20,7 +20,7 @@ describe Timeliness::Parser do
 
     it "should return return same value if value not a string" do
       value = Time.now
-      parse(value).should == value
+      parse(value).should eq value
     end
 
     it "should return time object for valid date string" do
@@ -39,6 +39,10 @@ describe Timeliness::Parser do
       should_not_parse("00/01/2000")
     end
 
+    it "should return nil for invalid date month string" do
+      should_not_parse("1 Foo 2000")
+    end
+
     it "should return time object for valid time string" do
       parse("12:13:14").should be_kind_of(Time)
     end
@@ -59,14 +63,14 @@ describe Timeliness::Parser do
       context "when current timezone is earler than string zone" do
         it 'should return value shifted by positive offset in default timezone' do
           value = parse("2000-06-01T12:00:00+02:00")
-          value.should == Time.local(2000,6,1,20,0,0)
-          value.utc_offset.should == 10.hours
+          value.should eq Time.local(2000,6,1,20,0,0)
+          value.utc_offset.should eq 10.hours
         end
 
         it 'should return value shifted by negative offset in default timezone' do
           value = parse("2000-06-01T12:00:00-01:00")
-          value.should == Time.local(2000,6,1,23,0,0)
-          value.utc_offset.should == 10.hours
+          value.should eq Time.local(2000,6,1,23,0,0)
+          value.utc_offset.should eq 10.hours
         end
       end
 
@@ -78,14 +82,14 @@ describe Timeliness::Parser do
 
         it 'should return value shifted by positive offset in default timezone' do
           value = parse("2000-06-01T12:00:00+02:00")
-          value.should == Time.zone.local(2000,6,1,3,0,0)
-          value.utc_offset.should == -7.hours
+          value.should eq Time.zone.local(2000,6,1,3,0,0)
+          value.utc_offset.should eq -7.hours
         end
 
         it 'should return value shifted by negative offset in default timezone' do
           value = parse("2000-06-01T12:00:00-01:00")
-          value.should == Time.zone.local(2000,6,1,6,0,0)
-          value.utc_offset.should == -7.hours
+          value.should eq Time.zone.local(2000,6,1,6,0,0)
+          value.utc_offset.should eq -7.hours
         end
 
         after(:all) do
@@ -103,23 +107,23 @@ describe Timeliness::Parser do
       it 'should return value using string zone adjusted to default :local timezone' do
         Timeliness.default_timezone = :local
         value = parse("Thu, 01 Jun 2000 03:00:00 MST")
-        value.should == Time.local(2000,6,1,20,0,0)
-        value.utc_offset.should == 10.hours
+        value.should eq Time.local(2000,6,1,20,0,0)
+        value.utc_offset.should eq 10.hours
       end
 
       it 'should return value using string zone adjusted to default :current timezone' do
         Timeliness.default_timezone = :current
         Time.zone = 'Adelaide'
         value = parse("Thu, 01 Jun 2000 03:00:00 MST")
-        value.should == Time.zone.local(2000,6,1,19,30,0)
-        value.utc_offset.should == 9.5.hours
+        value.should eq Time.zone.local(2000,6,1,19,30,0)
+        value.utc_offset.should eq 9.5.hours
       end
 
       it 'should return value using string zone adjusted to :zone option string timezone' do
         Timeliness.default_timezone = :local
         value = parse("Thu, 01 Jun 2000 03:00:00 MST", :zone => 'Perth')
-        value.should == Time.use_zone('Perth') { Time.zone.local(2000,6,1,18,0,0) }
-        value.utc_offset.should == 8.hours
+        value.should eq Time.use_zone('Perth') { Time.zone.local(2000,6,1,18,0,0) }
+        value.utc_offset.should eq 8.hours
       end
 
       after do
@@ -129,7 +133,7 @@ describe Timeliness::Parser do
 
     context "with :datetime type" do
       it "should return time object for valid datetime string" do
-        parse("2000-01-01 12:13:14", :datetime).should == Time.local(2000,1,1,12,13,14)
+        parse("2000-01-01 12:13:14", :datetime).should eq Time.local(2000,1,1,12,13,14)
       end
 
       it "should return nil for invalid date string" do
@@ -139,11 +143,11 @@ describe Timeliness::Parser do
 
     context "with :date type" do
       it "should return time object for valid date string" do
-        parse("2000-01-01", :date).should == Time.local(2000,1,1)
+        parse("2000-01-01", :date).should eq Time.local(2000,1,1)
       end
 
       it "should ignore time in datetime string" do
-        parse('2000-02-01 12:13', :date).should == Time.local(2000,2,1)
+        parse('2000-02-01 12:13', :date).should eq Time.local(2000,2,1)
       end
 
       it "should return nil for invalid date string" do
@@ -153,11 +157,11 @@ describe Timeliness::Parser do
 
     context "with :time type" do
       it "should return time object with a dummy date values" do
-        parse('12:13', :time).should == Time.local(2010,1,1,12,13)
+        parse('12:13', :time).should eq Time.local(2010,1,1,12,13)
       end
 
       it "should ignore date in datetime string" do
-        parse('2010-02-01 12:13', :time).should == Time.local(2010,1,1,12,13)
+        parse('2010-02-01 12:13', :time).should eq Time.local(2010,1,1,12,13)
       end
 
       it "should raise error if time hour is out of range for AM meridian" do
@@ -168,14 +172,14 @@ describe Timeliness::Parser do
     context "with :now option" do
       it 'should use date parts if string does not specify' do
         time = parse("12:13:14", :now => Time.local(2010,1,1))
-        time.should == Time.local(2010,1,1,12,13,14)
+        time.should eq Time.local(2010,1,1,12,13,14)
       end
     end
 
     context "with time value argument" do
       it 'should use argument as :now option value' do
         time = parse("12:13:14", Time.local(2010,1,1))
-        time.should == Time.local(2010,1,1,12,13,14)
+        time.should eq Time.local(2010,1,1,12,13,14)
       end
     end
 
@@ -183,7 +187,7 @@ describe Timeliness::Parser do
       context ":utc" do
         it "should return time object in utc timezone" do
           time = parse("2000-06-01 12:13:14", :datetime, :zone => :utc)
-          time.utc_offset.should == 0
+          time.utc_offset.should eq 0
         end
 
         it 'should return nil for partial invalid time component' do
@@ -194,7 +198,7 @@ describe Timeliness::Parser do
       context ":local" do
         it "should return time object in local system timezone" do
           time = parse("2000-06-01 12:13:14", :datetime, :zone => :local)
-          time.utc_offset.should == 10.hours
+          time.utc_offset.should eq 10.hours
         end
 
         it 'should return nil for partial invalid time component' do
@@ -206,7 +210,7 @@ describe Timeliness::Parser do
         it "should return time object in current timezone" do
           Time.zone = 'Adelaide'
           time = parse("2000-06-01 12:13:14", :datetime, :zone => :current)
-          time.utc_offset.should == 9.5.hours
+          time.utc_offset.should eq 9.5.hours
         end
 
         it 'should return nil for partial invalid time component' do
@@ -217,7 +221,7 @@ describe Timeliness::Parser do
       context "named zone" do
         it "should return time object in the timezone" do
           time = parse("2000-06-01 12:13:14", :datetime, :zone => 'London')
-          time.utc_offset.should == 1.hour
+          time.utc_offset.should eq 1.hour
         end
 
         it 'should return nil for partial invalid time component' do
@@ -230,17 +234,17 @@ describe Timeliness::Parser do
           expect {
             Time.should_receive(:zone).and_raise(NoMethodError.new("undefined method `zone' for Time:Class"))
             parse("2000-06-01 12:13:14", :zone => :current)
-          }.should raise_error(Timeliness::Parser::MissingTimezoneSupport)
+          }.to raise_error(Timeliness::Parser::MissingTimezoneSupport)
 
           expect {
             Time.should_receive(:current).and_raise(NoMethodError.new("undefined method `current' for Time:Class"))
             parse("12:13:14", :zone => :current)
-          }.should raise_error(Timeliness::Parser::MissingTimezoneSupport)
+          }.to raise_error(Timeliness::Parser::MissingTimezoneSupport)
 
           expect {
             Time.should_receive(:use_zone).and_raise(NoMethodError.new("undefined method `use_zone' for Time:Class"))
             parse("2000-06-01 12:13:14", :zone => 'London')
-          }.should raise_error(Timeliness::Parser::MissingTimezoneSupport)
+          }.to raise_error(Timeliness::Parser::MissingTimezoneSupport)
         end
       end
     end
@@ -253,12 +257,12 @@ describe Timeliness::Parser do
 
         it 'should return date array' do
           Timeliness.date_for_time_type = [2010,1,1]
-          parse('12:13:14', :time).should == Time.local(2010,1,1,12,13,14)
+          parse('12:13:14', :time).should eq Time.local(2010,1,1,12,13,14)
         end
 
         it 'should return date array evaluated lambda' do
           Timeliness.date_for_time_type = lambda { Time.local(2010,2,1) }
-          parse('12:13:14', :time).should == Time.local(2010,2,1,12,13,14)
+          parse('12:13:14', :time).should eq Time.local(2010,2,1,12,13,14)
         end
 
         after do
@@ -268,16 +272,16 @@ describe Timeliness::Parser do
 
       context "with :now option" do
         it 'should use date from :now' do
-          parse('12:13:14', :time, :now => Time.local(2010, 6, 1)).should == Time.local(2010,6,1,12,13,14)
+          parse('12:13:14', :time, :now => Time.local(2010, 6, 1)).should eq Time.local(2010,6,1,12,13,14)
         end
       end
 
       context "with :zone option" do
         it "should use date from the specified zone" do
           time = parse("12:13:14", :time, :zone => :utc)
-          time.year.should == 2009
-          time.month.should == 12
-          time.day.should == 31
+          time.year.should eq 2009
+          time.month.should eq 12
+          time.day.should eq 31
         end
       end
 
@@ -288,54 +292,54 @@ describe Timeliness::Parser do
     context "with no type" do
       it "should return date array from date string" do
         time_array = parser._parse('2000-02-01')
-        time_array.should == [2000,2,1,nil,nil,nil,nil,nil]
+        time_array.should eq [2000,2,1,nil,nil,nil,nil,nil]
       end
 
       it "should return time array from time string" do
         time_array = parser._parse('12:13:14', :time)
-        time_array.should == [nil,nil,nil,12,13,14,nil,nil]
+        time_array.should eq [nil,nil,nil,12,13,14,nil,nil]
       end
 
       it "should return datetime array from datetime string" do
         time_array = parser._parse('2000-02-01 12:13:14')
-        time_array.should == [2000,2,1,12,13,14,nil,nil]
+        time_array.should eq [2000,2,1,12,13,14,nil,nil]
       end
     end
 
     context "with type" do
       it "should return date array from date string" do
         time_array = parser._parse('2000-02-01', :date)
-        time_array.should == [2000,2,1,nil,nil,nil,nil,nil]
+        time_array.should eq [2000,2,1,nil,nil,nil,nil,nil]
       end
 
       it "should not return time array from time string for :date type" do
         time_array = parser._parse('12:13:14', :date)
-        time_array.should == nil
+        time_array.should eq nil
       end
 
       it "should return time array from time string" do
         time_array = parser._parse('12:13:14', :time)
-        time_array.should == [nil,nil,nil,12,13,14,nil,nil]
+        time_array.should eq [nil,nil,nil,12,13,14,nil,nil]
       end
 
       it "should not return date array from date string for :time type" do
         time_array = parser._parse('2000-02-01', :time)
-        time_array.should == nil
+        time_array.should eq nil
       end
 
       it "should return datetime array from datetime string when type is date" do
         time_array = parser._parse('2000-02-01 12:13:14', :date)
-        time_array.should == [2000,2,1,12,13,14,nil,nil]
+        time_array.should eq [2000,2,1,12,13,14,nil,nil]
       end
 
       it "should return date array from date string when type is datetime" do
         time_array = parser._parse('2000-02-01', :datetime)
-        time_array.should == [2000,2,1,nil,nil,nil,nil,nil]
+        time_array.should eq [2000,2,1,nil,nil,nil,nil,nil]
       end
 
       it "should not return time array from time string when type is datetime" do
         time_array = parser._parse('12:13:14', :datetime)
-        time_array.should == nil
+        time_array.should eq nil
       end
     end
 
@@ -379,7 +383,7 @@ describe Timeliness::Parser do
     context "with :format option" do
       it "should return values if string matches specified format" do
         time_array = parser._parse('2000-02-01 12:13:14', :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
-        time_array.should == [2000,2,1,12,13,14,nil,nil]
+        time_array.should eq [2000,2,1,12,13,14,nil,nil]
       end
 
       it "should return nil if string does not match specified format" do
@@ -391,21 +395,21 @@ describe Timeliness::Parser do
     context "date with ambiguous year" do
       it "should return year in current century if year below threshold" do
         time_array = parser._parse('01-02-29', :date)
-        time_array.should == [2029,2,1,nil,nil,nil,nil,nil]
+        time_array.should eq [2029,2,1,nil,nil,nil,nil,nil]
       end
 
       it "should return year in last century if year at or above threshold" do
         time_array = parser._parse('01-02-30', :date)
-        time_array.should == [1930,2,1,nil,nil,nil,nil,nil]
+        time_array.should eq [1930,2,1,nil,nil,nil,nil,nil]
       end
 
       it "should allow custom threshold" do
         default = Timeliness.ambiguous_year_threshold
         Timeliness.ambiguous_year_threshold = 40
         time_array = parser._parse('01-02-39', :date)
-        time_array.should == [2039,2,1,nil,nil,nil,nil,nil]
+        time_array.should eq [2039,2,1,nil,nil,nil,nil,nil]
         time_array = parser._parse('01-02-40', :date)
-        time_array.should == [1940,2,1,nil,nil,nil,nil,nil]
+        time_array.should eq [1940,2,1,nil,nil,nil,nil,nil]
         Timeliness.ambiguous_year_threshold = default
       end
     end
@@ -414,7 +418,7 @@ describe Timeliness::Parser do
   describe "make_time" do
     it "should return time object for valid time array" do
       time = parser.make_time([2010,9,8,12,13,14])
-      time.should == Time.local(2010,9,8,12,13,14)
+      time.should eq Time.local(2010,9,8,12,13,14)
     end
 
     it "should return nil for invalid date in array" do
@@ -435,7 +439,7 @@ describe Timeliness::Parser do
       it "should be used if no zone value" do
         Timeliness.default_timezone = :utc
         time = parser.make_time([2000,6,1,12,0,0])
-        time.utc_offset.should == 0
+        time.utc_offset.should eq 0
       end
 
       after do
@@ -447,14 +451,14 @@ describe Timeliness::Parser do
       context ":utc" do
         it "should return time object in utc timezone" do
           time = parser.make_time([2000,6,1,12,0,0], :utc)
-          time.utc_offset.should == 0
+          time.utc_offset.should eq 0
         end
       end
 
       context ":local" do
         it "should return time object in local system timezone" do
           time = parser.make_time([2000,6,1,12,0,0], :local)
-          time.utc_offset.should == 10.hours
+          time.utc_offset.should eq 10.hours
         end
       end
 
@@ -462,14 +466,14 @@ describe Timeliness::Parser do
         it "should return time object in current timezone" do
           Time.zone = 'Adelaide'
           time = parser.make_time([2000,6,1,12,0,0], :current)
-          time.utc_offset.should == 9.5.hours
+          time.utc_offset.should eq 9.5.hours
         end
       end
 
       context "named zone" do
         it "should return time object in the timezone" do
           time = parser.make_time([2000,6,1,12,0,0], 'London')
-          time.utc_offset.should == 1.hour
+          time.utc_offset.should eq 1.hour
         end
       end
     end
@@ -479,7 +483,8 @@ describe Timeliness::Parser do
 
     context "with no options" do
       it 'should return date_for_time_type values with no options' do
-        current_date.should == Timeliness.date_for_time_type
+        dummy_date = Timeliness.date_for_time_type.call
+        current_date.should eq [ dummy_date.year, dummy_date.month, dummy_date.day ]
       end
     end
 
@@ -487,7 +492,7 @@ describe Timeliness::Parser do
       it 'should return date array from Time value' do
         time = Time.now
         date_array = [time.year, time.month, time.day]
-        current_date(:now => time).should == date_array
+        current_date(:now => time).should eq date_array
       end
     end
 
@@ -495,26 +500,26 @@ describe Timeliness::Parser do
       it 'should return date array for utc zone' do
         time = Time.now.getutc
         date_array = [time.year, time.month, time.day]
-        current_date(:zone => :utc).should == date_array
+        current_date(:zone => :utc).should eq date_array
       end
 
       it 'should return date array for local zone' do
         time = Time.now
         date_array = [time.year, time.month, time.day]
-        current_date(:zone => :local).should == date_array
+        current_date(:zone => :local).should eq date_array
       end
 
       it 'should return date array for current zone' do
         Time.zone = 'London'
         time = Time.current
         date_array = [time.year, time.month, time.day]
-        current_date(:zone => :current).should == date_array
+        current_date(:zone => :current).should eq date_array
       end
 
       it 'should return date array for named zone' do
         time = Time.use_zone('London') { Time.current }
         date_array = [time.year, time.month, time.day]
-        current_date(:zone => 'London').should == date_array
+        current_date(:zone => 'London').should eq date_array
       end
     end
   end

metadata

@@ -1,34 +1,24 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: timeliness
-version: !ruby/object:Gem::Version 
-  hash: 31
+version: !ruby/object:Gem::Version
+  version: 0.3.7
   prerelease: 
-  segments: 
-  - 0
-  - 3
-  - 6
-  version: 0.3.6
 platform: ruby
-authors: 
+authors:
 - Adam Meehan
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-04-01 01:00:00 +11:00
-default_executable: 
+date: 2012-10-03 00:00:00.000000000 Z
 dependencies: []
-
 description: Fast date/time parser with customisable formats, timezone and I18n support.
 email: adam.meehan@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
 - CHANGELOG.rdoc
-files: 
+files:
 - CHANGELOG.rdoc
 - LICENSE
 - README.rdoc
@@ -50,39 +40,28 @@ files:
 - spec/timeliness/format_spec.rb
 - spec/timeliness/parser_spec.rb
 - timeliness.gemspec
-has_rdoc: true
 homepage: http://github.com/adzap/timeliness
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: timeliness
-rubygems_version: 1.5.2
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Date/time parsing for the control freak.
 test_files: []
-