parse_cron 0.1.6

data/cron_parser_spec.rb

@@ -0,0 +1,251 @@
+require "time"
+require "./spec/spec_helper"
+require "cron_parser"
+require "date"
+
+def parse_date(str)
+  dt = DateTime.strptime(str, "%Y-%m-%d %H:%M:%S")
+  Time.local(dt.year, dt.month, dt.day, dt.hour, dt.min, dt.sec)
+end
+
+describe "CronParser#parse_element" do
+  [
+    ["*", 0..59, (0..59).to_a],
+    ["*/10", 0..59, [0, 10, 20, 30, 40, 50]],
+    ["10", 0..59, [10]],
+    ["10,30", 0..59, [10, 30]],
+    ["10-15", 0..59, [10, 11, 12, 13, 14, 15]],
+    ["10-40/10", 0..59, [10, 20, 30, 40]],
+  ].each do |element, range, expected|
+    it "should return #{expected} for '#{element}' when range is #{range}" do
+      parser = CronParser.new('* * * * *')
+      expect(parser.parse_element(element, range).first.to_a.sort).to eq expected.sort
+    end
+  end
+end
+
+describe "CronParser#next" do
+  [
+    ["* * * * *",             "2011-08-15 12:00:00",  "2011-08-15 12:01:00",1],
+    ["* * * * *",             "2011-08-15 02:25:00",  "2011-08-15 02:26:00",1],
+    ["* * * * *",             "2011-08-15 02:59:00",  "2011-08-15 03:00:00",1],
+    ["*/15 * * * *",          "2011-08-15 02:02:00",  "2011-08-15 02:15:00",1],
+    ["*/15,25 * * * *",       "2011-08-15 02:15:00",  "2011-08-15 02:25:00",1],
+    ["30 3,6,9 * * *",        "2011-08-15 02:15:00",  "2011-08-15 03:30:00",1],
+    ["30 9 * * *",            "2011-08-15 10:15:00",  "2011-08-16 09:30:00",1],
+    ["30 9 * * *",            "2011-08-31 10:15:00",  "2011-09-01 09:30:00",1],
+    ["30 9 * * *",            "2011-09-30 10:15:00",  "2011-10-01 09:30:00",1],
+    ["0 9 * * *",             "2011-12-31 10:15:00",  "2012-01-01 09:00:00",1],
+    ["* * 12 * *",            "2010-04-15 10:15:00",  "2010-05-12 00:00:00",1],
+    ["* * * * 1,3",           "2010-04-15 10:15:00",  "2010-04-19 00:00:00",1],
+    ["* * * * MON,WED",       "2010-04-15 10:15:00",  "2010-04-19 00:00:00",1],
+    ["0 0 1 1 *",             "2010-04-15 10:15:00",  "2011-01-01 00:00:00",1],
+    ["0 0 * * 1",             "2011-08-01 00:00:00",  "2011-08-08 00:00:00",1],
+    ["0 0 * * 1",             "2011-07-25 00:00:00",  "2011-08-01 00:00:00",1],
+    ["45 23 7 3 *",           "2011-01-01 00:00:00",  "2011-03-07 23:45:00",1],
+    ["0 0 1 jun *",           "2013-05-14 11:20:00",  "2013-06-01 00:00:00",1],
+    ["0 0 1 may,jul *",       "2013-05-14 15:00:00",  "2013-07-01 00:00:00",1],
+    ["0 0 1 MAY,JUL *",       "2013-05-14 15:00:00",  "2013-07-01 00:00:00",1],
+    ["40 5 * * *",            "2014-02-01 15:56:00",  "2014-02-02 05:40:00",1],
+    ["0 5 * * 1",             "2014-02-01 15:56:00",  "2014-02-03 05:00:00",1],
+    ["10 8 15 * *",           "2014-02-01 15:56:00",  "2014-02-15 08:10:00",1],
+    ["50 6 * * 1",            "2014-02-01 15:56:00",  "2014-02-03 06:50:00",1],
+    ["1 2 * apr mOn",         "2014-02-01 15:56:00",  "2014-04-07 02:01:00",1],
+    ["1 2 3 4 7",             "2014-02-01 15:56:00",  "2014-04-03 02:01:00",1],
+    ["1 2 3 4 7",             "2014-04-04 15:56:00",  "2014-04-06 02:01:00",1],
+    ["1-20/3 * * * *",        "2014-02-01 15:56:00",  "2014-02-01 16:01:00",1],
+    ["1,2,3 * * * *",         "2014-02-01 15:56:00",  "2014-02-01 16:01:00",1],
+    ["1-9,15-30 * * * *",     "2014-02-01 15:56:00",  "2014-02-01 16:01:00",1],
+    ["1-9/3,15-30/4 * * * *", "2014-02-01 15:56:00",  "2014-02-01 16:01:00",1],
+    ["1 2 3 jan mon",         "2014-02-01 15:56:00",  "2015-01-03 02:01:00",1],
+    ["1 2 3 4 mON",           "2014-02-01 15:56:00",  "2014-04-03 02:01:00",1],
+    ["1 2 3 jan 5",           "2014-02-01 15:56:00",  "2015-01-02 02:01:00",1],
+    ["@yearly",               "2014-02-01 15:56:00",  "2015-01-01 00:00:00",1],
+    ["@annually",             "2014-02-01 15:56:00",  "2015-01-01 00:00:00",1],
+    ["@monthly",              "2014-02-01 15:56:00",  "2014-03-01 00:00:00",1],
+    ["@weekly",               "2014-02-01 15:56:00",  "2014-02-02 00:00:00",1],
+    ["@daily",                "2014-02-01 15:56:00",  "2014-02-02 00:00:00",1],
+    ["@midnight",             "2014-02-01 15:56:00",  "2014-02-02 00:00:00",1],
+    ["@hourly",               "2014-02-01 15:56:00",  "2014-02-01 16:00:00",1],
+    ["@minutely",             "2014-02-01 15:56:00",  "2014-02-01 15:57:00",1],
+    ["*/3 * * * *",           "2014-02-01 15:56:00",  "2014-02-01 15:57:00",1],
+    ["0 5 * 2,3 *",           "2014-02-01 15:56:00",  "2014-02-02 05:00:00",1],
+    ["15-59/15 * * * *",      "2014-02-01 15:56:00",  "2014-02-01 16:15:00",1],
+    ["15-59/15 * * * *",      "2014-02-01 15:00:00",  "2014-02-01 15:15:00",1],
+    ["15-59/15 * * * *",      "2014-02-01 15:01:00",  "2014-02-01 15:15:00",1],
+    ["15-59/15 * * * *",      "2014-02-01 15:16:00",  "2014-02-01 15:30:00",1],
+    ["15-59/15 * * * *",      "2014-02-01 15:26:00",  "2014-02-01 15:30:00",1],
+    ["15-59/15 * * * *",      "2014-02-01 15:36:00",  "2014-02-01 15:45:00",1],
+    ["15-59/15 * * * *",      "2014-02-01 15:45:00",  "2014-02-01 16:15:00",4],
+    ["15-59/15 * * * *",      "2014-02-01 15:46:00",  "2014-02-01 16:15:00",3],
+    ["15-59/15 * * * *",      "2014-02-01 15:46:00",  "2014-02-01 16:15:00",2],
+    ["30 * * * * * *",        "2011-08-15 12:00:00",  "2011-08-15 12:00:30",1],
+    ["*/15 * * * * * *",      "2011-08-15 12:00:00",  "2011-08-15 12:00:15",1],
+    ["20-40 * * * * * *",     "2011-08-15 12:00:00",  "2011-08-15 12:00:20",1],
+    ["12 15-59/15 * * * * *", "2014-02-01 15:46:00",  "2014-02-01 16:15:12",2],
+    ["* * * * * * 2018",      "2014-02-01 15:46:00",  "2018-01-01 00:00:00",1],
+    ["1 1 1 1 1 * 2018",      "2014-02-01 15:46:00",  "2018-01-01 01:01:01",1],
+    ["* * * * * * 2016-2018", "2014-02-01 15:46:00",  "2016-01-01 00:00:00",1],
+    ["* * * * * * */20",      "2014-02-01 15:46:00",  "2020-01-01 00:00:00",1],
+    # tw testing
+    # 6 digit dkron
+    ["0 * * * * *",           "2019-06-01 08:00:00",  "2019-06-01 08:01:00",1],
+    ["0 0 * * * *",           "2019-06-01 08:00:00",  "2019-06-01 09:00:00",1],
+    ["0 0 0 * * *",           "2019-06-01 08:00:00",  "2019-06-02 00:00:00",1],
+    ["0 0 0 1 * *",           "2019-06-01 08:00:00",  "2019-07-01 00:00:00",1],
+    ["0 0 0 5 7 *",           "2019-06-01 08:00:00",  "2019-07-05 00:00:00",1],
+    ["0 0 * * 8 SUN",         "2019-06-01 08:00:00",  "2019-08-04 00:00:00",1],
+
+    ["15 0,15,30,45 * * * *", "2019-06-01 08:16:16",  "2019-06-01 08:30:15",1],
+    ["0 */15 */3 * * *",      "2019-06-01 08:00:00",  "2019-06-01 09:00:00",1],
+    ["0 0 * ? * *",           "2019-06-01 08:00:00",  "2019-06-01 09:00:00",1],
+    ["0 0 * * * ?",           "2019-06-01 08:00:00",  "2019-06-01 09:00:00",1],
+    ["0 0 * ? * ?",           "2019-06-01 08:00:00",  "2019-06-01 09:00:00",1],
+  ].each do |line, now, expected_next,num|
+    it "returns #{expected_next} for '#{line}' when now is #{now}" do
+      parsed_now = parse_date(now)
+      expected = parse_date(expected_next)
+      parser = CronParser.new(line)
+      expect(parser.next(parsed_now).xmlschema).to eq expected.xmlschema
+    end
+    it "returns the expected class" do
+      parsed_now = parse_date(now)
+      expected = parse_date(expected_next)
+      parser = CronParser.new(line)
+      result = parser.next(parsed_now,num)
+      expect(result.class.to_s).to eq (num > 1 ? 'Array' : 'Time')
+    end
+    it "returns the expected count" do
+      parsed_now = parse_date(now)
+      expected = parse_date(expected_next)
+      parser = CronParser.new(line)
+      result = parser.next(parsed_now,num)
+      if result.class.to_s == 'Array'
+        expect(result.size).to eq num
+      else
+        expect(result.class.to_s).to eq 'Time'
+      end
+    end
+  end
+
+  [
+    ["* * * * * * 2010", "2014-02-01 15:46:00"]
+  ].each do |line, now|
+    it "should raise an error for '#{line}' when now is #{now}" do
+      now = parse_date(now)
+
+      parser = CronParser.new(line)
+
+      expect{parser.next(now)}.to raise_error "No matching dates exist"
+    end
+  end
+end
+
+describe "CronParser#last" do
+  [
+    ["* * * * *",             "2011-08-15 12:00:00",  "2011-08-15 11:59:00"],
+    ["* * * * *",             "2011-08-15 02:25:00",  "2011-08-15 02:24:00"],
+    ["* * * * *",             "2011-08-15 03:00:00",  "2011-08-15 02:59:00"],
+    ["*/15 * * * *",          "2011-08-15 02:02:00",  "2011-08-15 02:00:00"],
+    ["*/15,45 * * * *",       "2011-08-15 02:55:00",  "2011-08-15 02:45:00"],
+    ["*/15,25 * * * *",       "2011-08-15 02:35:00",  "2011-08-15 02:30:00"],
+    ["30 3,6,9 * * *",        "2011-08-15 02:15:00",  "2011-08-14 09:30:00"],
+    ["30 9 * * *",            "2011-08-15 10:15:00",  "2011-08-15 09:30:00"],
+    ["30 9 * * *",            "2011-09-01 08:15:00",  "2011-08-31 09:30:00"],
+    ["30 9 * * *",            "2011-10-01 08:15:00",  "2011-09-30 09:30:00"],
+    ["0 9 * * *",             "2012-01-01 00:15:00",  "2011-12-31 09:00:00"],
+    ["* * 12 * *",            "2010-04-15 10:15:00",  "2010-04-12 23:59:00"],
+    ["* * * * 1,3",           "2010-04-15 10:15:00",  "2010-04-14 23:59:00"],
+    ["* * * * MON,WED",       "2010-04-15 10:15:00",  "2010-04-14 23:59:00"],
+    ["0 0 1 1 *",             "2010-04-15 10:15:00",  "2010-01-01 00:00:00"],
+    ["0 0 1 jun *",           "2013-05-14 11:20:00",  "2012-06-01 00:00:00"],
+    ["0 0 1 may,jul *",       "2013-05-14 15:00:00",  "2013-05-01 00:00:00"],
+    ["0 0 1 MAY,JUL *",       "2013-05-14 15:00:00",  "2013-05-01 00:00:00"],
+    ["40 5 * * *",            "2014-02-01 15:56:00",  "2014-02-01 05:40:00"],
+    ["0 5 * * 1",             "2014-02-01 15:56:00",  "2014-01-27 05:00:00"],
+    ["10 8 15 * *",           "2014-02-01 15:56:00",  "2014-01-15 08:10:00"],
+    ["50 6 * * 1",            "2014-02-01 15:56:00",  "2014-01-27 06:50:00"],
+    ["1 2 * apr mOn",         "2014-02-01 15:56:00",  "2013-04-29 02:01:00"],
+    ["1 2 3 4 7",             "2014-02-01 15:56:00",  "2013-04-28 02:01:00"],
+    ["1 2 3 4 7",             "2014-04-04 15:56:00",  "2014-04-03 02:01:00"],
+    ["1-20/3 * * * *",        "2014-02-01 15:56:00",  "2014-02-01 15:19:00"],
+    ["1,2,3 * * * *",         "2014-02-01 15:56:00",  "2014-02-01 15:03:00"],
+    ["1-9,15-30 * * * *",     "2014-02-01 15:56:00",  "2014-02-01 15:30:00"],
+    ["1-9/3,15-30/4 * * * *", "2014-02-01 15:56:00",  "2014-02-01 15:27:00"],
+    ["1 2 3 jan mon",         "2014-02-01 15:56:00",  "2014-01-27 02:01:00"],
+    ["1 2 3 4 mON",           "2014-02-01 15:56:00",  "2013-04-29 02:01:00"],
+    ["1 2 3 jan 5",           "2014-02-01 15:56:00",  "2014-01-31 02:01:00"],
+    ["@yearly",               "2014-02-01 15:56:00",  "2014-01-01 00:00:00"],
+    ["@annually",             "2014-02-01 15:56:00",  "2014-01-01 00:00:00"],
+    ["@monthly",              "2014-02-01 15:56:00",  "2014-02-01 00:00:00"],
+    ["@weekly",               "2014-02-01 15:56:00",  "2014-01-26 00:00:00"],
+    ["@daily",                "2014-02-01 15:56:00",  "2014-02-01 00:00:00"],
+    ["@midnight",             "2014-02-01 15:56:00",  "2014-02-01 00:00:00"],
+    ["@hourly",               "2014-02-01 15:56:00",  "2014-02-01 15:00:00"],
+    ["*/3 * * * *",           "2014-02-01 15:56:00",  "2014-02-01 15:54:00"],
+    ["0 5 * 2,3 *",           "2014-02-01 15:56:00",  "2014-02-01 05:00:00"],
+    ["15-59/15 * * * *",      "2014-02-01 15:56:00",  "2014-02-01 15:45:00"],
+    ["15-59/15 * * * *",      "2014-02-01 15:00:00",  "2014-02-01 14:45:00"],
+    ["15-59/15 * * * *",      "2014-02-01 15:01:00",  "2014-02-01 14:45:00"],
+    ["15-59/15 * * * *",      "2014-02-01 15:16:00",  "2014-02-01 15:15:00"],
+    ["15-59/15 * * * *",      "2014-02-01 15:26:00",  "2014-02-01 15:15:00"],
+    ["15-59/15 * * * *",      "2014-02-01 15:36:00",  "2014-02-01 15:30:00"],
+    ["15-59/15 * * * *",      "2014-02-01 15:45:00",  "2014-02-01 15:30:00"],
+    ["15-59/15 * * * *",      "2014-02-01 15:46:00",  "2014-02-01 15:45:00"],
+    ["30 * * * * * *",        "2011-08-15 12:00:00",  "2011-08-15 11:59:30"],
+    ["*/15 * * * * * *",      "2011-08-15 12:00:00",  "2011-08-15 11:59:45"],
+    ["20-40 * * * * * *",     "2011-08-15 12:00:00",  "2011-08-15 11:59:40"],
+    ["12 15-59/15 * * * * *", "2014-02-01 15:46:00",  "2014-02-01 15:45:12"],
+    ["* * * * * * 1970",      "2014-02-01 15:46:00",  "1970-12-31 23:59:59"],
+    ["1 1 1 1 1 * 1970",      "2014-02-01 15:46:00",  "1970-01-01 01:01:01"],
+    ["* * * * * * 1970-1978", "2014-02-01 15:46:00",  "1978-12-31 23:59:59"],
+    ["* * * * * * */20",      "2014-02-01 15:46:00",  "2000-12-31 23:59:59"],
+  ].each do |line, now, expected_next|
+    it "should return #{expected_next} for '#{line}' when now is #{now}" do
+      now = parse_date(now)
+      expected_next = parse_date(expected_next)
+
+      parser = CronParser.new(line)
+
+      expect(parser.last(now)).to eq expected_next
+    end
+  end
+
+  [
+    ["* * * * * * 2018", "2014-02-01 15:46:00"]
+  ].each do |line, now|
+    it "should raise an error for '#{line}' when now is #{now}" do
+      now = parse_date(now)
+
+      parser = CronParser.new(line)
+
+      expect{parser.last(now)}.to raise_error "No matching dates exist"
+    end
+  end
+end
+
+describe "CronParser#new" do
+  it 'should not raise error when given a valid cronline' do
+    expect { CronParser.new('30 * * * *') }.not_to raise_error
+  end
+
+
+  [
+    ["* * * *"],
+    ["? ? ? ? ? ?"],
+    ["? * * * * *"],
+    ["* * * * * * * *"],
+  ].each do |line|
+    it 'should raise error when given an invalid cronline' do
+      expect { CronParser.new(line) }.to raise_error('not a valid cronline')
+    end
+  end
+end
+
+describe "time source" do
+  it "should use an alternate specified time source" do
+    ExtendedTime = Class.new(Time)
+    expect(ExtendedTime).to receive(:local).once
+    CronParser.new("* * * * *",ExtendedTime).next
+  end
+end

data/lib/cron_parser.rb

@@ -0,0 +1,362 @@
+require 'set'
+require 'date'
+
+# Parses cron expressions and computes the next occurence of the "job"
+#
+class CronParser
+  # internal "mutable" time representation
+  class InternalTime
+    attr_accessor :year, :month, :day, :hour, :min, :sec
+    attr_accessor :time_source
+
+    def initialize(time = Time.now, time_source = Time)
+      @year = time.year
+      @month = time.month
+      @day = time.day
+      @hour = time.hour
+      @min = time.min
+      @sec = time.sec
+
+      @time_source = time_source
+    end
+
+    def to_time
+      time_source.local(@year, @month, @day, @hour, @min, @sec)
+    end
+
+    def inspect
+      [year, month, day, hour, min, sec].inspect
+    end
+  end
+
+  SYMBOLS = {
+     "jan" => "1",
+     "feb" => "2",
+     "mar" => "3",
+     "apr" => "4",
+     "may" => "5",
+     "jun" => "6",
+     "jul" => "7",
+     "aug" => "8",
+     "sep" => "9",
+     "oct" => "10",
+     "nov" => "11",
+     "dec" => "12",
+
+     "sun" => "0",
+     "mon" => "1",
+     "tue" => "2",
+     "wed" => "3",
+     "thu" => "4",
+     "fri" => "5",
+     "sat" => "6"
+  }
+
+  def initialize(source,time_source = Time)
+    @source = interpret_vixieisms(source)
+    @time_source = time_source
+    validate_source
+  end
+
+  def interpret_vixieisms(spec)
+    case spec
+    when '@reboot'
+      raise ArgumentError, "Can't predict last/next run of @reboot"
+    when '@yearly', '@annually'
+      '0 0 1 1 *'
+    when '@monthly'
+      '0 0 1 * *'
+    when '@weekly'
+      '0 0 * * 0'
+    when '@daily', '@midnight'
+      '0 0 * * *'
+    when '@hourly'
+      '0 * * * *'
+    when '@minutely'
+      '* * * * *'
+    else
+      spec
+    end
+  end
+
+
+  # returns the next occurence after the given date
+  def next(now = @time_source.now, num = 1)
+    t = InternalTime.new(now, @time_source)
+
+    unless time_specs[:year][0].include?(t.year)
+      nudge_year(t)
+      t.month = 0
+    end
+
+    unless time_specs[:month][0].include?(t.month)
+      nudge_month(t)
+      t.day = 0
+    end
+
+    unless interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+      nudge_date(t)
+      t.hour = -1
+    end
+
+    unless time_specs[:hour][0].include?(t.hour)
+      nudge_hour(t)
+      t.min = -1
+    end
+
+    unless time_specs[:minute][0].include?(t.min)
+      nudge_minute(t)
+      t.sec = -1
+    end
+
+    # always nudge the second
+    nudge_second(t)
+    t = t.to_time
+    if num > 1
+      recursive_calculate(:next,t,num)
+    else
+      t
+    end
+  end
+
+  # returns the last occurence before the given date
+  def last(now = @time_source.now, num=1)
+    t = InternalTime.new(now,@time_source)
+
+    unless time_specs[:year][0].include?(t.year)
+      nudge_year(t, :last)
+      t.month = 13
+    end
+
+    unless time_specs[:month][0].include?(t.month)
+      nudge_month(t, :last)
+      t.day = 32
+    end
+
+    if t.day == 32 || !interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+      nudge_date(t, :last)
+      t.hour = 24
+    end
+
+    unless time_specs[:hour][0].include?(t.hour)
+      nudge_hour(t, :last)
+      t.min = 60
+    end
+
+    unless time_specs[:minute][0].include?(t.min)
+      nudge_minute(t, :last)
+      t.sec = 60
+    end
+
+    # always nudge the second
+    nudge_second(t, :last)
+    t = t.to_time
+    if num > 1
+      recursive_calculate(:last,t,num)
+    else
+      t
+    end
+  end
+
+
+  SUBELEMENT_REGEX = %r{^(\d+)(-(\d+)(/(\d+))?)?$}
+  def parse_element(elem, allowed_range)
+    values = elem.split(',').map do |subel|
+      if subel =~ /^\*/
+        step = subel.length > 1 ? subel[2..-1].to_i : 1
+        stepped_range(allowed_range, step)
+      elsif subel =~ /^\?$/ && (allowed_range == (1..31) || allowed_range == (0..6))
+        step = subel.length > 1 ? subel[2..-1].to_i : 1
+        stepped_range(allowed_range, step)
+      else
+        if SUBELEMENT_REGEX === subel
+          if $5 # with range
+            stepped_range($1.to_i..$3.to_i, $5.to_i)
+          elsif $3 # range without step
+            stepped_range($1.to_i..$3.to_i, 1)
+          else # just a numeric
+            [$1.to_i]
+          end
+        else
+          raise ArgumentError, "Bad Vixie-style specification #{subel}"
+        end
+      end
+    end.flatten.sort
+
+    [Set.new(values), values, elem]
+  end
+
+
+  protected
+
+  def recursive_calculate(meth,time,num)
+    array = [time]
+    num.-(1).times do |num|
+      array << self.send(meth, array.last)
+    end
+    array
+  end
+
+  # returns a list of days which do both match time_spec[:dom] or time_spec[:dow]
+  def interpolate_weekdays(year, month)
+    @_interpolate_weekdays_cache ||= {}
+    @_interpolate_weekdays_cache["#{year}-#{month}"] ||= interpolate_weekdays_without_cache(year, month)
+  end
+
+  def interpolate_weekdays_without_cache(year, month)
+    t = Date.new(year, month, 1)
+    valid_mday, _, mday_field = time_specs[:dom]
+    valid_wday, _, wday_field = time_specs[:dow]
+
+    # Careful, if both DOW and DOM fields are non-wildcard,
+    # then we only need to match *one* for cron to run the job:
+    if not (mday_field == '*' and wday_field == '*')
+      valid_mday = [] if mday_field == '*'
+      valid_wday = [] if wday_field == '*'
+    end
+    # Careful: crontabs may use either 0 or 7 for Sunday:
+    valid_wday << 0 if valid_wday.include?(7)
+
+    result = []
+    while t.month == month
+      result << t.mday if valid_mday.include?(t.mday) || valid_wday.include?(t.wday)
+      t = t.succ
+    end
+
+    [Set.new(result), result]
+  end
+
+  def nudge_year(t, dir = :next)
+    spec = time_specs[:year][1]
+    next_value = find_best_next(t.year, spec, dir)
+    t.year = next_value || (dir == :next ? spec.first : spec.last)
+
+    # We've exhausted all years in the range
+    raise "No matching dates exist" if next_value.nil?
+  end
+
+  def nudge_month(t, dir = :next)
+    spec = time_specs[:month][1]
+    next_value = find_best_next(t.month, spec, dir)
+    t.month = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_year(t, dir) if next_value.nil?
+
+    # we changed the month, so its likely that the date is incorrect now
+    valid_days = interpolate_weekdays(t.year, t.month)[1]
+    t.day = dir == :next ? valid_days.first : valid_days.last
+  end
+
+  def date_valid?(t, dir = :next)
+    interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+  end
+
+  def nudge_date(t, dir = :next, can_nudge_month = true)
+    spec = interpolate_weekdays(t.year, t.month)[1]
+    next_value = find_best_next(t.day, spec, dir)
+    t.day = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_month(t, dir) if next_value.nil? && can_nudge_month
+  end
+
+  def nudge_hour(t, dir = :next)
+    spec = time_specs[:hour][1]
+    next_value = find_best_next(t.hour, spec, dir)
+    t.hour = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_date(t, dir) if next_value.nil?
+  end
+
+  def nudge_minute(t, dir = :next)
+    spec = time_specs[:minute][1]
+    next_value = find_best_next(t.min, spec, dir)
+    t.min = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_hour(t, dir) if next_value.nil?
+  end
+
+  def nudge_second(t, dir = :next)
+    spec = time_specs[:second][1]
+    next_value = find_best_next(t.sec, spec, dir)
+    t.sec = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_minute(t, dir) if next_value.nil?
+  end
+
+  def time_specs
+    @time_specs ||= begin
+      tokens = substitute_parse_symbols(@source).split(/\s+/)
+      # tokens now contains the 5 or 7 fields
+
+      if tokens.count == 5
+        {
+          :second => parse_element("0", 0..59),       #second
+          :minute => parse_element(tokens[0], 0..59), #minute
+          :hour   => parse_element(tokens[1], 0..23), #hour
+          :dom    => parse_element(tokens[2], 1..31), #DOM
+          :month  => parse_element(tokens[3], 1..12), #mon
+          :dow    => parse_element(tokens[4], 0..6),  #DOW
+          :year   => parse_element("*", 2000..2050)   #year
+        }
+      elsif tokens.count == 6
+        {
+          :second => parse_element(tokens[0], 0..59), #second
+          :minute => parse_element(tokens[1], 0..59), #minute
+          :hour   => parse_element(tokens[2], 0..23), #hour
+          :dom    => parse_element(tokens[3], 1..31), #DOM
+          :month  => parse_element(tokens[4], 1..12), #mon
+          :dow    => parse_element(tokens[5], 0..6),  #DOW
+          :year   => parse_element("*", 2000..2050)   #year
+        }
+      else
+        {
+          :second => parse_element(tokens[0], 0..59), #second
+          :minute => parse_element(tokens[1], 0..59), #minute
+          :hour   => parse_element(tokens[2], 0..23), #hour
+          :dom    => parse_element(tokens[3], 1..31), #DOM
+          :month  => parse_element(tokens[4], 1..12), #mon
+          :dow    => parse_element(tokens[5], 0..6),  #DOW
+          :year   => parse_element(tokens[6], 2000..2050)  #year
+        }
+      end
+    end
+  end
+
+  def substitute_parse_symbols(str)
+    SYMBOLS.inject(str.downcase) do |s, (symbol, replacement)|
+      s.gsub(symbol, replacement)
+    end
+  end
+
+
+  def stepped_range(rng, step = 1)
+    len = rng.last - rng.first
+
+    num = len.div(step)
+    result = (0..num).map { |i| rng.first + step * i }
+
+    result.pop if result[-1] == rng.last and rng.exclude_end?
+    result
+  end
+
+
+  # returns the smallest element from allowed which is greater than current
+  # returns nil if no matching value was found
+  def find_best_next(current, allowed, dir)
+    if dir == :next
+      allowed.sort.find { |val| val > current }
+    else
+      allowed.sort.reverse.find { |val| val < current }
+    end
+  end
+
+  def validate_source
+    unless @source.respond_to?(:split)
+      raise ArgumentError, 'not a valid cronline'
+    end
+    source_length = @source.split(/\s+/).length
+    unless (source_length >= 5 && source_length < 8)
+      raise ArgumentError, 'not a valid cronline'
+    end
+  end
+end