timeliness 0.1.1 → 0.2.0

data/CHANGELOG.rdoc

@@ -1,3 +1,10 @@
+= 0.2.0 - 2010-10-27
+* Allow a lambda for date_for_time_type which is evaluated on parse
+* Return the offset or zone in array from _parse
+* Give a nicer error message if use a zone and ActiveSupport is not loaded.
+* Removed some aliases used in validates_timeliness and are no longer needed.
+* Some minor spec fixes
+
 = 0.1.1 - 2010-10-14
 * Alias for validates_timeliness compatibility
 * Tiny cleanup

data/README.rdoc

@@ -14,9 +14,11 @@ Date/time parser for Ruby with the following features:
 * I18n support (for months), if I18n gem loaded.
 * Fewer WTFs than Time/Date parse method.
 * Has no dependencies.
+* Works with Ruby MRI 1.8.*, 1.9.2, Rubinius
 
 Extracted from my {validates_timeliness gem}[http://github.com/adzap/validates_timeliness], it has been rewritten cleaner and much faster. It's most suitable for when
-you need to control the parsing behaviour. It's faster than the Time/Date class parse methods, so it has general appeal.
+you need to control the parsing behaviour. It's faster than the Time/Date class parse methods, so it
+has general appeal.
 
 
 == Usage
@@ -27,16 +29,11 @@ The simplest example is just a straight forward string parse:
   Timeliness.parse('2010-09-08')          #=> Wed Sep 08 00:00:00 1000 2010
   Timeliness.parse('12:13:14')            #=> Sat Jan 01 12:13:14 1100 2000
 
-Notice a time only string will return with a date value. The date value can be configured globally with
-this setting:
 
-  Timeliness.date_for_time_type = [2010, 1, 1]
-
-or specified with :now option:
+=== Specify a Type
 
-  Timeliness.parse('12:13:14', :now => Time.mktime(2010,9,8)) #=> Wed Sep 08 12:13:14 1000 2010
-
-You can also provide a type which will tell the parser that you are only interested in the part of the value for that type.
+You can provide a type which will tell the parser that you are only interested in the part of
+the value for that type.
 
   Timeliness.parse('2010-09-08 12:13:14', :date)     #=> Wed Sep 08 00:00:00 1000 2010
   Timeliness.parse('2010-09-08 12:13:14', :time)     #=> Sat Jan 01 12:13:14 1100 2000
@@ -48,15 +45,35 @@ Now let's get strict. Pass the :strict option with true and things get finicky
   Timeliness.parse('2010-09-08 12:13:14', :time, :strict => true)     #=> nil
   Timeliness.parse('2010-09-08 12:13:14', :datetime, :strict => true) #=> Wed Sep 08 12:13:14 1000 2010 i.e. the whole string is used
 
-The date and time strings are not accepted for a datetime type. The strict option without a type is ignored.
+The date and time strings are not accepted for a datetime type. The strict option without a type is
+ignored.
+
+
+=== Specify the Current Date
+
+Notice a time only string will return with a date value. The date value can be configured globally 
+with this setting:
+
+  Timeliness.date_for_time_type = [2010, 1, 1]
+
+or using a lambda thats evaluated when parsed
 
-To control what zone the time object is returned in, you have two options. Firstly you can set the default zone. Below
-is the list of options with their effective time creation method call
+  Timeliness.date_for_time_type = lambda { Time.now } 
+
+It can also be specified with :now option:
+
+  Timeliness.parse('12:13:14', :now => Time.mktime(2010,9,8)) #=> Wed Sep 08 12:13:14 1000 2010
+
+
+=== Timezone
+
+To control what zone the time object is returned in, you have two options. Firstly you can set the
+default zone. Below is the list of options with their effective time creation method call
 
   Timeliness.default_timezone = :local      # Time.local(...)
   Timeliness.default_timezone = :utc        # Time.utc(...)
-  Timeliness.default_timezone = :current    # Time.zone.local(...)
-  Timeliness.default_timezone = 'Melbourne' # Time.use_zone('Melbourne') { Time.zone.local(...) }
+  Timeliness.default_timezone = :current    # Time.zone.local(...). Use current zone.
+  Timeliness.default_timezone = 'Melbourne' # Time.use_zone('Melbourne') { Time.zone.local(...) }. Doesn't change Time.zone.
 
 The last two options require that you have ActiveSupport timezone extension loaded.
 
@@ -69,25 +86,32 @@ You can also use the :zone option to control it for a single parse call:
 
 Remember, you must have ActiveSupport timezone extension loaded to use the last two examples.
 
+
+=== Restrict to Format
+
 To get super finicky, you can restrict the parsing to a single format with the :format option
 
   Timeliness.parse('2010-09-08 12:13:14', :format => 'yyyy-mm-dd hh:nn:ss')  #=> Wed Sep 08 12:13:14 UTC 2010
   Timeliness.parse('08/09/2010 12:13:14', :format => 'yyyy-mm-dd hh:nn:ss')  #=> nil
 
+
+=== Raw Parsed Values
+
 If you would like to get the raw array of values before the time object is created, you can with
 
-  Timeliness._parse('2010-09-08 12:13:14') # => [2010, 9, 8, 12, 13, 14, nil]
+  Timeliness._parse('2010-09-08 12:13:14') # => [2010, 9, 8, 12, 13, 14, nil, nil]
 
-The last nil is for the empty value of microseconds.
+The last two nils are for the empty value of microseconds, and timezone or offset.
 
 
 == Formats
 
-The gem has default formats included which can be easily added to using the format syntax. Also formats can be easily
-removed so that they are no longer considered valid.
+The gem has default formats included which can be easily added to using the format syntax. Also 
+formats can be easily removed so that they are no longer considered valid.
 
-Below are the default formats. If you think they are easy to read then you will be happy to know that is exactly the same
-format syntax you can use to define your own. No complex regular expressions are needed.
+Below are the default formats. If you think they are easy to read then you will be happy to know
+that is exactly the same format syntax you can use to define your own. No complex regular
+expressions are needed.
 
 
 === Datetime formats
@@ -164,7 +188,8 @@ Here is what each format token means:
      ddd = Day name of 3 to 9 letters (e.g. Wed or Wednesday)
        u = microseconds matches 1 to 3 digits
 
-All other characters are considered literal. For the technically minded, these formats are compiled into a single regular expression
+All other characters are considered literal. For the technically minded, these formats are compiled
+into a single regular expression
 
 To see all defined formats look at the {source code}[http://github.com/adzap/timeliness/tree/master/lib/timeliness/formats.rb].
 
@@ -173,9 +198,9 @@ To see all defined formats look at the {source code}[http://github.com/adzap/tim
 
 === US/Euro Formats
 
-The perennial problem for non-US developers or applications not primarily for the
-US, is the US date format of m/d/yy. This is ambiguous with the European format
-of d/m/yy. By default the gem uses the US formats as this is the Ruby default
+The perennial problem for non-US developers or applications not primarily for the US, is the US date
+format of m/d/yy. This is ambiguous with the European format of d/m/yy. By default the gem uses the
+US formats as this is the Ruby default
 when it does date interpretation.
 
 To switch to using the European (or Rest of The World) formats use this setting
@@ -191,8 +216,8 @@ You can switch back to US formats with
 
 === Customising Formats
 
-Sometimes you may not want certain formats to be valid. You can remove formats for each type and 
-the parser will then not consider that a valid format. To remove a format
+Sometimes you may not want certain formats to be valid. You can remove formats for each type and the
+parser will then not consider that a valid format. To remove a format
 
   Timeliness.remove_formats(:date, 'm\d\yy')
 
@@ -202,27 +227,25 @@ Adding new formats is also simple
 
 Now "10 o'clock" will be a valid value.
 
-You can embed regular expressions in the format but no guarantees that it will
-remain intact. If you avoid the use of any token characters, and regexp dots or
-backslashes as special characters in the regexp, it may work as expected.
-For special characters use POSIX character classes for safety. See the ISO 8601
-datetime for an example of an embedded regular expression.
+You can embed regular expressions in the format but no guarantees that it will remain intact. If
+you avoid the use of any token characters, and regexp dots or backslashes as special characters in
+the regexp, it may work as expected.  For special characters use POSIX character classes for safety.
+See the ISO 8601 datetime for an example of an embedded regular expression.
 
-Because formats are evaluated in order, adding a format which may be ambiguous
-with an existing format, will mean your format is ignored. If you need to make
-your new format higher precedence than an existing format, you can include the
-before option like so
+Because formats are evaluated in order, adding a format which may be ambiguous with an existing
+format, will mean your format is ignored. If you need to make your new format higher precedence than
+an existing format, you can include the before option like so
 
   Timeliness.add_formats(:time, 'ss:nn:hh', :before => 'hh:nn:ss')
 
-Now a time of '59:30:23' will be interpreted as 11:30:59 pm. This option saves
-you adding a new one and deleting an old one to get it to work.
+Now a time of '59:30:23' will be interpreted as 11:30:59 pm. This option saves you adding a new one
+and deleting an old one to get it to work.
 
 
 === Ambiguous Year
 
-When dealing with 2 digit year values, by default a year is interpreted as being
-in the last century when at or above 30. You can customize this however
+When dealing with 2 digit year values, by default a year is interpreted as being in the last century
+when at or above 30. You can customize this however
 
   Timeliness.ambiguous_year_threshold = 20
 

data/lib/timeliness.rb

@@ -12,10 +12,7 @@ module Timeliness
     extend Forwardable
     def_delegators Parser, :parse, :_parse
     def_delegators Formats, :add_formats, :remove_formats, :use_us_formats, :use_euro_formats
-
     attr_accessor :default_timezone, :date_for_time_type, :ambiguous_year_threshold
-
-    alias :dummy_date_for_time_type :date_for_time_type
   end
 
   # Default timezone. Options:
@@ -31,6 +28,16 @@ module Timeliness
   # Set the default date part for a time type values.
   @date_for_time_type = [ 2000, 1, 1 ]
 
+  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
+
   # Set the threshold value for a two digit year to be considered last century
   #
   # Default: 30

data/lib/timeliness/format_set.rb

@@ -48,7 +48,7 @@ module Timeliness
       # values placed in the position defined by the component.
       #
       def define_format_method(name, components)
-        values = [nil] * 7
+        values = [nil] * 8
         components.each do |component|
           position, code = *Formats.format_components[component]
           values[position] = code || "#{component}.to_i" if position
@@ -66,6 +66,10 @@ module Timeliness
       @formats = formats
     end
 
+    # Compiles the formats into one big regexp. Stores the index of where
+    # each format's capture values begin in the match data. Each individual
+    # format regpexp is also stored for use with the parse :format option.
+    #
     def compile!
       regexp_string   = ''
       @format_regexps = {}

data/lib/timeliness/formats.rb

@@ -100,7 +100,7 @@ module Timeliness
       'u'    => [ '\d{1,6}', :usec ],
       'ampm' => [ '[aApP]\.?[mM]\.?', :meridian ],
       'zo'   => [ '[+-]\d{2}:?\d{2}', :offset ],
-      'tz'   => [ '[A-Z]{1,4}' ],
+      'tz'   => [ '[A-Z]{1,4}', :zone ],
       '_'    => [ '\s?' ]
     }
 
@@ -122,6 +122,7 @@ module Timeliness
       :sec      => [ 5 ],
       :usec     => [ 6, 'microseconds(usec)'],
       :offset   => [ 7, 'offset_in_seconds(offset)'],
+      :zone     => [ 7, 'zone'],
       :meridian => [ nil ]
     }
 

data/lib/timeliness/parser.rb

@@ -1,5 +1,6 @@
 module Timeliness
   module Parser
+    class MissingTimezoneSupport < StandardError; end
 
     class << self
 
@@ -12,18 +13,11 @@ module Timeliness
         time_array = _parse(value, type, options)
         return nil if time_array.nil?
 
-        case type
-        when :date
-          time_array[3..7] = nil
-        when :time
-          time_array[0..2] = current_date(options)
-        when nil
-          dummy_date = current_date(options)
-          time_array[0] ||= dummy_date[0]
-          time_array[1] ||= dummy_date[1]
-          time_array[2] ||= dummy_date[2]
-        end
+        override_values_by_type(time_array, type, options) unless type == :datetime
         make_time(time_array[0..6], options[:zone])
+      rescue NoMethodError => ex
+        raise ex unless ex.message =~ /zone/
+        raise MissingTimezoneSupport, "ActiveSupport must be loaded to use timezones other than :utc and :local."
       end
 
       def make_time(time_array, zone=nil)
@@ -57,21 +51,40 @@ module Timeliness
 
       private
 
+      def override_values_by_type(values, type, options)
+        case type
+        when :date
+          values[3..7] = nil
+        when :time
+          values[0..2] = current_date(options)
+        when nil
+          dummy_date = current_date(options)
+          values[0] ||= dummy_date[0]
+          values[1] ||= dummy_date[1]
+          values[2] ||= dummy_date[2]
+        end
+      end
+
       def current_date(options)
         now = if options[:now]
           options[:now]
         elsif options[:zone]
-          case options[:zone]
-          when :utc, :local
-            Time.now.send("get#{options[:zone]}")
-          when :current
-            Time.current
-          else
-            Time.use_zone(options[:zone]) { Time.current }
-          end
+          current_time_in_zone(options[:zone])
+        else
+          Timeliness.date_for_time_type
+        end
+        now.is_a?(Array) ? now[0..2] : [now.year, now.month, now.day]
+      end
+
+      def current_time_in_zone(zone)
+        case zone
+        when :utc, :local
+          Time.now.send("get#{zone}")
+        when :current
+          Time.current
+        else
+          Time.use_zone(zone) { Time.current }
         end
-        now ||= Timeliness.date_for_time_type
-        now.is_a?(Array) ? now[0..2] : Array(now).reverse[4..6]
       end
 
       # Taken from ActiveSupport and simplified

data/lib/timeliness/version.rb

@@ -1,3 +1,3 @@
 module Timeliness
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/spec/timeliness/format_set_spec.rb

@@ -3,32 +3,36 @@ require 'spec_helper'
 describe Timeliness::FormatSet do
   context ".define_format_method" do
     it "should define method which outputs date array with values in correct order" do
-      define_method_for('yyyy-mm-dd').call('2000', '1', '2').should == [2000,1,2,nil,nil,nil,nil]
+      define_method_for('yyyy-mm-dd').call('2000', '1', '2').should == [2000,1,2,nil,nil,nil,nil,nil]
     end
 
     it "should define method which outputs date array from format with different order" do
-      define_method_for('dd/mm/yyyy').call('2', '1', '2000').should == [2000,1,2,nil,nil,nil,nil]
+      define_method_for('dd/mm/yyyy').call('2', '1', '2000').should == [2000,1,2,nil,nil,nil,nil,nil]
     end
 
     it "should define method which outputs time array" do
-      define_method_for('hh:nn:ss').call('01', '02', '03').should == [nil,nil,nil,1,2,3,nil]
+      define_method_for('hh:nn:ss').call('01', '02', '03').should == [nil,nil,nil,1,2,3,nil,nil]
     end
 
     it "should define method which outputs time array with meridian 'pm' adjusted hour" do
-      define_method_for('hh:nn:ss ampm').call('01', '02', '03', 'pm').should == [nil,nil,nil,13,2,3,nil]
+      define_method_for('hh:nn:ss ampm').call('01', '02', '03', 'pm').should == [nil,nil,nil,13,2,3,nil,nil]
     end
 
     it "should define method which outputs time array with meridian 'am' unadjusted hour" do
-      define_method_for('hh:nn:ss ampm').call('01', '02', '03', 'am').should == [nil,nil,nil,1,2,3,nil]
+      define_method_for('hh:nn:ss ampm').call('01', '02', '03', 'am').should == [nil,nil,nil,1,2,3,nil,nil]
     end
 
     it "should define method which outputs time array with microseconds" do
-      define_method_for('hh:nn:ss.u').call('01', '02', '03', '99').should == [nil,nil,nil,1,2,3,990000]
+      define_method_for('hh:nn:ss.u').call('01', '02', '03', '99').should == [nil,nil,nil,1,2,3,990000,nil]
     end
 
     it "should define method which outputs datetime array with zone offset" do
       define_method_for('yyyy-mm-dd hh:nn:ss.u zo').call('2001', '02', '03', '04', '05', '06', '99', '+10:00').should == [2001,2,3,4,5,6,990000,36000]
     end
+
+    it "should define method which outputs datetime array with timezone string" do
+      define_method_for('yyyy-mm-dd hh:nn:ss.u tz').call('2001', '02', '03', '04', '05', '06', '99', 'EST').should == [2001,2,3,4,5,6,990000,'EST']
+    end
   end
 
   context "compiled regexp" do

data/spec/timeliness/formats_spec.rb

@@ -26,7 +26,7 @@ describe Timeliness::Formats do
       it "should add new format with higher precedence" do
         formats.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]
+        time_array.should == [nil,nil,nil,23,58,59,nil,nil]
       end
 
       it "should raise error if :before format does not exist" do
@@ -45,17 +45,18 @@ describe Timeliness::Formats do
       @default_formats = formats.time_formats.dup
     end
 
-    it "should remove format from format array" do
+    it "should remove a single format from the formats array for type" do
       formats.remove_formats(:time, 'h.nn_ampm')
-      formats.time_formats.should_not include("h o'clock")
+      formats.time_formats.should_not include('h.nn_ampm')
     end
 
-    it "should remove multiple formats from format array" do
-      formats.remove_formats(:time, 'h.nn_ampm')
-      formats.time_formats.should_not include("h o'clock")
+    it "should remove multiple formats from formats array for type" do
+      formats.remove_formats(:time, 'h:nn', 'h.nn_ampm')
+      formats.time_formats.should_not include('h:nn')
+      formats.time_formats.should_not include('h.nn_ampm')
     end
 
-    it "should not allow format to be parsed" do
+    it "should prevent parsing of removed format" do
       should_parse('2.12am', :time)
       formats.remove_formats(:time, 'h.nn_ampm')
       should_not_parse('2.12am', :time)
@@ -73,9 +74,9 @@ describe Timeliness::Formats 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]
+      parser._parse('01/02/2000', :date).should == [2000,1,2,nil,nil,nil,nil,nil]
       formats.use_euro_formats
-      parser._parse('01/02/2000', :date).should == [2000,2,1,nil,nil,nil,nil]
+      parser._parse('01/02/2000', :date).should == [2000,2,1,nil,nil,nil,nil,nil]
     end
   end
 
@@ -85,9 +86,9 @@ describe Timeliness::Formats do
     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]
+      parser._parse('01/02/2000', :date).should == [2000,2,1,nil,nil,nil,nil,nil]
       formats.use_us_formats
-      parser._parse('01/02/2000', :date).should == [2000,1,2,nil,nil,nil,nil]
+      parser._parse('01/02/2000', :date).should == [2000,1,2,nil,nil,nil,nil,nil]
     end
   end
 end

data/spec/timeliness/parser_spec.rb

@@ -71,11 +71,36 @@ describe Timeliness::Parser do
           time.utc_offset.should == 1.hour
         end
       end
+
+      context "without ActiveSupport loaded" do
+        it 'should output message' do
+          lambda {
+            Time.should_receive(:use_zone).and_raise(NoMethodError.new("undefined method `zone' for Time:Class"))
+            time = parse("2000-06-01 12:13:14", :datetime, :zone => 'London')
+          }.should raise_error(Timeliness::Parser::MissingTimezoneSupport)
+        end
+      end
     end
 
     describe "for time type" do
-      it 'should use date from date_for_time_type' do
-        parse('12:13:14', :time).should == Time.local(2000,1,1,12,13,14)
+      context "with date from date_for_time_type" do
+        before do
+          @original = Timeliness.date_for_time_type
+        end
+
+        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)
+        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)
+        end
+
+        after do
+          Timeliness.date_for_time_type = @original
+        end
       end
 
       context "with :now option" do
@@ -107,54 +132,54 @@ describe Timeliness::Parser do
     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]
+        time_array.should == [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]
+        time_array.should == [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', :datetime)
-        time_array.should == [2000,2,1,12,13,14,nil]
+        time_array.should == [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]
+        time_array.should == [2000,2,1,nil,nil,nil,nil,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]
+        time_array.should == [2000,2,1,12,13,14,nil,nil]
       end
     end
 
     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]
+        time_array.should == [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]
+        time_array.should == [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]
+        time_array.should == [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')
-        time_array.should == [2000,2,1,nil,nil,nil,nil]
+        time_array.should == [2000,2,1,nil,nil,nil,nil,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')
-        time_array.should == [2000,2,1,12,13,14,nil]
+        time_array.should == [2000,2,1,12,13,14,nil,nil]
       end
     end
 
@@ -205,7 +230,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]
+        time_array.should == [2000,2,1,12,13,14,nil,nil]
       end
 
       it "should return nil if string does not match specified format" do
@@ -217,21 +242,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]
+        time_array.should == [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]
+        time_array.should == [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]
+        time_array.should == [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]
+        time_array.should == [1940,2,1,nil,nil,nil,nil,nil]
         Timeliness.ambiguous_year_threshold = default
       end
     end

data/timeliness.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{timeliness}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adam Meehan"]
-  s.date = %q{2010-10-14}
+  s.date = %q{2010-10-27}
   s.description = %q{Fast date/time parser with customisable formats and I18n support.}
   s.email = %q{adam.meehan@gmail.com}
   s.extra_rdoc_files = ["README.rdoc", "CHANGELOG.rdoc"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: timeliness
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Adam Meehan
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-14 00:00:00 +11:00
+date: 2010-10-27 00:00:00 +11:00
 default_executable: 
 dependencies: []