timeliness 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09a4713be8da3195a5d92e1cfbd2bfda98f35ff922674fd12339bcecc562e366'
-  data.tar.gz: d645f22bed3e99b5e2ebf971304e6f6acc6b657339f3d3d651ea67902258fb24
+  metadata.gz: 0b1224a95afa47942b2118db304f6b00f741748e129243fe277ccb45127b9804
+  data.tar.gz: 320e9633f0769274f57bcca370e1a839abf62039df963af1d4cb35757b9f03fc
 SHA512:
-  metadata.gz: 346644804949fc5398084ff04feecca71b6a415908433520932ff7f38985bcf6bb2c8db0dd048f3939286ebdf9d01fab4544ab9c45e5d2a6549984231f0ec329
-  data.tar.gz: 39b7862378f626fb7f361769deb81488cd7d5c3c86a61a81dff199ea4b6abc07d29422f64a16e8220085a49fc25c45216259c1e49d5a371533ac4255257fb25f
+  metadata.gz: 593b8a2649f97b485a94f205c2e500ca38c31d4db734d46962c4224f12df47fe6679a111d1a950e1794f46065a9e922eafbada8a8dc617ac68a250a1249fba1c
+  data.tar.gz: 3b8705a405281a0d4bb2c56f436a6e016bae0f83ed8f61700fc6553d37ed53614b85b56d818063bc4aaa5dc96360426e762da038ed30374473448c621a18e07b

data/CHANGELOG.rdoc

@@ -1,3 +1,7 @@
+= 0.4.4 - 2019-08-06
+* Raise compilation error if token with capturing arg is used more than once in a format
+* Some small internal refactorings in format compilation
+
 = 0.4.3 - 2019-06-16
 * Fixed `Timeliness.ambiguous_date_format` being used in new threads if custom value set
 * Moved all config from Timeliness to new Configuration class. Delegated all

data/README.rdoc

@@ -41,9 +41,9 @@ the value for that type.
 
 Now let's get strict. Pass the :strict option with true and things get finicky
 
-  Timeliness.parse('2010-09-08 12:13:14', :date, :strict => true)     #=> nil
-  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
+  Timeliness.parse('2010-09-08 12:13:14', :date, strict: true)     #=> nil
+  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.
@@ -62,7 +62,7 @@ or using a lambda thats evaluated when parsed
 
 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
+  Timeliness.parse('12:13:14', now: Time.mktime(2010,9,8)) #=> Wed Sep 08 12:13:14 1000 2010
 
 As well conforming to the Ruby Time class style.
 
@@ -82,10 +82,10 @@ The last two options require that you have ActiveSupport timezone extension load
 
 You can also use the :zone option to control it for a single parse call:
 
-  Timeliness.parse('2010-09-08 12:13:14', :zone => :utc)        #=> Wed Sep 08 12:13:14 UTC 2010
-  Timeliness.parse('2010-09-08 12:13:14', :zone => :local)      #=> Wed Sep 08 12:13:14 1000 2010
-  Timeliness.parse('2010-09-08 12:13:14', :zone => :current)    #=> Wed Sep 08 12:13:14 1000 2010, with Time.zone = 'Melbourne'
-  Timeliness.parse('2010-09-08 12:13:14', :zone => 'Melbourne') #=> Wed Sep 08 12:13:14 1000 2010
+  Timeliness.parse('2010-09-08 12:13:14', zone: :utc)        #=> Wed Sep 08 12:13:14 UTC 2010
+  Timeliness.parse('2010-09-08 12:13:14', zone: :local)      #=> Wed Sep 08 12:13:14 1000 2010
+  Timeliness.parse('2010-09-08 12:13:14', zone: :current)    #=> Wed Sep 08 12:13:14 1000 2010, with Time.zone = 'Melbourne'
+  Timeliness.parse('2010-09-08 12:13:14', zone: 'Melbourne') #=> Wed Sep 08 12:13:14 1000 2010
 
 Remember, you must have ActiveSupport timezone extension loaded to use the last two examples.
 
@@ -94,8 +94,8 @@ Remember, you must have ActiveSupport timezone extension loaded to use the last
 
 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
+  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
 
 
 === String with Offset or Zone Abbreviations
@@ -280,7 +280,7 @@ Because formats are evaluated in order, adding a format which may be ambiguous w
 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')
+  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.

data/Rakefile

@@ -23,4 +23,4 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
 end
 
 desc 'Default: run specs.'
-task :default => :spec
+task default: :spec

data/benchmark.rb

@@ -13,7 +13,7 @@ if defined?(JRUBY_VERSION)
 end
 
 n = 10_000
-Benchmark.bm do |x|
+Benchmark.bm(40) do |x|
   x.report('timeliness - datetime') {
     n.times do
       Timeliness::Parser.parse("2000-01-04 12:12:12", :datetime)
@@ -22,7 +22,7 @@ Benchmark.bm do |x|
 
   x.report('timeliness - datetime with :format') {
     n.times do
-      Timeliness::Parser.parse("2000-01-04 12:12:12", :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
+      Timeliness::Parser.parse("2000-01-04 12:12:12", :datetime, format: 'yyyy-mm-dd hh:nn:ss')
     end
   }
 
@@ -131,22 +131,6 @@ Benchmark.bm do |x|
     end
   }
 
-  if defined?(ParseDate)
-    x.report('parsedate - valid') {
-      n.times do
-        arr = ParseDate.parsedate("2000-01-04 12:12:12")
-        Date.new(*arr[0..2])
-        Time.mktime(*arr)
-      end
-    }
-
-    x.report('parsedate - invalid ') {
-      n.times do
-        arr = ParseDate.parsedate("2000-00-04 12:12:12")
-      end
-    }
-  end
-
   x.report('strptime - valid') {
     n.times do
       DateTime.strptime("2000-01-04 12:12:12", '%Y-%m-%d %H:%M:%s')

data/lib/timeliness/core_ext/string.rb

@@ -3,7 +3,7 @@ class String
   # Form can be either :utc (default) or :local.
   def to_time(form = :utc)
     return nil if self.blank?
-    Timeliness::Parser.parse(self, :datetime, :zone => form)
+    Timeliness::Parser.parse(self, :datetime, zone: form)
   end
 
   def to_date

data/lib/timeliness/definitions.rb

@@ -121,17 +121,17 @@ module Timeliness
     # code is nil, then just the raw value is used.
     #
     @format_components = {
-      :year     => [ 0, 'unambiguous_year(year)'],
-      :month    => [ 1, 'month_index(month)'],
-      :day      => [ 2 ],
-      :hour     => [ 3, 'full_hour(hour, meridian ||= nil)'],
-      :min      => [ 4 ],
-      :sec      => [ 5 ],
-      :usec     => [ 6, 'microseconds(usec)'],
-      :offset   => [ 7, 'offset_in_seconds(offset)'],
-      :zone     => [ 7, 'zone'],
-      :zulu     => [ 7, 'offset_in_seconds("00:00")'],
-      :meridian => [ nil ]
+      year:     [ 0, 'unambiguous_year(year)'],
+      month:    [ 1, 'month_index(month)'],
+      day:      [ 2 ],
+      hour:     [ 3, 'full_hour(hour, meridian ||= nil)'],
+      min:      [ 4 ],
+      sec:      [ 5 ],
+      usec:     [ 6, 'microseconds(usec)'],
+      offset:   [ 7, 'offset_in_seconds(offset)'],
+      zone:     [ 7, 'zone'],
+      zulu:     [ 7, 'offset_in_seconds("00:00")'],
+      meridian: [ nil ]
     }
 
     # Mapping some common timezone abbreviations which are not mapped or

data/lib/timeliness/format.rb

@@ -12,29 +12,37 @@ module Timeliness
 
     def compile!
       @token_count = 0
+      found_tokens, token_order = [], []
+
       format = format_string.dup
       format.gsub!(/([\.\\])/, '\\\\\1') # escapes dots and backslashes
-      found_tokens, token_order = [], []
 
       # Substitute tokens with numbered placeholder
       Definitions.sorted_token_keys.each do |token|
-        token_regexp_str, arg_key = Definitions.format_tokens[token]
-        if format.gsub!(/#{token}/, "%<#{found_tokens.size}>")
+        count = 0
+        format.gsub!(token) do
+          token_regexp_str, arg_key = Definitions.format_tokens[token]
+          token_index = found_tokens.size
+
           if arg_key
+            raise CompilationFailed, "Token '#{token}' was found more than once in format '#{format_string}'. This has unexpected effects should be removed." if count > 0
+            count += 1
+
             token_regexp_str = "(#{token_regexp_str})"
             @token_count += 1
           end
-          found_tokens << [token_regexp_str, arg_key]
+          found_tokens << [ token_regexp_str, arg_key ]
+
+          "%<#{token_index}>"
         end
       end
 
       # Replace placeholders with token regexps
-      format.scan(/%<(\d)>/).each {|token_index|
-        token_index = token_index.first
-        token_regexp_str, arg_key = found_tokens[token_index.to_i]
-        format.gsub!("%<#{token_index}>", token_regexp_str)
+      format.gsub!(/%<(\d+)>/) do
+        token_regexp_str, arg_key = found_tokens[$1.to_i]
         token_order << arg_key
-      }
+        token_regexp_str
+      end
 
       define_process_method(token_order.compact)
       @regexp_string = format
@@ -55,12 +63,11 @@ module Timeliness
         position, code = Definitions.format_components[component]
         values[position] = code || "#{component}.to_i" if position
       end
-      instance_eval <<-DEF
-        def process(#{components.join(',')})
-          [#{values.map {|i| i || 'nil' }.join(',')}]
-        end
+      instance_eval <<~DEF
+      def process(#{components.join(',')})
+        [#{values.map { |i| i || 'nil' }.join(',')}]
+      end
       DEF
     end
-
   end
 end

data/lib/timeliness/version.rb

@@ -1,3 +1,3 @@
 module Timeliness
-  VERSION = '0.4.3'
+  VERSION = '0.4.4'
 end

data/spec/timeliness/definitions_spec.rb

@@ -21,13 +21,13 @@ describe Timeliness::Definitions do
 
     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')
+        definitions.add_formats(:time, "ss:hh:nn", before: 'hh:nn:ss')
         time_array = parser._parse('59:23:58', :time)
         expect(time_array).to 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') }.to raise_error(Timeliness::Definitions::FormatNotFound)
+        expect { definitions.add_formats(:time, "ss:hh:nn", before: 'nn:hh:ss') }.to raise_error(Timeliness::Definitions::FormatNotFound)
       end
     end
 

data/spec/timeliness/format_set_spec.rb

@@ -11,17 +11,17 @@ describe Timeliness::FormatSet do
   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']},
-        'hh-nn-ss'  => {:pass => ['12-12-12', '01-01-01'], :fail => ['1-12-12', '12-1-12', '12-12-1', '12:12:12']},
-        'h:nn'      => {:pass => ['12:12', '1:01'], :fail => ['12:2', '12-12']},
-        'h.nn'      => {:pass => ['2.12', '12.12'], :fail => ['2.1', '12:12']},
-        'h nn'      => {:pass => ['2 12', '12 12'], :fail => ['2 1', '2.12', '12:12']},
-        'h-nn'      => {:pass => ['2-12', '12-12'], :fail => ['2-1', '2.12', '12:12']},
-        'h:nn_ampm' => {:pass => ['2:12am', '2:12 pm', '2:12 AM', '2:12PM'], :fail => ['1:2am', '1:12  pm', '2.12am']},
-        'h.nn_ampm' => {:pass => ['2.12am', '2.12 pm'], :fail => ['1:2am', '1:12  pm', '2:12am']},
-        'h nn_ampm' => {:pass => ['2 12am', '2 12 pm'], :fail => ['1 2am', '1 12  pm', '2:12am']},
-        'h-nn_ampm' => {:pass => ['2-12am', '2-12 pm'], :fail => ['1-2am', '1-12  pm', '2:12am']},
-        'h_ampm'    => {:pass => ['2am', '2 am', '12 pm'], :fail => ['1.am', '12  pm', '2:12am']},
+        'hh:nn:ss'  => {pass: ['12:12:12', '01:01:01'], fail: ['1:12:12', '12:1:12', '12:12:1', '12-12-12']},
+        'hh-nn-ss'  => {pass: ['12-12-12', '01-01-01'], fail: ['1-12-12', '12-1-12', '12-12-1', '12:12:12']},
+        'h:nn'      => {pass: ['12:12', '1:01'], fail: ['12:2', '12-12']},
+        'h.nn'      => {pass: ['2.12', '12.12'], fail: ['2.1', '12:12']},
+        'h nn'      => {pass: ['2 12', '12 12'], fail: ['2 1', '2.12', '12:12']},
+        'h-nn'      => {pass: ['2-12', '12-12'], fail: ['2-1', '2.12', '12:12']},
+        'h:nn_ampm' => {pass: ['2:12am', '2:12 pm', '2:12 AM', '2:12PM'], fail: ['1:2am', '1:12  pm', '2.12am']},
+        'h.nn_ampm' => {pass: ['2.12am', '2.12 pm'], fail: ['1:2am', '1:12  pm', '2:12am']},
+        'h nn_ampm' => {pass: ['2 12am', '2 12 pm'], fail: ['1 2am', '1 12  pm', '2:12am']},
+        'h-nn_ampm' => {pass: ['2-12am', '2-12 pm'], fail: ['1-2am', '1-12  pm', '2:12am']},
+        'h_ampm'    => {pass: ['2am', '2 am', '12 pm'], fail: ['1.am', '12  pm', '2:12am']},
       }
       format_tests.each do |format, values|
         it "should correctly match times in format '#{format}'" do
@@ -34,17 +34,17 @@ describe Timeliness::FormatSet do
 
     context "for date formats" do
       format_tests = {
-        'yyyy/mm/dd' => {:pass => ['2000/02/01'], :fail => ['2000\02\01', '2000/2/1', '00/02/01']},
-        'yyyy-mm-dd' => {:pass => ['2000-02-01'], :fail => ['2000\02\01', '2000-2-1', '00-02-01']},
-        'yyyy.mm.dd' => {:pass => ['2000.02.01'], :fail => ['2000\02\01', '2000.2.1', '00.02.01']},
-        'm/d/yy'     => {:pass => ['2/1/01', '02/01/00', '02/01/2000'], :fail => ['2/1/0', '2.1.01']},
-        'd/m/yy'     => {:pass => ['1/2/01', '01/02/00', '01/02/2000'], :fail => ['1/2/0', '1.2.01']},
-        'm\d\yy'     => {:pass => ['2\1\01', '2\01\00', '02\01\2000'], :fail => ['2\1\0', '2/1/01']},
-        'd\m\yy'     => {:pass => ['1\2\01', '1\02\00', '01\02\2000'], :fail => ['1\2\0', '1/2/01']},
-        'd-m-yy'     => {:pass => ['1-2-01', '1-02-00', '01-02-2000'], :fail => ['1-2-0', '1/2/01']},
-        'd.m.yy'     => {:pass => ['1.2.01', '1.02.00', '01.02.2000'], :fail => ['1.2.0', '1/2/01']},
-        'd mmm yy'   => {:pass => ['1 Feb 00', '1 Feb 2000', '1 February 00', '01 February 2000'],
-                          :fail => ['1 Fe 00', 'Feb 1 2000', '1 Feb 0']}
+        'yyyy/mm/dd' => {pass: ['2000/02/01'], fail: ['2000\02\01', '2000/2/1', '00/02/01']},
+        'yyyy-mm-dd' => {pass: ['2000-02-01'], fail: ['2000\02\01', '2000-2-1', '00-02-01']},
+        'yyyy.mm.dd' => {pass: ['2000.02.01'], fail: ['2000\02\01', '2000.2.1', '00.02.01']},
+        'm/d/yy'     => {pass: ['2/1/01', '02/01/00', '02/01/2000'], fail: ['2/1/0', '2.1.01']},
+        'd/m/yy'     => {pass: ['1/2/01', '01/02/00', '01/02/2000'], fail: ['1/2/0', '1.2.01']},
+        'm\d\yy'     => {pass: ['2\1\01', '2\01\00', '02\01\2000'], fail: ['2\1\0', '2/1/01']},
+        'd\m\yy'     => {pass: ['1\2\01', '1\02\00', '01\02\2000'], fail: ['1\2\0', '1/2/01']},
+        'd-m-yy'     => {pass: ['1-2-01', '1-02-00', '01-02-2000'], fail: ['1-2-0', '1/2/01']},
+        'd.m.yy'     => {pass: ['1.2.01', '1.02.00', '01.02.2000'], fail: ['1.2.0', '1/2/01']},
+        'd mmm yy'   => {pass: ['1 Feb 00', '1 Feb 2000', '1 February 00', '01 February 2000'],
+                          fail: ['1 Fe 00', 'Feb 1 2000', '1 Feb 0']}
       }
       format_tests.each do |format, values|
         it "should correctly match dates in format '#{format}'" do
@@ -57,10 +57,10 @@ describe Timeliness::FormatSet do
 
     context "for datetime formats" do
       format_tests = {
-        'ddd mmm d hh:nn:ss zo yyyy' => {:pass => ['Sat Jul 19 12:00:00 +1000 2008'], :fail => []},
-        'ddd mmm d hh:nn:ss tz yyyy' => {:pass => ['Sat Jul 19 12:00:00 EST 2008'], :fail => []},
-        'yyyy-mm-ddThh:nn:sszo' => {:pass => ['2008-07-19T12:00:00+10:00'], :fail => ['2008-07-19T12:00:00Z+10:00']},
-        'yyyy-mm-ddThh:nn:ss.uzt' => {:pass => ['2019-06-07T03:35:55.100000Z'], :fail => []},
+        'ddd mmm d hh:nn:ss zo yyyy' => {pass: ['Sat Jul 19 12:00:00 +1000 2008'], fail: []},
+        'ddd mmm d hh:nn:ss tz yyyy' => {pass: ['Sat Jul 19 12:00:00 EST 2008'], fail: []},
+        'yyyy-mm-ddThh:nn:sszo' => {pass: ['2008-07-19T12:00:00+10:00'], fail: ['2008-07-19T12:00:00Z+10:00']},
+        'yyyy-mm-ddThh:nn:ss.uzt' => {pass: ['2019-06-07T03:35:55.100000Z'], fail: []},
       }
       format_tests.each do |format, values|
         it "should correctly match datetimes in format '#{format}'" do

data/spec/timeliness/format_spec.rb

@@ -16,6 +16,12 @@ describe Timeliness::Format do
         Timeliness::Format.new('|--[)').compile!
       }.to raise_error(Timeliness::Format::CompilationFailed)
     end
+
+    it 'should raise compilation error if token with captured arg is present more than once' do
+      expect { 
+        Timeliness::Format.new('dd-mm-yyyy-dd').compile!
+      }.to raise_error(Timeliness::Format::CompilationFailed)
+    end
   end
 
   describe "#process" do
@@ -73,8 +79,8 @@ describe Timeliness::Format do
       context "with I18n loaded" do
         before(:all) do
           I18n.locale = :es
-          I18n.backend.store_translations :es, :date => { :month_names => %w{ ~ Enero Febrero Marzo } }
-          I18n.backend.store_translations :es, :date => { :abbr_month_names => %w{ ~ Ene Feb Mar } }
+          I18n.backend.store_translations :es, date: { month_names: %w{ ~ Enero Febrero Marzo } }
+          I18n.backend.store_translations :es, date: { abbr_month_names: %w{ ~ Ene Feb Mar } }
         end
 
         it 'should parse abbreviated month for current locale to correct value' do

data/spec/timeliness/parser_spec.rb

@@ -138,7 +138,7 @@ describe Timeliness::Parser do
       it 'should return value using string zone adjusted to :zone option string timezone' do
         Timeliness.configuration.default_timezone = :local
 
-        value = parse("Thu, 01 Jun 2000 03:00:00 MST", :zone => 'Perth')
+        value = parse("Thu, 01 Jun 2000 03:00:00 MST", zone: 'Perth')
         expect(value).to eq Time.use_zone('Perth') { Time.zone.local(2000,6,1,18,0,0) }
         expect(value.utc_offset).to eq 8.hours
       end
@@ -196,7 +196,7 @@ 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 = parse("12:13:14", now: Time.local(2010,1,1))
         expect(time).to eq Time.local(2010,1,1,12,13,14)
       end
     end
@@ -211,23 +211,23 @@ describe Timeliness::Parser do
     context "with :zone option" 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 = parse("2000-06-01 12:13:14", :datetime, zone: :utc)
           expect(time.utc_offset).to eq 0
         end
 
         it 'should return nil for partial invalid time component' do
-          expect(parse("2000-06-01 12:60", :datetime, :zone => :utc)).to be_nil
+          expect(parse("2000-06-01 12:60", :datetime, zone: :utc)).to be_nil
         end
       end
 
       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 = parse("2000-06-01 12:13:14", :datetime, zone: :local)
           expect(time.utc_offset).to eq Time.mktime(2000, 6, 1, 12, 13, 14).utc_offset
         end
 
         it 'should return nil for partial invalid time component' do
-          expect(parse("2000-06-01 12:60", :datetime, :zone => :local)).to be_nil
+          expect(parse("2000-06-01 12:60", :datetime, zone: :local)).to be_nil
         end
       end
 
@@ -235,23 +235,23 @@ describe Timeliness::Parser do
         timezone_settings zone: 'Adelaide'
 
         it "should return time object in current timezone" do
-          time = parse("2000-06-01 12:13:14", :datetime, :zone => :current)
+          time = parse("2000-06-01 12:13:14", :datetime, zone: :current)
           expect(time.utc_offset).to eq 9.5.hours
         end
 
         it 'should return nil for partial invalid time component' do
-          expect(parse("2000-06-01 12:60", :datetime, :zone => :current)).to be_nil
+          expect(parse("2000-06-01 12:60", :datetime, zone: :current)).to be_nil
         end
       end
 
       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 = parse("2000-06-01 12:13:14", :datetime, zone: 'London')
           expect(time.utc_offset).to eq 1.hour
         end
 
         it 'should return nil for partial invalid time component' do
-          expect(parse("2000-06-01 12:60", :datetime, :zone => 'London')).to be_nil
+          expect(parse("2000-06-01 12:60", :datetime, zone: 'London')).to be_nil
         end
       end
 
@@ -259,17 +259,17 @@ describe Timeliness::Parser do
         it 'should output message' do
           expect {
             expect(Time).to receive(:zone).and_raise(NoMethodError.new("undefined method `zone' for Time:Class"))
-            parse("2000-06-01 12:13:14", :zone => :current)
+            parse("2000-06-01 12:13:14", zone: :current)
           }.to raise_error(Timeliness::Parser::MissingTimezoneSupport)
 
           expect {
             expect(Time).to receive(:current).and_raise(NoMethodError.new("undefined method `current' for Time:Class"))
-            parse("12:13:14", :zone => :current)
+            parse("12:13:14", zone: :current)
           }.to raise_error(Timeliness::Parser::MissingTimezoneSupport)
 
           expect {
             expect(Time).to receive(:use_zone).and_raise(NoMethodError.new("undefined method `use_zone' for Time:Class"))
-            parse("2000-06-01 12:13:14", :zone => 'London')
+            parse("2000-06-01 12:13:14", zone: 'London')
           }.to raise_error(Timeliness::Parser::MissingTimezoneSupport)
         end
       end
@@ -292,7 +292,7 @@ describe Timeliness::Parser do
 
       context "with :now option" do
         it 'should use date from :now' do
-          expect(parse('12:13:14', :time, :now => Time.local(2010, 6, 1))).to eq Time.local(2010,6,1,12,13,14)
+          expect(parse('12:13:14', :time, now: Time.local(2010, 6, 1))).to eq Time.local(2010,6,1,12,13,14)
         end
       end
 
@@ -304,7 +304,7 @@ describe Timeliness::Parser do
         end
 
         it "should use date from the specified zone" do
-          time = parse("12:13:14", :time, :zone => :utc)
+          time = parse("12:13:14", :time, zone: :utc)
           expect(time.year).to eq 2009
           expect(time.month).to eq 12
           expect(time.day).to eq 31
@@ -374,51 +374,51 @@ describe Timeliness::Parser do
       end
     end
 
-    context "with :strict => true" do
+    context "with strict: true" do
       it "should return nil from date string when type is datetime" do
-        time_array = parser._parse('2000-02-01', :datetime, :strict => true)
+        time_array = parser._parse('2000-02-01', :datetime, strict: true)
         expect(time_array).to be_nil
       end
 
       it "should return nil from datetime string when type is date" do
-        time_array = parser._parse('2000-02-01 12:13:14', :date, :strict => true)
+        time_array = parser._parse('2000-02-01 12:13:14', :date, strict: true)
         expect(time_array).to be_nil
       end
 
       it "should return nil from datetime string when type is time" do
-        time_array = parser._parse('2000-02-01 12:13:14', :time, :strict => true)
+        time_array = parser._parse('2000-02-01 12:13:14', :time, strict: true)
         expect(time_array).to be_nil
       end
 
       it "should parse date string when type is date" do
-        time_array = parser._parse('2000-02-01', :date, :strict => true)
+        time_array = parser._parse('2000-02-01', :date, strict: true)
         expect(time_array).not_to be_nil
       end
 
       it "should parse time string when type is time" do
-        time_array = parser._parse('12:13:14', :time, :strict => true)
+        time_array = parser._parse('12:13:14', :time, strict: true)
         expect(time_array).not_to be_nil
       end
 
       it "should parse datetime string when type is datetime" do
-        time_array = parser._parse('2000-02-01 12:13:14', :datetime, :strict => true)
+        time_array = parser._parse('2000-02-01 12:13:14', :datetime, strict: true)
         expect(time_array).not_to be_nil
       end
 
       it "should ignore strict parsing if no type specified" do
-        time_array = parser._parse('2000-02-01', :strict => true)
+        time_array = parser._parse('2000-02-01', strict: true)
         expect(time_array).not_to be_nil
       end
     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')
+        time_array = parser._parse('2000-02-01 12:13:14', :datetime, format: 'yyyy-mm-dd hh:nn:ss')
         expect(time_array).to eq [2000,2,1,12,13,14,nil,nil]
       end
 
       it "should return nil if string does not match specified format" do
-        time_array = parser._parse('2000-02-01 12:13', :datetime, :format => 'yyyy-mm-dd hh:nn:ss')
+        time_array = parser._parse('2000-02-01 12:13', :datetime, format: 'yyyy-mm-dd hh:nn:ss')
         expect(time_array).to be_nil
       end
     end
@@ -520,7 +520,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]
-        expect(current_date(:now => time)).to eq date_array
+        expect(current_date(now: time)).to eq date_array
       end
     end
 
@@ -528,26 +528,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]
-        expect(current_date(:zone => :utc)).to eq date_array
+        expect(current_date(zone: :utc)).to eq date_array
       end
 
       it 'should return date array for local zone' do
         time = Time.now
         date_array = [time.year, time.month, time.day]
-        expect(current_date(:zone => :local)).to eq date_array
+        expect(current_date(zone: :local)).to 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]
-        expect(current_date(:zone => :current)).to eq date_array
+        expect(current_date(zone: :current)).to 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]
-        expect(current_date(:zone => 'London')).to eq date_array
+        expect(current_date(zone: 'London')).to eq date_array
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timeliness
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Adam Meehan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-16 00:00:00.000000000 Z
+date: 2020-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport