timeliness 0.2.0 → 0.3.0

data/lib/timeliness/helpers.rb

@@ -5,7 +5,7 @@ module Timeliness
       hour = hour.to_i
       return hour if meridian.nil?
       if meridian.delete('.').downcase == 'am'
-        raise if hour == 0 || hour > 12
+        raise(ArgumentError) if hour == 0 || hour > 12
         hour == 12 ? 0 : hour
       else
         hour == 12 ? hour : hour + 12

data/lib/timeliness/parser.rb

@@ -7,42 +7,40 @@ module Timeliness
       def parse(value, *args)
         return value unless value.is_a?(String)
 
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        type = args.first
+        type, options = type_and_options_from_args(args)
 
         time_array = _parse(value, type, options)
         return nil if time_array.nil?
 
-        override_values_by_type(time_array, type, options) unless type == :datetime
-        make_time(time_array[0..6], options[:zone])
+        default_values_by_type(time_array, type, options) unless type == :datetime
+
+        make_time(time_array[0..7], 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)
+      def make_time(time_array, zone_option=nil)
         return nil unless fast_date_valid_with_fallback(*time_array[0..2])
 
-        zone ||= Timeliness.default_timezone
-        case zone
-        when :utc, :local
-          time_with_datetime_fallback(zone, *time_array.compact)
-        when :current
-          Time.zone.local(*time_array)
-        else
-          Time.use_zone(zone) { Time.zone.local(*time_array) }
-        end
+        zone_or_offset = time_array.delete_at(7)
+        zone, offset   = zone_and_offset(zone_or_offset) if zone_or_offset
+
+        value = create_time_in_zone(time_array, zone || zone_option)
+        value = time_in_zone(value, zone_option) if zone
+
+        offset ? value + (value.utc_offset - offset) : value
       rescue ArgumentError, TypeError
         nil
       end
 
       def _parse(string, type=nil, options={})
         if options[:strict] && type
-          set = Formats.send("#{type}_format_set")
+          set = Definitions.send("#{type}_format_set")
           set.match(string, options[:format])
         else
           values = nil
-          Formats.format_set(type, string).find {|set| values = set.match(string, options[:format]) }
+          Definitions.format_sets(type, string).find {|set| values = set.match(string, options[:format]) }
           values
         end
       rescue
@@ -51,7 +49,18 @@ module Timeliness
 
       private
 
-      def override_values_by_type(values, type, options)
+      def type_and_options_from_args(args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        type_or_now = args.first
+        if type_or_now.is_a?(Symbol)
+          type = type_or_now
+        elsif !type_or_now.is_a?(Hash)
+          options[:now] = type_or_now
+        end
+        return type, options
+      end
+
+      def default_values_by_type(values, type, options)
         case type
         when :date
           values[3..7] = nil
@@ -87,6 +96,39 @@ module Timeliness
         end
       end
 
+      def time_in_zone(time, zone=nil)
+        zone ||= Timeliness.default_timezone
+        case zone
+        when :utc, :local
+          time.send("get#{zone}")
+        when :current
+          time.in_time_zone
+        else
+          Time.use_zone(zone) { time.in_time_zone }
+        end
+      end
+
+      def create_time_in_zone(time_array, zone=nil)
+        zone ||= Timeliness.default_timezone
+        case zone
+        when :utc, :local
+          time_with_datetime_fallback(zone, *time_array.compact)
+        when :current
+          Time.zone.local(*time_array)
+        else
+          Time.use_zone(zone) { Time.zone.local(*time_array) }
+        end
+      end
+
+      def zone_and_offset(parsed_value)
+        if parsed_value.is_a?(String)
+          zone   = Definitions.timezone_mapping[parsed_value] || parsed_value
+        else
+          offset = parsed_value
+        end
+        return zone, offset
+      end
+
       # Taken from ActiveSupport and simplified
       def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
        return nil if hour > 23 || min > 59 || sec > 59

data/lib/timeliness/version.rb

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

data/spec/spec_helper.rb

@@ -9,8 +9,8 @@ module TimelinessHelpers
     Timeliness::Parser
   end
 
-  def formats
-    Timeliness::Formats
+  def definitions
+    Timeliness::Definitions
   end
 
   def parse(*args)

data/spec/timeliness/{formats_spec.rb → definitions_spec.rb}

@@ -1,93 +1,93 @@
 require 'spec_helper'
 
-describe Timeliness::Formats do
+describe Timeliness::Definitions do
 
   context "add_formats" do
     before do
-      @default_formats = formats.time_formats.dup
+      @default_formats = definitions.time_formats.dup
     end
 
     it "should add format to format array" do
-      formats.add_formats(:time, "h o'clock")
-      formats.time_formats.should include("h o'clock")
+      definitions.add_formats(:time, "h o'clock")
+      definitions.time_formats.should include("h o'clock")
     end
 
     it "should parse new format after its added" do
       should_not_parse("12 o'clock", :time)
-      formats.add_formats(:time, "h o'clock")
+      definitions.add_formats(:time, "h o'clock")
       should_parse("12 o'clock", :time)
     end
 
     it "should raise error if format exists" do
-      lambda { formats.add_formats(:time, "hh:nn:ss") }.should raise_error
+      expect { definitions.add_formats(:time, "hh:nn:ss") }.should raise_error
     end
 
     context "with :before option" do
       it "should add new format with higher precedence" do
-        formats.add_formats(:time, "ss:hh:nn", :before => 'hh:nn:ss')
+        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]
       end
 
       it "should raise error if :before format does not exist" do
-        lambda { formats.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') }.should raise_error
       end
     end
 
     after do
-      formats.time_formats = @default_formats
-      formats.compile_formats
+      definitions.time_formats = @default_formats
+      definitions.compile_formats
     end
   end
 
   context "remove_formats" do
     before do
-      @default_formats = formats.time_formats.dup
+      @default_formats = definitions.time_formats.dup
     end
 
     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.nn_ampm')
+      definitions.remove_formats(:time, 'h.nn_ampm')
+      definitions.time_formats.should_not include('h.nn_ampm')
     end
 
     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')
+      definitions.remove_formats(:time, 'h:nn', 'h.nn_ampm')
+      definitions.time_formats.should_not include('h:nn')
+      definitions.time_formats.should_not include('h.nn_ampm')
     end
 
     it "should prevent parsing of removed format" do
       should_parse('2.12am', :time)
-      formats.remove_formats(:time, 'h.nn_ampm')
+      definitions.remove_formats(:time, 'h.nn_ampm')
       should_not_parse('2.12am', :time)
     end
 
     it "should raise error if format does not exist" do
-      lambda { formats.remove_formats(:time, "ss:hh:nn") }.should raise_error()
+      expect { definitions.remove_formats(:time, "ss:hh:nn") }.should raise_error()
     end
 
     after do
-      formats.time_formats = @default_formats
-      formats.compile_formats
+      definitions.time_formats = @default_formats
+      definitions.compile_formats
     end
   end
 
   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]
-      formats.use_euro_formats
+      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
     before do
-      formats.use_euro_formats
+      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]
-      formats.use_us_formats
+      definitions.use_us_formats
       parser._parse('01/02/2000', :date).should == [2000,1,2,nil,nil,nil,nil,nil]
     end
   end

data/spec/timeliness/format_set_spec.rb

@@ -1,42 +1,16 @@
 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,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,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,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,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,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,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
+  context "#compile!" do
+    let(:set) { Timeliness::FormatSet.new(['yyyy-mm-dd', 'dd/mm/yyyy']) }
 
-    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']
+    it 'should set the regexp for the set' do
+      set.compile!
+      set.regexp.should_not be_nil
     end
   end
 
   context "compiled regexp" do
-
     context "for time formats" do
       format_tests = {
         'hh:nn:ss'  => {:pass => ['12:12:12', '01:01:01'], :fail => ['1:12:12', '12:1:12', '12:12:1', '12-12-12']},
@@ -99,8 +73,21 @@ describe Timeliness::FormatSet do
 
   end
 
-  def define_method_for(format)
-    Timeliness::FormatSet.compile([format]).method(:"format_#{format}")
+  context "#match" do
+    let(:set) { Timeliness::FormatSet.compile(['yyyy-mm-dd', 'dd/mm/yyyy']) }
+
+    it 'should return array if string matches a format in set' do
+      set.match('2000-01-02').should be_kind_of(Array)
+    end
+
+    it 'should return nil if string does not matches a format in set' do
+      set.match('2nd Feb 2000').should be_nil
+    end
+
+    it 'should only use specific format string for match if provided' do
+      set.match('2000-01-02', 'yyyy-mm-dd').should be_kind_of(Array)
+      set.match('2000-01-02', 'dd/mm/yyyy').should be_nil
+    end
   end
 
   def compile_regexp(format)

data/spec/timeliness/format_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Timeliness::Format do
+  context "#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]
+    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]
+    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]
+    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]
+    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]
+    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]
+    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]
+    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']
+    end
+  end
+
+  def format_for(format)
+    Timeliness::Format.new(format).compile!
+  end
+end

data/spec/timeliness/parser_spec.rb

@@ -1,38 +1,128 @@
 require 'spec_helper'
 
 describe Timeliness::Parser do
-  context "parse" do
+  before(:all) do
+    Timecop.freeze(2010,1,1,0,0,0)
+  end
+
+  describe "parse" do
+    it "should return time object for valid datetime string" do
+      parse("2000-01-01 12:13:14").should be_kind_of(Time)
+    end
+
+    it "should return nil for empty string" do
+      parse("").should be_nil
+    end
+
+    it "should return nil for nil value" do
+      parse(nil).should be_nil
+    end
+
+    it "should return return same value if value not a string" do
+      value = Time.now
+      parse(value).should == value
+    end
+
+    it "should return time object for valid date string" do
+      parse("2000-01-01").should be_kind_of(Time)
+    end
+
+    it "should return nil for invalid date string" do
+      should_not_parse("2000-02-30")
+    end
+
     it "should return time object for valid time string" do
-      parse("2000-01-01 12:13:14", :datetime).should be_kind_of(Time)
+      parse("12:13:14").should be_kind_of(Time)
+    end
+
+    it "should return nil for invalid time string" do
+      should_not_parse("25:00:00")
     end
 
     it "should return nil for datetime string with invalid date part" do
-      should_not_parse("2000-02-30 12:13:14", :datetime)
+      should_not_parse("2000-02-30 12:13:14")
     end
 
     it "should return nil for datetime string with invalid time part" do
-      should_not_parse("2000-02-01 25:13:14", :datetime)
+      should_not_parse("2000-02-01 25:13:14")
     end
 
-    it "should return nil for invalid date string" do
-      should_not_parse("2000-02-30", :date)
+    context "string with zone offset value" 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
+        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
+        end
+      end
+
+      context "when current timezone is later than string zone" do
+        before(:all) do
+          Timeliness.default_timezone = :current
+          Time.zone = 'America/Phoenix'
+        end
+
+        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
+        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
+        end
+
+        after(:all) do
+          Time.zone = nil
+          Timeliness.default_timezone = :local
+        end
+      end
     end
 
-    it "should return nil for invalid time string" do
-      should_not_parse("25:00:00", :time)
+    context "string with zone abbreviation" do
+      it 'should return value using string zone in default timezone' do
+        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
+      end
     end
 
-    it "should ignore time in datetime string for date type" do
-      parse('2000-02-01 12:13', :date).should == Time.local(2000,2,1)
+    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)
+      end
     end
 
-    it "should ignore date in datetime string for time type" do
-      parse('2010-02-01 12:13', :time).should == Time.local(2000,1,1,12,13)
+    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)
+      end
+
+      it "should ignore time in datetime string" do
+        parse('2000-02-01 12:13', :date).should == Time.local(2000,2,1)
+      end
     end
 
-    it "should return return same value if value not a string" do
-      value = Time.now
-      parse(value, :datetime).should == value
+    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)
+      end
+
+      it "should ignore date in datetime string" do
+        parse('2010-02-01 12:13', :time).should == Time.local(2010,1,1,12,13)
+      end
+
+      it "should raise error if time hour is out of range for AM meridian" do
+        parse('13:14 am', :time).should be_nil
+      end
     end
 
     context "with :now option" do
@@ -75,14 +165,14 @@ describe Timeliness::Parser do
       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')
+            Time.should_receive(:zone).and_raise(NoMethodError.new("undefined method `zone' for Time:Class"))
+            time = parse("2000-06-01 12:13:14", :datetime, :zone => :current)
           }.should raise_error(Timeliness::Parser::MissingTimezoneSupport)
         end
       end
     end
 
-    describe "for time type" do
+    context "for time type" do
       context "with date from date_for_time_type" do
         before do
           @original = Timeliness.date_for_time_type
@@ -110,28 +200,21 @@ describe Timeliness::Parser do
       end
 
       context "with :zone option" do
-        before(:all) do
-          Timecop.freeze(2010,1,1,0,0,0)
-        end
-
         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
         end
-
-        after(:all) do
-          Timecop.return
-        end
       end
+
     end
   end
 
-  context "_parse" do
-    context "with type" do
+  describe "_parse" do
+    context "with no type" do
       it "should return date array from date string" do
-        time_array = parser._parse('2000-02-01', :date)
+        time_array = parser._parse('2000-02-01')
         time_array.should == [2000,2,1,nil,nil,nil,nil,nil]
       end
 
@@ -141,45 +224,45 @@ describe Timeliness::Parser do
       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,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]
-      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 = parser._parse('2000-02-01 12:13:14')
         time_array.should == [2000,2,1,12,13,14,nil,nil]
       end
     end
 
-    context "with no type" do
+    context "with type" do
       it "should return date array from date string" do
-        time_array = parser._parse('2000-02-01')
+        time_array = parser._parse('2000-02-01', :date)
         time_array.should == [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
+      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]
       end
 
-      it "should return datetime array from datetime string" do
-        time_array = parser._parse('2000-02-01 12:13:14')
+      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
+      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]
       end
 
       it "should return date array from date string when type is datetime" do
-        time_array = parser._parse('2000-02-01')
+        time_array = parser._parse('2000-02-01', :datetime)
         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,nil]
+      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
       end
     end
 
@@ -220,13 +303,6 @@ describe Timeliness::Parser do
       end
     end
 
-    it "should return nil if time hour is out of range for AM meridian" do
-      time_array = parser._parse('13:14 am', :time)
-      time_array.should == nil
-      time_array = parser._parse('00:14 am', :time)
-      time_array.should == nil
-    end
-
     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')
@@ -327,9 +403,6 @@ describe Timeliness::Parser do
   end
 
   describe "current_date" do
-    before(:all) do
-      Timecop.freeze(2010,1,1,0,0,0)
-    end
 
     context "with no options" do
       it 'should return date_for_time_type values with no options' do
@@ -371,9 +444,9 @@ describe Timeliness::Parser do
         current_date(:zone => 'London').should == date_array
       end
     end
+  end
 
-    after(:all) do
-      Timecop.return
-    end
+  after(:all) do
+    Timecop.return
   end
 end