whedon 0.0.0 → 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle/
+*.gem
+Gemfile.lock
+pkg/
+coverage/
+*.swp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in whedon.gemspec
+gemspec

data/README.md

@@ -0,0 +1,28 @@
+# whedon - parse crontab syntax
+
+The goal of this gem is to parse a crontab timing specification and produce an
+object that can be queried about the schedule.
+
+This gem began as an extraction of Rufus::CronLine from the rufus-schedule gem.
+
+## API example
+
+```
+sch = Whedon::Schedule.new('30 * * * *')
+
+# Most Recent
+sch.last
+
+# Upcoming
+sch.next
+
+# Next after date/time argument
+sch.next("2020/07/01")
+
+# Given date/time matches cron string
+sch.matches?("2020/07/01 14:00:00")
+
+# Give cron string represented as an array
+# [seconds minutes hours days months weekdays monthdays timezone]
+sch.to_a
+```

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec
+
+desc 'Start IRB with preloaded environment'
+task :console do
+  exec 'irb', "-I#{File.join(File.dirname(__FILE__), 'lib')}", '-rwhedon'
+end

data/lib/whedon/schedule.rb

@@ -0,0 +1,374 @@
+#--
+# 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.
+#++
+
+require 'tzinfo'
+
+
+module Whedon
+
+  #
+  # A 'cron line' is a line in the sense of a crontab
+  # (man 5 crontab) file line.
+  #
+  class Schedule
+
+    DAY_S = 24 * 3600
+    WEEK_S = 7 * DAY_S
+
+    # 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
+
+    attr_accessor :raise_error_on_duplicate
+
+    def initialize(line)
+
+      super()
+
+      @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?(Fixnum) }
+      end
+    end
+
+    # Returns true if the given time matches this cron line.
+    #
+    def matches?(time)
+
+      time = as_time(time)
+
+      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
+
+    def now?(time=Time.now)
+      matches?(time)
+    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))
+    #
+    #   Whedon::CronLine.new('30 7 * * *').next_time(
+    #     Time.mktime(2008, 10, 24, 7, 29))
+    #   #=> Fri Oct 24 07:30:00 -0500 2008
+    #
+    #   Whedon::CronLine.new('30 7 * * *').next_time(
+    #     Time.utc(2008, 10, 24, 7, 29))
+    #   #=> Fri Oct 24 07:30:00 UTC 2008
+    #
+    #   Whedon::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(now=Time.now)
+
+      time = as_time(now)
+      time = time - time.usec * 1e-6 + 1
+        # small adjustment before starting
+
+      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 now.utc?
+      end
+
+      time
+    end
+    alias_method :next, :next_time
+
+    # Returns the previous the cronline matched. It's like next_time, but
+    # for the past.
+    #
+    def previous_time(now=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 = now - 2 * 3600
+      result = nil
+
+      loop do
+        nex = next_time(current)
+        return (result ? result : previous_time(start)) if nex > now
+        result = current = nex
+      end
+
+      # never reached
+    end
+    alias_method :previous, :previous_time
+    alias_method :last,     :previous_time
+
+    # 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
+    alias_method :to_a, :to_array
+
+    private
+
+    WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
+
+    def raise_error_on_duplicate?
+      !!(raise_error_on_duplicate)
+    end
+
+    def as_time(time)
+      unless time.kind_of?(Time)
+        time = ( time.to_s =~ /^\d+$/ ) ?
+          Time.at(time.to_s) : Time.parse(time.to_s)
+      end
+
+      time = @timezone.utc_to_local(time.getutc) if @timezone
+      time
+    end
+
+    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 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 raise_error_on_duplicate? && r.uniq.size < r.size
+
+      r.uniq
+    end
+
+    RANGE_REGEX = /^(\*|\d{1,2})(?:-(\d{1,2}))?(?:\/(\d{1,2}))?$/
+
+    def parse_range(item, min, max)
+
+      return %w[ L ] if item == 'L'
+
+      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 or 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

data/lib/whedon/version.rb

@@ -0,0 +1,5 @@
+module Parse
+  module Cron
+    VERSION = "0.0.1"
+  end
+end

data/lib/whedon.rb

@@ -0,0 +1,2 @@
+require 'whedon/version'
+require 'whedon/schedule'

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require File.expand_path("../../lib/whedon", __FILE__)
+
+class Ex < Whedon::Schedule
+  def initialize(line)
+    self.raise_error_on_duplicate = true
+    super(line)
+  end
+end
+
+def local(*args)
+  Time.local(*args)
+end
+alias lo local
+
+def utc(*args)
+  Time.utc(*args)
+end
+
+def cl(line)
+  Whedon::Schedule.new(line)
+end
+
+def compare(line, array)
+  cl(line).to_array.should == array
+end

data/spec/whedon/schedule_spec.rb

@@ -0,0 +1,383 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Sat Mar 21 12:55:27 JST 2009
+#
+
+#require 'spec_base'
+require "spec_helper"
+require "whedon/schedule"
+
+describe Whedon::Schedule do
+  #
+  # See spec_helper.rb for definitions for the class & methods
+  # used in these tests. This includes Ex, local, utc, cl,
+  # match, no_match, and compare
+
+  describe '.new' do
+
+    it 'interprets cron strings correctly' do
+
+      compare '* * * * *', [ [0], nil, nil, nil, nil, nil, nil, nil ]
+      compare '10-12 * * * *', [ [0], [10, 11, 12], nil, nil,  nil, nil, nil, nil ]
+      compare '* * * * sun,mon', [ [0], nil, nil, nil, nil, [0, 1], nil, nil ]
+      compare '* * * * mon-wed', [ [0], nil, nil, nil, nil, [1, 2, 3], nil, nil ]
+      compare '* * * * 7', [ [0], nil, nil, nil, nil, [0], nil, nil ]
+      compare '* * * * 0', [ [0], nil, nil, nil, nil, [0], nil, nil ]
+      compare '* * * * 0,1', [ [0], nil, nil, nil, nil, [0,1], nil, nil ]
+      compare '* * * * 7,1', [ [0], nil, nil, nil, nil, [0,1], nil, nil ]
+      compare '* * * * 7,0', [ [0], nil, nil, nil, nil, [0], nil, nil ]
+      compare '* * * * sun,2-4', [ [0], nil, nil, nil, nil, [0, 2, 3, 4], nil, nil ]
+
+      compare '* * * * sun,mon-tue', [ [0], nil, nil, nil, nil, [0, 1, 2], nil, nil ]
+
+      compare '* * * * * *', [ nil, nil, nil, nil, nil, nil, nil, nil ]
+      compare '1 * * * * *', [ [1], nil, nil, nil, nil, nil, nil, nil ]
+      compare '7 10-12 * * * *', [ [7], [10, 11, 12], nil, nil, nil, nil, nil, nil ]
+      compare '1-5 * * * * *', [ [1,2,3,4,5], nil, nil, nil, nil, nil, nil, nil ]
+
+      compare '0 0 1 1 *', [ [0], [0], [0], [1], [1], nil, nil, nil ]
+
+      compare '0 23-24 * * *', [ [0], [0], [23, 0], nil, nil, nil, nil, nil ]
+        #
+        # as reported by Aimee Rose in
+        # https://github.com/jmettraux/rufus-scheduler/issues/56
+
+      compare '0 23-2 * * *', [ [0], [0], [23, 0, 1, 2], nil, nil, nil, nil, nil ]
+    end
+
+    it 'rejects invalid weekday expressions' do
+
+      lambda { cl '0 17 * * MON_FRI' }.should raise_error
+        # underline instead of dash
+
+      lambda { cl '* * * * 9' }.should raise_error
+      lambda { cl '* * * * 0-12' }.should raise_error
+      lambda { cl '* * * * BLABLA' }.should raise_error
+    end
+
+    it 'rejects invalid cronlines' do
+
+      lambda { cl '* nada * * 9' }.should raise_error(ArgumentError)
+    end
+
+    it 'interprets cron strings with TZ correctly' do
+
+      compare '* * * * * EST', [ [0], nil, nil, nil, nil, nil, nil, 'EST' ]
+      compare '* * * * * * EST', [ nil, nil, nil, nil, nil, nil, nil, 'EST' ]
+
+      lambda { cl '* * * * * NotATimeZone' }.should raise_error
+      lambda { cl '* * * * * * NotATimeZone' }.should raise_error
+    end
+
+    it 'interprets cron strings with / (slashes) correctly' do
+
+      compare(
+        '0 */2 * * *',
+        [ [0], [0], (0..11).collect { |e| e * 2 }, nil, nil, nil, nil, nil ])
+      compare(
+        '0 7-23/2 * * *',
+        [ [0], [0], (7..23).select { |e| e.odd? }, nil, nil, nil, nil, nil ])
+      compare(
+        '*/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
+
+      lambda {
+        Whedon::Schedule.new('* * * * sun#1-sun#2')
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'accepts items with initial 0' do
+
+      compare '09 * * * *', [ [0], [9], nil, nil, nil, nil, nil, nil ]
+      compare '09-12 * * * *', [ [0], [9, 10, 11, 12], nil, nil, nil, nil, nil, nil ]
+      compare '07-08 * * * *', [ [0], [7, 8], nil, nil, nil, nil, nil, nil ]
+      compare '* */08 * * *', [ [0], nil, [0, 8, 16], nil, nil, nil, nil, nil ]
+      compare '* */07 * * *', [ [0], nil, [0, 7, 14, 21], nil, nil, nil, nil, nil ]
+      compare '* 01-09/04 * * *', [ [0], nil, [1, 5, 9], nil, nil, nil, nil, nil ]
+      compare '* * * * 06', [ [0], nil, nil, nil, nil, [6], nil, nil ]
+    end
+
+    it 'ignores duplicates by default' do
+
+      compare '* * L,L * *', [[0], nil, nil, ['L'], nil, nil, nil, nil ]
+      compare '*/20,40 * * * *', [ [0], [0, 20, 40 ], nil, nil, nil, nil, nil, nil ]
+    end
+
+    it 'raises an error for duplicates when configured to do so' do
+
+      lambda { Ex.new('* * L,L * *') }.should raise_error(ArgumentError)
+    end
+
+    it 'interprets cron strings with L correctly' do
+
+      compare '* * L * *', [[0], nil, nil, ['L'], nil, nil, nil, nil ]
+      compare '* * 2-5,L * *', [[0], nil, nil, [2,3,4,5,'L'], nil, nil, nil, nil ]
+      compare '* * */8,L * *', [[0], nil, nil, [1,9,17,25,'L'], nil, nil, nil, nil ]
+    end
+
+    it 'does not support ranges for L' do
+
+      lambda { cl '* * 15-L * *'}.should raise_error(ArgumentError)
+      lambda { cl '* * L/4 * *'}.should raise_error(ArgumentError)
+    end
+
+    it 'raises if L is used for something else than days' do
+
+      lambda { cl '* L * * *'}.should raise_error(ArgumentError)
+    end
+
+    it 'raises for out of range input' do
+
+      lambda { cl '60-62 * * * *'}.should raise_error(ArgumentError)
+      lambda { cl '62 * * * *'}.should raise_error(ArgumentError)
+      lambda { cl '60 * * * *'}.should raise_error(ArgumentError)
+      lambda { cl '* 25-26 * * *'}.should raise_error(ArgumentError)
+      lambda { cl '* 25 * * *'}.should 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)
+      Whedon::Schedule.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
+
+      nt('* * * * *', now).should == now + 60
+      nt('* * * * sun', now).should == now + 259200
+      nt('* * * * * *', now).should == now + 1
+      nt('* * 13 * fri', now).should == now + 3715200
+
+      nt('10 12 13 12 *', now).should == 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)
+
+      nt('0 0 * * thu', now).should == now + 604800
+
+      nt('0 0 * * *', now).should == now + 24 * 3600
+      nt('0 24 * * *', now).should == now + 24 * 3600
+
+      now = local(2008, 12, 31, 23, 59, 59, 0)
+
+      nt('* * * * *', now).should == now + 1
+    end
+
+    it 'computes the next occurence correctly in UTC (TZ not specified)' do
+
+      now = utc(1970, 1, 1)
+
+      nt('* * * * *', now).should == utc(1970, 1, 1, 0, 1)
+      nt('* * * * sun', now).should == utc(1970, 1, 4)
+      nt('* * * * * *', now).should == utc(1970, 1, 1, 0, 0, 1)
+      nt('* * 13 * fri', now).should == utc(1970, 2, 13)
+
+      nt('10 12 13 12 *', now).should == utc(1970, 12, 13, 12, 10)
+        # this one is slow (1 year == 3 seconds)
+      nt('* * 1 6 *', now).should == utc(1970, 6, 1)
+
+      nt('0 0 * * thu', now).should == utc(1970, 1, 8)
+    end
+
+    it 'computes the next occurence correctly in local TZ (TZ not specified)' do
+
+      now = local(1970, 1, 1)
+
+      nt('* * * * *', now).should == local(1970, 1, 1, 0, 1)
+      nt('* * * * sun', now).should == local(1970, 1, 4)
+      nt('* * * * * *', now).should == local(1970, 1, 1, 0, 0, 1)
+      nt('* * 13 * fri', now).should == local(1970, 2, 13)
+
+      nt('10 12 13 12 *', now).should == local(1970, 12, 13, 12, 10)
+        # this one is slow (1 year == 3 seconds)
+      nt('* * 1 6 *', now).should == local(1970, 6, 1)
+
+      nt('0 0 * * thu', now).should == 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
+
+      nt("* * * * * #{zone}", now).should == utc(1969, 12, 31, 23, 1)
+      nt("* * * * sun #{zone}", now).should == utc(1970, 1, 3, 23)
+      nt("* * * * * * #{zone}", now).should == utc(1969, 12, 31, 23, 0, 1)
+      nt("* * 13 * fri #{zone}", now).should == utc(1970, 2, 12, 23)
+
+      nt("10 12 13 12 * #{zone}", now).should == utc(1970, 12, 13, 11, 10)
+      nt("* * 1 6 * #{zone}", now).should == utc(1970, 5, 31, 23)
+
+      nt("0 0 * * thu #{zone}", now).should == 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
+    #  nt("* * * * * #{zone}", now).should == local(1969, 12, 31, 18, 1)
+    #  nt("* * * * sun #{zone}", now).should == local(1970, 1, 3, 18)
+    #  nt("* * * * * * #{zone}", now).should == local(1969, 12, 31, 18, 0, 1)
+    #  nt("* * 13 * fri #{zone}", now).should == local(1970, 2, 12, 18)
+    #  nt("10 12 13 12 * #{zone}", now).should == local(1970, 12, 13, 6, 10)
+    #  nt("* * 1 6 * #{zone}", now).should == local(1970, 5, 31, 19)
+    #  nt("0 0 * * thu #{zone}", now).should == local(1970, 1, 7, 18)
+    #end
+
+    it 'computes the next time correctly when there is a sun#2 involved' do
+
+      nt('* * * * sun#1', local(1970, 1, 1)).should == local(1970, 1, 4)
+      nt('* * * * sun#2', local(1970, 1, 1)).should == local(1970, 1, 11)
+
+      nt('* * * * sun#2', local(1970, 1, 12)).should == local(1970, 2, 8)
+    end
+
+    it 'computes the next time correctly when there is a sun#2,sun#3 involved' do
+
+      nt('* * * * sun#2,sun#3', local(1970, 1, 1)).should == local(1970, 1, 11)
+      nt('* * * * sun#2,sun#3', local(1970, 1, 12)).should == local(1970, 1, 18)
+    end
+
+    it 'understands sun#L' do
+
+      nt('* * * * sun#L', local(1970, 1, 1)).should == local(1970, 1, 25)
+    end
+
+    it 'understands sun#-1' do
+
+      nt('* * * * sun#-1', local(1970, 1, 1)).should == local(1970, 1, 25)
+    end
+
+    it 'understands sun#-2' do
+
+      nt('* * * * sun#-2', local(1970, 1, 1)).should == local(1970, 1, 18)
+    end
+
+    it 'computes the next time correctly when "L" (last day of month)' do
+
+      nt('* * L * *', lo(1970, 1, 1)).should == lo(1970, 1, 31)
+      nt('* * L * *', lo(1970, 2, 1)).should == lo(1970, 2, 28)
+      nt('* * L * *', lo(1972, 2, 1)).should == lo(1972, 2, 29)
+      nt('* * L * *', lo(1970, 4, 1)).should == lo(1970, 4, 30)
+    end
+  end
+
+  describe '#previous_time' do
+
+    def pt(cronline, now)
+      Whedon::Schedule.new(cronline).previous_time(now)
+    end
+
+    it 'returns the previous time the cron should have triggered' do
+
+      pt('* * * * sun', lo(1970, 1, 1)).should == lo(1969, 12, 28, 23, 59, 00)
+      pt('* * 13 * *', lo(1970, 1, 1)).should == lo(1969, 12, 13, 23, 59, 00)
+      pt('0 12 13 * *', lo(1970, 1, 1)).should == lo(1969, 12, 13, 12, 00)
+
+      pt('* * * * * sun', lo(1970, 1, 1)).should == lo(1969, 12, 28, 23, 59, 59)
+    end
+  end
+
+  describe '#matches?' do
+
+
+    [ ['* * * * *',     utc(1970, 1, 1, 0, 1),      true],
+      ['* * * * sun',   utc(1970, 1, 4),            true],
+      ['* * * * * *',   utc(1970, 1, 1, 0, 0, 1),   true],
+      ['* * 13 * fri',  utc(1970, 2, 13),           true],
+      ['10 12 13 12 *', utc(1970, 12, 13, 12, 10),  true],
+      ['* * 1 6 *',     utc(1970, 6, 1),            true],
+      ['0 0 * * thu',   utc(1970, 1, 8),            true],
+      ['0 0 1 1 *',     utc(2012, 1, 1),            true],
+      ['0 0 1 1 *',     utc(2012, 1, 1, 1, 0),      false]
+    ].each do |line, time, result|
+      it 'matches correctly in UTC (TZ not specified)' do
+        cl(line).matches?(time).should eql(result)
+      end
+    end
+
+    [ ['* * * * *',     local(1970, 1, 1, 0, 1), true],
+      ['* * * * sun',   local(1970, 1, 4), true],
+      ['* * * * * *',   local(1970, 1, 1, 0, 0, 1), true],
+      ['* * 13 * fri',  local(1970, 2, 13), true],
+      ['10 12 13 12 *', local(1970, 12, 13, 12, 10), true],
+      ['* * 1 6 *',     local(1970, 6, 1), true],
+      ['0 0 * * thu',   local(1970, 1, 8), true],
+      ['0 0 1 1 *',     local(2012, 1, 1), true],
+      ['0 0 1 1 *',     local(2012, 1, 1, 1, 0), false]
+    ].each do |line, time, result|
+      it 'matches correctly in local TZ (TZ not specified)' do
+        cl(line).matches?(time).should eql(result)
+      end
+    end
+
+    zone = 'Europe/Stockholm'
+    [ ["* * * * * #{zone}",     utc(1969, 12, 31, 23, 1),     true],
+      ["* * * * sun #{zone}",   utc(1970, 1, 3, 23),          true],
+      ["* * * * * * #{zone}",   utc(1969, 12, 31, 23, 0, 1),  true],
+      ["* * 13 * fri #{zone}",  utc(1970, 2, 12, 23),         true],
+      ["10 12 13 12 * #{zone}", utc(1970, 12, 13, 11, 10),    true],
+      ["* * 1 6 * #{zone}",     utc(1970, 5, 31, 23),         true],
+      ["0 0 * * thu #{zone}",   utc(1970, 1, 7, 23),          true],
+    ].each do |line, time, result|
+      it 'matches correctly in UTC (TZ specified)' do
+        cl(line).matches?(time).should eql(result)
+      end
+    end
+
+    it 'matches correctly when there is a sun#2 involved' do
+
+      cl('* * 13 * fri#2').matches?(utc(1970, 2, 13)).should be_true
+      cl('* * 13 * fri#2').matches?(utc(1970, 2, 20)).should be_false
+    end
+
+    it 'matches correctly when there is a L involved' do
+
+      cl('* * L * *').matches?(utc(1970, 1, 31)).should be_true
+      cl('* * L * *').matches?(utc(1970, 1, 30)).should be_false
+    end
+
+    it 'matches correctly when there is a sun#2,sun#3 involved' do
+
+      cl('* * * * sun#2,sun#3').matches?( local(1970, 1, 4) ).should be_false
+      cl('* * * * sun#2,sun#3').matches?( local(1970, 1, 11) ).should be_true
+      cl('* * * * sun#2,sun#3').matches?( local(1970, 1, 18) ).should be_true
+      cl('* * * * sun#2,sun#3').matches?( local(1970, 1, 25) ).should be_false
+    end
+  end
+
+  describe '#monthdays' do
+
+    it 'returns the appropriate "sun#2"-like string' do
+
+      class Whedon::Schedule
+        public :monthdays
+      end
+
+      cl = Whedon::Schedule.new('* * * * *')
+
+      cl.monthdays(local(1970, 1, 1)).should == %w[ thu#1 thu#-5 ]
+      cl.monthdays(local(1970, 1, 7)).should == %w[ wed#1 wed#-4 ]
+      cl.monthdays(local(1970, 1, 14)).should == %w[ wed#2 wed#-3 ]
+
+      cl.monthdays(local(2011, 3, 11)).should == %w[ fri#2 fri#-3 ]
+    end
+  end
+end
+

data/whedon.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "whedon/version"
+
+Gem::Specification.new do |s|
+  s.name        = "whedon"
+  s.version     = Parse::Cron::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["John Mettraux", "Blake Thomas"]
+  s.email       = ["jmettraux@gmail.com", "bwthomas@gmail.com"]
+  s.homepage    = "https://github.com/bwthomas/whedon"
+  s.summary     = %q{Parses cron lines}
+  s.description = %q{Parses cron lines into a Schedule instance that can be queried.}
+
+  s.rubyforge_project = "whedon"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'tzinfo'
+
+  s.add_development_dependency 'rspec', '~>2.6.0'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'pry'
+end

metadata

@@ -1,24 +1,101 @@
 --- !ruby/object:Gem::Specification
 name: whedon
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
   prerelease: 
 platform: ruby
 authors:
+- John Mettraux
 - Blake Thomas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-28 00:00:00.000000000 Z
-dependencies: []
-description: Nothing to see here.
+date: 2013-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parses cron lines into a Schedule instance that can be queried.
 email:
+- jmettraux@gmail.com
 - bwthomas@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
-homepage: https://rubygems.org/profiles/bwthomas
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- lib/whedon.rb
+- lib/whedon/schedule.rb
+- lib/whedon/version.rb
+- spec/spec_helper.rb
+- spec/whedon/schedule_spec.rb
+- whedon.gemspec
+homepage: https://github.com/bwthomas/whedon
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -41,6 +118,8 @@ rubyforge_project: whedon
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Nothing to see here.
-test_files: []
+summary: Parses cron lines
+test_files:
+- spec/spec_helper.rb
+- spec/whedon/schedule_spec.rb
 has_rdoc: