uv-rays 2.0.4 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb2605b3097dbf2b0ef3c8c17df39580ce036185
-  data.tar.gz: 6983fdeea7d991cda8740e3076a98fc07d479630
+  metadata.gz: 90bfee69384f25d0c1ce287d91028996305ee511
+  data.tar.gz: a5d3f82c72d591fb56f54b0d92eade0768d042bb
 SHA512:
-  metadata.gz: 40556df7599e68cdbed13ffe47bddf74c5fee91fdb296b8f5468d6f881e44b0e5db7490b5a6f150ab90f2025beb2ccc1c754df281a2c58d5af54ecb09077f75b
-  data.tar.gz: 990adf1a8c5282b80ab3c93a19ea8785519e436add68136a68b8891bfe0e6e9cd7676bfe243df9429b47711bb44109c37ed4f8bbcb17bcb849a5ef02f2065dc7
+  metadata.gz: 6ce208199ef4a990628aa1d82b1b2f64186fe56aedb46c84991edba1b773cc95dce94086b12fd7ef058a432daf3b127ddec6b56361cbd3649b06af5f262e3717
+  data.tar.gz: 9851c7e265d84351307d60c29ba1e86f1dae9e0b36f4c44bc655e7afc15af74774f0f42b73decba188e9520f4fac4cbc6d15b69ceec00cd11ce575f5b9095a12

data/lib/uv-rays.rb

@@ -7,7 +7,6 @@ require 'libuv'
 require 'set'               # ruby std lib
 require 'bisect'            # insert into a sorted array
 require 'tzinfo'            # timezone information
-require 'uv-rays/scheduler/cron'
 require 'uv-rays/scheduler/time'
 require 'uv-rays/scheduler'
 

data/lib/uv-rays/scheduler.rb

@@ -32,15 +32,23 @@ module UV
 
         # Provide relevant inspect information
         def inspect
-            insp = String.new("#<#{self.class}:0x#{self.__id__.to_s(16)} ")
+            insp = String.new("#<#{self.class}:#{"0x00%x" % (self.__id__ << 1)} ")
             insp << "trigger_count=#{@trigger_count} "
             insp << "config=#{info} " if self.respond_to?(:info, true)
-            insp << "next_scheduled=#{@next_scheduled} "
-            insp << "last_scheduled=#{@last_scheduled} created=#{@created}>"
+            insp << "next_scheduled=#{to_time(@next_scheduled)} "
+            insp << "last_scheduled=#{to_time(@last_scheduled)} created=#{to_time(@created)}>"
             insp
         end
         alias_method :to_s, :inspect
 
+        def to_time(internal_time)
+            if internal_time
+                ((internal_time + @scheduler.time_diff) / 1000).to_i
+            else
+                internal_time
+            end
+        end
+
 
         # required for comparable
         def <=>(anOther)
@@ -100,8 +108,8 @@ module UV
         # Update the time period of the repeating event
         #
         # @param schedule [String] a standard CRON job line or a human readable string representing a time period.
-        def update(every)
-            time = Scheduler.parse_in(every, :quiet) || Scheduler.parse_cron(every, :quiet)
+        def update(every, timezone: nil)
+            time = Scheduler.parse_in(every, :quiet) || Scheduler.parse_cron(every, :quiet, timezone: timezone)
             raise ArgumentError.new("couldn't parse \"#{o}\"") if time.nil?
 
             @every = time
@@ -142,7 +150,7 @@ module UV
                 @next_scheduled = @last_scheduled + @every
             else
                 # must be a cron
-                @next_scheduled = (@every.next_time.to_f * 1000).to_i - @scheduler.time_diff
+                @next_scheduled = (@every.next.to_f * 1000).to_i - @scheduler.time_diff
             end
         end
 
@@ -154,7 +162,7 @@ module UV
         end
 
         def info
-            "repeat:#{@every}"
+            "repeat:#{@every.inspect}"
         end
     end
 
@@ -176,13 +184,19 @@ module UV
             # Not really required when used correctly
             @critical = Mutex.new
 
-            # as the libuv time is taken from an arbitrary point in time we
-            # need to roughly synchronize between it and ruby's Time.now
+            # Every hour we should re-calibrate this (just in case)
+            calibrate_time
+            every(3600000) { calibrate_time }
+        end
+
+
+        # As the libuv time is taken from an arbitrary point in time we
+        #  need to roughly synchronize between it and ruby's Time.now
+        def calibrate_time
             @reactor.update_time
             @time_diff = (Time.now.to_f * 1000).to_i - @reactor.now
         end
 
-
         # Create a repeating event that occurs each time period
         #
         # @param time [String] a human readable string representing the time period. 3w2d4h1m2s for example.
@@ -239,9 +253,9 @@ module UV
         # @param schedule [String] a standard CRON job line.
         # @param callback [Proc] a block or method to execute when the event triggers
         # @return [::UV::Repeat]
-        def cron(schedule, callback = nil, &block)
+        def cron(schedule, callback = nil, timezone: nil , &block)
             callback ||= block
-            ms = Scheduler.parse_cron(schedule)
+            ms = Scheduler.parse_cron(schedule, timezone: timezone)
             event = Repeat.new(self, ms)
 
             if callback.respond_to? :call

data/lib/uv-rays/scheduler/time.rb

@@ -24,10 +24,36 @@
 # Made in Japan.
 #++
 
+require 'parse-cron'
+
 
 module UV
     class Scheduler
 
+        # Thread safe timezone time class for use with parse-cron
+        class TimeInZone
+            def initialize(timezone)
+                @timezone = timezone
+            end
+
+            def now
+                time = nil
+                Time.use_zone(@timezone) do
+                    time = Time.now
+                end
+                time
+            end
+
+            def local(*args)
+                result = nil
+                Time.use_zone(@timezone) do
+                    result = Time.local(*args)
+                end
+                result
+            end
+        end
+
+
         def self.parse_in(o, quiet = false)
             # if o is an integer we are looking at ms
             o.is_a?(String) ? parse_duration(o, quiet) : o
@@ -60,8 +86,13 @@ module UV
             raise se
         end
 
-        def self.parse_cron(o, quiet = false)
-            CronLine.new(o)
+        def self.parse_cron(o, quiet = false, timezone: nil)
+            if timezone
+                tz = TimeInZone.new(timezone)
+                CronParser.new(o, tz)
+            else
+                CronParser.new(o)
+            end
 
         rescue ArgumentError => ae
             return nil if quiet
@@ -81,13 +112,13 @@ module UV
         end
 
         DURATIONS2M = [
-          [ 'y', 365 * 24 * 3600 * 1000 ],
-          [ 'M', 30 * 24 * 3600 * 1000 ],
-          [ 'w', 7 * 24 * 3600 * 1000 ],
-          [ 'd', 24 * 3600 * 1000 ],
-          [ 'h', 3600 * 1000 ],
-          [ 'm', 60 * 1000 ],
-          [ 's', 1000 ]
+            [ 'y', 365 * 24 * 3600 * 1000 ],
+            [ 'M', 30 * 24 * 3600 * 1000 ],
+            [ 'w', 7 * 24 * 3600 * 1000 ],
+            [ 'd', 24 * 3600 * 1000 ],
+            [ 'h', 3600 * 1000 ],
+            [ 'm', 60 * 1000 ],
+            [ 's', 1000 ]
         ]
         DURATIONS2 = DURATIONS2M.dup
         DURATIONS2.delete_at(1)

data/lib/uv-rays/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module UV
-    VERSION = '2.0.4'
+    VERSION = '2.1.0'
 end

data/spec/zen_spec.rb

@@ -0,0 +1,27 @@
+require 'libuv'
+require 'set'
+
+
+describe Libuv::Listener do
+	it "should ensure there are no remaining object references in callbacks", network: true do
+		require 'objspace'
+
+		checked = Set.new
+
+		# These are created by loop objects and are never cleaned up
+		# This is OK as the loops are expected to execute for the life of the application
+		except = []
+
+		ObjectSpace.each_object(Class) do |cls|
+			next unless cls.ancestors.include? ::UV::Connection
+			next if checked.include? cls
+			checked << cls
+		end
+
+		if checked.length > 0
+			puts "\nMemory Leak in #{checked.inspect}"
+		end
+
+		expect(checked.length).to be(0)
+	end
+end

data/uv-rays.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |gem|
     gem.add_runtime_dependency     'tzinfo', '~> 1.2'      # Ruby timezones info
     gem.add_runtime_dependency     'cookiejar', '~> 0.3'   # HTTP cookies
     gem.add_runtime_dependency     'ipaddress', '~> 0.8'   # IP address validation
+    gem.add_runtime_dependency     'parse-cron', '~> 0.1'  # CRON calculations
     gem.add_runtime_dependency     'addressable', '~> 2.4' # URI parser
     gem.add_runtime_dependency     'http-parser', '~> 1.2' # HTTP tokeniser
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uv-rays
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.1.0
 platform: ruby
 authors:
 - Stephen von Takach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-15 00:00:00.000000000 Z
+date: 2017-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libuv
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: parse-cron
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
@@ -199,7 +213,6 @@ files:
 - lib/uv-rays/http/request.rb
 - lib/uv-rays/http_endpoint.rb
 - lib/uv-rays/scheduler.rb
-- lib/uv-rays/scheduler/cron.rb
 - lib/uv-rays/scheduler/time.rb
 - lib/uv-rays/tcp_server.rb
 - lib/uv-rays/version.rb
@@ -207,9 +220,9 @@ files:
 - spec/buffered_tokenizer_spec.rb
 - spec/connection_spec.rb
 - spec/http_endpoint_spec.rb
-- spec/scheduler_cron_spec.rb
 - spec/scheduler_spec.rb
 - spec/scheduler_time_spec.rb
+- spec/zen_spec.rb
 - uv-rays.gemspec
 homepage: https://github.com/cotag/uv-rays
 licenses:
@@ -240,6 +253,6 @@ test_files:
 - spec/buffered_tokenizer_spec.rb
 - spec/connection_spec.rb
 - spec/http_endpoint_spec.rb
-- spec/scheduler_cron_spec.rb
 - spec/scheduler_spec.rb
 - spec/scheduler_time_spec.rb
+- spec/zen_spec.rb

data/lib/uv-rays/scheduler/cron.rb

@@ -1,389 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# Copyright (c) 2006-2013, John Mettraux, jmettraux@gmail.com
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# Made in Japan.
-#++
-
-
-module UV
-    class Scheduler
-        #
-        # A 'cron line' is a line in the sense of a crontab
-        # (man 5 crontab) file line.
-        #
-        class CronLine
-
-            # The string used for creating this cronline instance.
-            #
-            attr_reader :original
-
-            attr_reader :seconds
-            attr_reader :minutes
-            attr_reader :hours
-            attr_reader :days
-            attr_reader :months
-            attr_reader :weekdays
-            attr_reader :monthdays
-            attr_reader :timezone
-
-            def initialize(line)
-
-              raise ArgumentError.new(
-                "not a string: #{line.inspect}"
-              ) unless line.is_a?(String)
-
-              @original = line
-
-              items = line.split
-
-              @timezone = (TZInfo::Timezone.get(items.last) rescue nil)
-              items.pop if @timezone
-
-              raise ArgumentError.new(
-                "not a valid cronline : '#{line}'"
-              ) unless items.length == 5 or items.length == 6
-
-              offset = items.length - 5
-
-              @seconds = offset == 1 ? parse_item(items[0], 0, 59) : [ 0 ]
-              @minutes = parse_item(items[0 + offset], 0, 59)
-              @hours = parse_item(items[1 + offset], 0, 24)
-              @days = parse_item(items[2 + offset], 1, 31)
-              @months = parse_item(items[3 + offset], 1, 12)
-              @weekdays, @monthdays = parse_weekdays(items[4 + offset])
-
-              [ @seconds, @minutes, @hours, @months ].each do |es|
-
-                raise ArgumentError.new(
-                  "invalid cronline: '#{line}'"
-                ) if es && es.find { |e| ! e.is_a?(Integer) }
-              end
-            end
-
-            # Returns true if the given time matches this cron line.
-            #
-            def matches?(time)
-
-              time = Time.at(time) unless time.kind_of?(Time)
-
-              time = @timezone.utc_to_local(time.getutc) if @timezone
-
-              return false unless sub_match?(time, :sec, @seconds)
-              return false unless sub_match?(time, :min, @minutes)
-              return false unless sub_match?(time, :hour, @hours)
-              return false unless date_match?(time)
-              true
-            end
-
-            # Returns the next time that this cron line is supposed to 'fire'
-            #
-            # This is raw, 3 secs to iterate over 1 year on my macbook :( brutal.
-            # (Well, I was wrong, takes 0.001 sec on 1.8.7 and 1.9.1)
-            #
-            # This method accepts an optional Time parameter. It's the starting point
-            # for the 'search'. By default, it's Time.now
-            #
-            # Note that the time instance returned will be in the same time zone that
-            # the given start point Time (thus a result in the local time zone will
-            # be passed if no start time is specified (search start time set to
-            # Time.now))
-            #
-            #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
-            #     Time.mktime(2008, 10, 24, 7, 29))
-            #   #=> Fri Oct 24 07:30:00 -0500 2008
-            #
-            #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
-            #     Time.utc(2008, 10, 24, 7, 29))
-            #   #=> Fri Oct 24 07:30:00 UTC 2008
-            #
-            #   Rufus::Scheduler::CronLine.new('30 7 * * *').next_time(
-            #     Time.utc(2008, 10, 24, 7, 29)).localtime
-            #   #=> Fri Oct 24 02:30:00 -0500 2008
-            #
-            # (Thanks to K Liu for the note and the examples)
-            #
-            def next_time(from=Time.now)
-
-              time = @timezone ? @timezone.utc_to_local(from.getutc) : from
-
-              time = time.round
-              # chop off subseconds
-
-              time = time + 1
-              # start at the next second
-
-              loop do
-
-                unless date_match?(time)
-                  time += (24 - time.hour) * 3600 - time.min * 60 - time.sec; next
-                end
-                unless sub_match?(time, :hour, @hours)
-                  time += (60 - time.min) * 60 - time.sec; next
-                end
-                unless sub_match?(time, :min, @minutes)
-                  time += 60 - time.sec; next
-                end
-                unless sub_match?(time, :sec, @seconds)
-                  time += 1; next
-                end
-
-                break
-              end
-
-              if @timezone
-                time = @timezone.local_to_utc(time)
-                time = time.getlocal unless from.utc?
-              end
-
-              time
-            end
-
-            # Returns the previous the cronline matched. It's like next_time, but
-            # for the past.
-            #
-            def previous_time(from=Time.now)
-
-              # looks back by slices of two hours,
-              #
-              # finds for '* * * * sun', '* * 13 * *' and '0 12 13 * *'
-              # starting 1970, 1, 1 in 1.8 to 2 seconds (says Rspec)
-
-              start = current = from - 2 * 3600
-              result = nil
-
-              loop do
-                nex = next_time(current)
-                return (result ? result : previous_time(start)) if nex > from
-                result = current = nex
-              end
-
-              # never reached
-            end
-
-            # Returns an array of 6 arrays (seconds, minutes, hours, days,
-            # months, weekdays).
-            # This method is used by the cronline unit tests.
-            #
-            def to_array
-
-              [
-                @seconds,
-                @minutes,
-                @hours,
-                @days,
-                @months,
-                @weekdays,
-                @monthdays,
-                @timezone ? @timezone.name : nil
-              ]
-            end
-
-            # Returns the shortest delta between two potential occurrences of the
-            # schedule described by this cronline.
-            #
-            def frequency
-
-              delta = 366 * DAY_S
-
-              t0 = previous_time(Time.local(2000, 1, 1))
-
-              loop do
-
-                break if delta <= 1
-                break if delta <= 60 && @seconds && @seconds.size == 1
-
-                t1 = next_time(t0)
-                d = t1 - t0
-                delta = d if d < delta
-
-                break if @months == nil && t1.month == 2
-                break if t1.year == 2001
-
-                t0 = t1
-              end
-
-              delta
-            end
-
-            protected
-
-            WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
-            DAY_S = 24 * 3600
-            WEEK_S = 7 * DAY_S
-
-            def parse_weekdays(item)
-
-              return nil if item == '*'
-
-              items = item.downcase.split(',')
-
-              weekdays = nil
-              monthdays = nil
-
-              items.each do |it|
-
-                if m = it.match(/^(.+)#(l|-?[12345])$/)
-
-                  raise ArgumentError.new(
-                    "ranges are not supported for monthdays (#{it})"
-                  ) if m[1].index('-')
-
-                  expr = it.gsub(/#l/, '#-1')
-
-                  (monthdays ||= []) << expr
-
-                else
-
-                  expr = it.dup
-                  WEEKDAYS.each_with_index { |a, i| expr.gsub!(/#{a}/, i.to_s) }
-
-                  raise ArgumentError.new(
-                    "invalid weekday expression (#{it})"
-                  ) if expr !~ /^0*[0-7](-0*[0-7])?$/
-
-                  its = expr.index('-') ? parse_range(expr, 0, 7) : [ Integer(expr) ]
-                  its = its.collect { |i| i == 7 ? 0 : i }
-
-                  (weekdays ||= []).concat(its)
-                end
-              end
-
-              weekdays = weekdays.uniq.sort if weekdays
-
-              [ weekdays, monthdays ]
-            end
-
-            def parse_item(item, min, max)
-
-              return nil if item == '*'
-
-              r = item.split(',').map { |i| parse_range(i.strip, min, max) }.flatten
-
-              raise ArgumentError.new(
-                "found duplicates in #{item.inspect}"
-              ) if r.uniq.size < r.size
-
-              r = r.sort_by { |e| e.is_a?(String) ? 61 : e.to_i }
-              r
-            end
-
-            RANGE_REGEX = /^(\*|\d{1,2})(?:-(\d{1,2}))?(?:\/(\d{1,2}))?$/
-
-            def parse_range(item, min, max)
-
-              return %w[ L ] if item == 'L'
-
-              item = '*' + item if item.match(/^\//)
-
-              m = item.match(RANGE_REGEX)
-
-              raise ArgumentError.new(
-                "cannot parse #{item.inspect}"
-              ) unless m
-
-              sta = m[1]
-              sta = sta == '*' ? min : sta.to_i
-
-              edn = m[2]
-              edn = edn ? edn.to_i : sta
-              edn = max if m[1] == '*'
-
-              inc = m[3]
-              inc = inc ? inc.to_i : 1
-
-              raise ArgumentError.new(
-                "#{item.inspect} is not in range #{min}..#{max}"
-              ) if sta < min || edn > max
-
-              r = []
-              val = sta
-
-              loop do
-                v = val
-                v = 0 if max == 24 && v == 24
-                r << v
-                break if inc == 1 && val == edn
-                val += inc
-                break if inc > 1 && val > edn
-                val = min if val > max
-              end
-
-              r.uniq
-            end
-
-            def sub_match?(time, accessor, values)
-
-              value = time.send(accessor)
-
-              return true if values.nil?
-              return true if values.include?('L') && (time + DAY_S).day == 1
-
-              return true if value == 0 && accessor == :hour && values.include?(24)
-
-              values.include?(value)
-            end
-
-            def monthday_match?(date, values)
-
-              return true if values.nil?
-
-              today_values = monthdays(date)
-
-              (today_values & values).any?
-            end
-
-            def date_match?(date)
-
-              return false unless sub_match?(date, :day, @days)
-              return false unless sub_match?(date, :month, @months)
-              return false unless sub_match?(date, :wday, @weekdays)
-              return false unless monthday_match?(date, @monthdays)
-              true
-            end
-
-            def monthdays(date)
-
-              pos = 1
-              d = date.dup
-
-              loop do
-                d = d - WEEK_S
-                break if d.month != date.month
-                pos = pos + 1
-              end
-
-              neg = -1
-              d = date.dup
-
-              loop do
-                d = d + WEEK_S
-                break if d.month != date.month
-                neg = neg - 1
-              end
-
-              [ "#{WEEKDAYS[date.wday]}##{pos}", "#{WEEKDAYS[date.wday]}##{neg}" ]
-            end
-        end
-    end
-end
-

data/spec/scheduler_cron_spec.rb

@@ -1,440 +0,0 @@
-require 'uv-rays'
-
-describe UV::Scheduler::CronLine do
-
-    def cl(cronline_string)
-        UV::Scheduler::CronLine.new(cronline_string)
-    end
-
-    def match(line, time)
-        expect(cl(line).matches?(time)).to eq(true)
-    end
-    def no_match(line, time)
-        expect(cl(line).matches?(time)).to eq(false)
-    end
-    def to_a(line, array)
-        expect(cl(line).to_array).to eq(array)
-    end
-    def local(*args)
-        Time.local(*args)
-    end
-    alias lo local
-
-    def utc(*args)
-        Time.utc(*args)
-    end
-
-    describe '.new' do
-
-        it 'interprets cron strings correctly' do
-
-            to_a '* * * * *',       [ [0], nil, nil, nil, nil, nil, nil, nil ]
-            to_a '10-12 * * * *', [ [0], [10, 11, 12], nil, nil, nil, nil, nil, nil ]
-            to_a '* * * * sun,mon', [ [0], nil, nil, nil, nil, [0, 1], nil, nil ]
-            to_a '* * * * mon-wed', [ [0], nil, nil, nil, nil, [1, 2, 3], nil, nil ]
-            to_a '* * * * 7', [ [0], nil, nil, nil, nil, [0], nil, nil ]
-            to_a '* * * * 0', [ [0], nil, nil, nil, nil, [0], nil, nil ]
-            to_a '* * * * 0,1', [ [0], nil, nil, nil, nil, [0,1], nil, nil ]
-            to_a '* * * * 7,1', [ [0], nil, nil, nil, nil, [0,1], nil, nil ]
-            to_a '* * * * 7,0', [ [0], nil, nil, nil, nil, [0], nil, nil ]
-            to_a '* * * * sun,2-4', [ [0], nil, nil, nil, nil, [0, 2, 3, 4], nil, nil ]
-
-            to_a '* * * * sun,mon-tue', [ [0], nil, nil, nil, nil, [0, 1, 2], nil, nil ]
-            to_a '0 0 * * mon#1,tue', [[0], [0], [0], nil, nil, [2], ["mon#1"], nil]
-
-            to_a '* * * * * *', [ nil, nil, nil, nil, nil, nil, nil, nil ]
-            to_a '1 * * * * *', [ [1], nil, nil, nil, nil, nil, nil, nil ]
-            to_a '7 10-12 * * * *', [ [7], [10, 11, 12], nil, nil, nil, nil, nil, nil ]
-            to_a '1-5 * * * * *', [ [1,2,3,4,5], nil, nil, nil, nil, nil, nil, nil ]
-
-            to_a '0 0 1 1 *', [ [0], [0], [0], [1], [1], nil, nil, nil ]
-
-            to_a '52 0 * * *', [ [0], [52], [0], nil, nil, nil, nil, nil ]
-
-            to_a '0 16 * * *', [ [0], [0], [16], nil, nil, nil, nil, nil ]
-
-            to_a '0 23-24 * * *', [ [0], [0], [0, 23], nil, nil, nil, nil, nil ]
-
-            to_a '0 23-2 * * *', [ [0], [0], [0, 1, 2, 23], nil, nil, nil, nil, nil ]
-
-            # modulo forms work for five-field forms
-            to_a '*/17 * * * *', [[0], [0, 17, 34, 51], nil, nil, nil, nil, nil, nil]
-            to_a '13 */17 * * *', [[0], [13], [0, 17], nil, nil, nil, nil, nil]
-
-            # modulo forms work for six-field forms
-            to_a '*/17 * * * * *', [[0, 17, 34, 51], nil, nil, nil, nil, nil, nil, nil]
-            to_a '13 */17 * * * *', [[13], [0, 17, 34, 51], nil, nil, nil, nil, nil, nil]
-
-        end
-
-        it 'rejects invalid weekday expressions' do
-
-            expect  { cl '0 17 * * MON_FRI' }.to raise_error(ArgumentError)
-                # underline instead of dash
-
-            expect  { cl '* * * * 9' }.to raise_error(ArgumentError)
-            expect  { cl '* * * * 0-12' }.to raise_error(ArgumentError)
-            expect  { cl '* * * * BLABLA' }.to raise_error(ArgumentError)
-        end
-
-        it 'rejects invalid cronlines' do
-
-            expect  { cl '* nada * * 9' }.to raise_error(ArgumentError)
-        end
-
-        it 'interprets cron strings with TZ correctly' do
-
-            to_a('* * * * * EST', [ [0], nil, nil, nil, nil, nil, nil, 'EST' ])
-            to_a('* * * * * * EST', [ nil, nil, nil, nil, nil, nil, nil, 'EST' ])
-
-            to_a(
-                '* * * * * * America/Chicago',
-                [ nil, nil, nil, nil, nil, nil, nil, 'America/Chicago' ])
-            to_a(
-                '* * * * * * America/New_York',
-                [ nil, nil, nil, nil, nil, nil, nil, 'America/New_York' ])
-
-            expect  { cl '* * * * * NotATimeZone' }.to raise_error(ArgumentError)
-            expect  { cl '* * * * * * NotATimeZone' }.to raise_error(ArgumentError)
-        end
-
-        it 'interprets cron strings with / (slashes) correctly' do
-
-            to_a(
-                '0 */2 * * *',
-                [ [0], [0], (0..11).collect { |e| e * 2 }, nil, nil, nil, nil, nil ])
-            to_a(
-                '0 7-23/2 * * *',
-                [ [0], [0], (7..23).select { |e| e.odd? }, nil, nil, nil, nil, nil ])
-            to_a(
-                '*/10 * * * *',
-                [ [0], [0, 10, 20, 30, 40, 50], nil, nil, nil, nil, nil, nil ])
-
-            # fighting https://github.com/jmettraux/rufus-scheduler/issues/65
-            #
-            to_a(
-                '*/10 * * * * Europe/Berlin',
-                [ [0], [ 0, 10, 20, 30, 40, 50], nil, nil, nil, nil, nil, 'Europe/Berlin' ])
-        end
-
-        it 'accepts lonely / (slashes) (like <= 2.0.19 did)' do
-
-            # fighting https://github.com/jmettraux/rufus-scheduler/issues/65
-
-            to_a(
-                '/10 * * * *',
-                [ [0], [ 0, 10, 20, 30, 40, 50], nil, nil, nil, nil, nil, nil ])
-        end
-
-        it 'does not support ranges for monthdays (sun#1-sun#2)' do
-
-            expect {
-                UV::Scheduler::CronLine.new('* * * * sun#1-sun#2')
-            }.to raise_error(ArgumentError)
-        end
-
-        it 'accepts items with initial 0' do
-
-            to_a '09 * * * *', [ [0], [9], nil, nil, nil, nil, nil, nil ]
-            to_a '09-12 * * * *', [ [0], [9, 10, 11, 12], nil, nil, nil, nil, nil, nil ]
-            to_a '07-08 * * * *', [ [0], [7, 8], nil, nil, nil, nil, nil, nil ]
-            to_a '* */08 * * *', [ [0], nil, [0, 8, 16], nil, nil, nil, nil, nil ]
-            to_a '* */07 * * *', [ [0], nil, [0, 7, 14, 21], nil, nil, nil, nil, nil ]
-            to_a '* 01-09/04 * * *', [ [0], nil, [1, 5, 9], nil, nil, nil, nil, nil ]
-            to_a '* * * * 06', [ [0], nil, nil, nil, nil, [6], nil, nil ]
-        end
-
-        it 'interprets cron strings with L correctly' do
-
-            to_a '* * L * *', [[0], nil, nil, ['L'], nil, nil, nil, nil ]
-            to_a '* * 2-5,L * *', [[0], nil, nil, [2,3,4,5,'L'], nil, nil, nil, nil ]
-            to_a '* * */8,L * *', [[0], nil, nil, [1,9,17,25,'L'], nil, nil, nil, nil ]
-        end
-
-        it 'does not support ranges for L' do
-
-            expect  { cl '* * 15-L * *'}.to raise_error(ArgumentError)
-            expect  { cl '* * L/4 * *'}.to raise_error(ArgumentError)
-        end
-
-        it 'does not support multiple Ls' do
-
-            expect  { cl '* * L,L * *'}.to raise_error(ArgumentError)
-        end
-
-        it 'raises if L is used for something else than days' do
-
-            expect  { cl '* L * * *'}.to raise_error(ArgumentError)
-        end
-
-        it 'raises for out of range input' do
-
-            expect  { cl '60-62 * * * *'}.to raise_error(ArgumentError)
-            expect  { cl '62 * * * *'}.to raise_error(ArgumentError)
-            expect  { cl '60 * * * *'}.to raise_error(ArgumentError)
-            expect  { cl '* 25-26 * * *'}.to raise_error(ArgumentError)
-            expect  { cl '* 25 * * *'}.to raise_error(ArgumentError)
-                #
-                # as reported by Aimee Rose in
-                # https://github.com/jmettraux/rufus-scheduler/pull/58
-        end
-    end
-
-    describe '#next_time' do
-
-        def nt(cronline, now)
-            UV::Scheduler::CronLine.new(cronline).next_time(now)
-        end
-
-        it 'computes the next occurence correctly' do
-
-            now = Time.at(0).getutc # Thu Jan 01 00:00:00 UTC 1970
-
-            expect(nt('* * * * *', now)).to eq(now + 60)
-            expect(nt('* * * * sun', now)).to eq(now + 259200)
-            expect(nt('* * * * * *', now)).to eq(now + 1)
-            expect(nt('* * 13 * fri', now)).to eq(now + 3715200)
-
-            expect(nt('10 12 13 12 *', now)).to eq(now + 29938200)
-                # this one is slow (1 year == 3 seconds)
-                #
-                # historical note:
-                # (comment made in 2006 or 2007, the underlying libs got better and
-                # that slowness is gone)
-
-            expect(nt('0 0 * * thu', now)).to eq(now + 604800)
-            expect(nt('00 0 * * thu', now)).to eq(now + 604800)
-
-            expect(nt('0 0 * * *', now)).to eq(now + 24 * 3600)
-            expect(nt('0 24 * * *', now)).to eq(now + 24 * 3600)
-
-            now = local(2008, 12, 31, 23, 59, 59, 0)
-
-            expect(nt('* * * * *', now)).to eq(now + 1)
-        end
-
-        it 'computes the next occurence correctly in UTC (TZ not specified)' do
-
-            now = utc(1970, 1, 1)
-
-            expect(nt('* * * * *', now)).to eq(utc(1970, 1, 1, 0, 1))
-            expect(nt('* * * * sun', now)).to eq(utc(1970, 1, 4))
-            expect(nt('* * * * * *', now)).to eq(utc(1970, 1, 1, 0, 0, 1))
-            expect(nt('* * 13 * fri', now)).to eq(utc(1970, 2, 13))
-
-            expect(nt('10 12 13 12 *', now)).to eq(utc(1970, 12, 13, 12, 10))
-                # this one is slow (1 year == 3 seconds)
-            expect(nt('* * 1 6 *', now)).to eq(utc(1970, 6, 1))
-
-            expect(nt('0 0 * * thu', now)).to eq(utc(1970, 1, 8))
-        end
-
-        it 'computes the next occurence correctly in local TZ (TZ not specified)' do
-
-            now = local(1970, 1, 1)
-
-            expect(nt('* * * * *', now)).to eq(local(1970, 1, 1, 0, 1))
-            expect(nt('* * * * sun', now)).to eq(local(1970, 1, 4))
-            expect(nt('* * * * * *', now)).to eq(local(1970, 1, 1, 0, 0, 1))
-            expect(nt('* * 13 * fri', now)).to eq(local(1970, 2, 13))
-
-            expect(nt('10 12 13 12 *', now)).to eq(local(1970, 12, 13, 12, 10))
-                # this one is slow (1 year == 3 seconds)
-            expect(nt('* * 1 6 *', now)).to eq(local(1970, 6, 1))
-
-            expect(nt('0 0 * * thu', now)).to eq(local(1970, 1, 8))
-        end
-
-        it 'computes the next occurence correctly in UTC (TZ specified)' do
-
-            zone = 'Europe/Stockholm'
-            tz = TZInfo::Timezone.get(zone)
-            now = tz.local_to_utc(local(1970, 1, 1))
-                # Midnight in zone, UTC
-
-            expect(nt("* * * * * #{zone}", now)).to eq(utc(1969, 12, 31, 23, 1))
-            expect(nt("* * * * sun #{zone}", now)).to eq(utc(1970, 1, 3, 23))
-            expect(nt("* * * * * * #{zone}", now)).to eq(utc(1969, 12, 31, 23, 0, 1))
-            expect(nt("* * 13 * fri #{zone}", now)).to eq(utc(1970, 2, 12, 23))
-
-            expect(nt("10 12 13 12 * #{zone}", now)).to eq(utc(1970, 12, 13, 11, 10))
-            expect(nt("* * 1 6 * #{zone}", now)).to eq(utc(1970, 5, 31, 23))
-
-            expect(nt("0 0 * * thu #{zone}", now)).to eq(utc(1970, 1, 7, 23))
-        end
-
-        #it 'computes the next occurence correctly in local TZ (TZ specified)' do
-        #    zone = 'Europe/Stockholm'
-        #    tz = TZInfo::Timezone.get(zone)
-        #    now = tz.local_to_utc(utc(1970, 1, 1)).localtime
-        #        # Midnight in zone, local time
-        #    expect(nt("* * * * * #{zone}", now)).to eq(local(1969, 12, 31, 18, 1))
-        #    expect(nt("* * * * sun #{zone}", now)).to eq(local(1970, 1, 3, 18))
-        #    expect(nt("* * * * * * #{zone}", now)).to eq(local(1969, 12, 31, 18, 0, 1))
-        #    expect(nt("* * 13 * fri #{zone}", now)).to eq(local(1970, 2, 12, 18))
-        #    expect(nt("10 12 13 12 * #{zone}", now)).to eq(local(1970, 12, 13, 6, 10))
-        #    expect(nt("* * 1 6 * #{zone}", now)).to eq(local(1970, 5, 31, 19))
-        #    expect(nt("0 0 * * thu #{zone}", now)).to eq(local(1970, 1, 7, 18))
-        #end
-
-        it 'computes the next time correctly when there is a sun#2 involved' do
-
-            expect(nt('* * * * sun#1', local(1970, 1, 1))).to eq(local(1970, 1, 4))
-            expect(nt('* * * * sun#2', local(1970, 1, 1))).to eq(local(1970, 1, 11))
-
-            expect(nt('* * * * sun#2', local(1970, 1, 12))).to eq(local(1970, 2, 8))
-        end
-
-        it 'computes the next time correctly when there is a sun#2,sun#3 involved' do
-
-            expect(nt('* * * * sun#2,sun#3', local(1970, 1, 1))).to eq(local(1970, 1, 11))
-            expect(nt('* * * * sun#2,sun#3', local(1970, 1, 12))).to eq(local(1970, 1, 18))
-        end
-
-        it 'understands sun#L' do
-
-            expect(nt('* * * * sun#L', local(1970, 1, 1))).to eq(local(1970, 1, 25))
-        end
-
-        it 'understands sun#-1' do
-
-            expect(nt('* * * * sun#-1', local(1970, 1, 1))).to eq(local(1970, 1, 25))
-        end
-
-        it 'understands sun#-2' do
-
-            expect(nt('* * * * sun#-2', local(1970, 1, 1))).to eq(local(1970, 1, 18))
-        end
-
-        it 'computes the next time correctly when "L" (last day of month)' do
-
-            expect(nt('* * L * *', lo(1970, 1, 1))).to eq(lo(1970, 1, 31))
-            expect(nt('* * L * *', lo(1970, 2, 1))).to eq(lo(1970, 2, 28))
-            expect(nt('* * L * *', lo(1972, 2, 1))).to eq(lo(1972, 2, 29))
-            expect(nt('* * L * *', lo(1970, 4, 1))).to eq(lo(1970, 4, 30))
-        end
-
-        it 'returns a time with subseconds chopped off' do
-
-            expect(nt('* * * * *', Time.now).usec).to eq(0)
-            expect(nt('* * * * *', Time.now).iso8601(10).match(/\.0+[^\d]/)).not_to eq(nil)
-        end
-    end
-
-    describe '#previous_time' do
-
-        def pt(cronline, now)
-            UV::Scheduler::CronLine.new(cronline).previous_time(now)
-        end
-
-        it 'returns the previous time the cron should have triggered' do
-
-            expect(pt('* * * * sun', lo(1970, 1, 1))).to eq(lo(1969, 12, 28, 23, 59, 00))
-            expect(pt('* * 13 * *', lo(1970, 1, 1))).to eq(lo(1969, 12, 13, 23, 59, 00))
-            expect(pt('0 12 13 * *', lo(1970, 1, 1))).to eq(lo(1969, 12, 13, 12, 00))
-
-            expect(pt('* * * * * sun', lo(1970, 1, 1))).to eq(lo(1969, 12, 28, 23, 59, 59))
-        end
-    end
-
-    describe '#matches?' do
-
-        it 'matches correctly in UTC (TZ not specified)' do
-
-            match '* * * * *', utc(1970, 1, 1, 0, 1)
-            match '* * * * sun', utc(1970, 1, 4)
-            match '* * * * * *', utc(1970, 1, 1, 0, 0, 1)
-            match '* * 13 * fri', utc(1970, 2, 13)
-
-            match '10 12 13 12 *', utc(1970, 12, 13, 12, 10)
-            match '* * 1 6 *', utc(1970, 6, 1)
-
-            match '0 0 * * thu', utc(1970, 1, 8)
-
-            match '0 0 1 1 *', utc(2012, 1, 1)
-            no_match '0 0 1 1 *', utc(2012, 1, 1, 1, 0)
-        end
-
-        it 'matches correctly in local TZ (TZ not specified)' do
-
-            match '* * * * *', local(1970, 1, 1, 0, 1)
-            match '* * * * sun', local(1970, 1, 4)
-            match '* * * * * *', local(1970, 1, 1, 0, 0, 1)
-            match '* * 13 * fri', local(1970, 2, 13)
-
-            match '10 12 13 12 *', local(1970, 12, 13, 12, 10)
-            match '* * 1 6 *', local(1970, 6, 1)
-
-            match '0 0 * * thu', local(1970, 1, 8)
-
-            match '0 0 1 1 *', local(2012, 1, 1)
-            no_match '0 0 1 1 *', local(2012, 1, 1, 1, 0)
-        end
-
-        it 'matches correctly in UTC (TZ specified)' do
-
-            zone = 'Europe/Stockholm'
-
-            match "* * * * * #{zone}", utc(1969, 12, 31, 23, 1)
-            match "* * * * sun #{zone}", utc(1970, 1, 3, 23)
-            match "* * * * * * #{zone}", utc(1969, 12, 31, 23, 0, 1)
-            match "* * 13 * fri #{zone}", utc(1970, 2, 12, 23)
-
-            match "10 12 13 12 * #{zone}", utc(1970, 12, 13, 11, 10)
-            match "* * 1 6 * #{zone}", utc(1970, 5, 31, 23)
-
-            match "0 0 * * thu #{zone}", utc(1970, 1, 7, 23)
-        end
-
-        it 'matches correctly when there is a sun#2 involved' do
-
-            match '* * 13 * fri#2', utc(1970, 2, 13)
-            no_match '* * 13 * fri#2', utc(1970, 2, 20)
-        end
-
-        it 'matches correctly when there is a L involved' do
-
-            match '* * L * *', utc(1970, 1, 31)
-            no_match '* * L * *', utc(1970, 1, 30)
-        end
-
-        it 'matches correctly when there is a sun#2,sun#3 involved' do
-
-            no_match '* * * * sun#2,sun#3', local(1970, 1, 4)
-            match '* * * * sun#2,sun#3', local(1970, 1, 11)
-            match '* * * * sun#2,sun#3', local(1970, 1, 18)
-            no_match '* * * * sun#2,sun#3', local(1970, 1, 25)
-        end
-    end
-
-    describe '#monthdays' do
-
-        it 'returns the appropriate "sun#2"-like string' do
-
-            class UV::Scheduler::CronLine
-                public :monthdays
-            end
-
-            cl = UV::Scheduler::CronLine.new('* * * * *')
-
-            expect(cl.monthdays(local(1970, 1, 1))).to eq(%w[ thu#1 thu#-5 ])
-            expect(cl.monthdays(local(1970, 1, 7))).to eq(%w[ wed#1 wed#-4 ])
-            expect(cl.monthdays(local(1970, 1, 14))).to eq(%w[ wed#2 wed#-3 ])
-
-            expect(cl.monthdays(local(2011, 3, 11))).to eq(%w[ fri#2 fri#-3 ])
-        end
-    end
-
-    describe '#frequency' do
-
-        it 'returns the shortest delta between two occurrences' do
-
-            expect(UV::Scheduler::CronLine.new('* * * * *').frequency).to eq(60)
-            expect(UV::Scheduler::CronLine.new('* * * * * *').frequency).to eq(1)
-
-            expect(UV::Scheduler::CronLine.new('5 23 * * *').frequency).to eq(24 * 3600)
-            expect(UV::Scheduler::CronLine.new('5 * * * *').frequency).to eq(3600)
-            expect(UV::Scheduler::CronLine.new('10,20,30 * * * *').frequency).to eq(600)
-        end
-    end
-end