cronman 0.0.1

data/README.md

@@ -0,0 +1,41 @@
+# What is this?
+
+A crontab(5) parser.
+
+# How to install?
+
+In your Gemfile:
+
+```ruby
+gem 'cronman', 'git: git@github.com:renatomoya/cronman.git'
+```
+
+# How to use?
+
+```ruby
+crontab = Cronman.parse(src)
+
+from_date = Date.parse('2009-10-10')
+to_date = Date.parse('2009-10-20')
+
+crontab.entries.each do |entry|
+  # Access the cron definition
+  puts entry.cron_definition
+
+  # Access the cron definition translation
+  puts entry.translation.join(' ')
+
+  # Access the command
+  puts entry.command
+
+  # Access parsed cron definition
+  puts entry.schedule
+
+  # Filtering is easy!
+  e.schedule.from(from_date).until(to_date) do |timing|
+   puts timing
+  end
+end
+```
+
+Most of this code is not mine. I borrowed it from [@sakuro](https://github.com/sakuro) gem [crontab](https://github.com/sakuro/crontab). I added a few missing features for a personal project called cronman.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+spec = Gem::Specification.load('crontab.gemspec')
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar_bz2 = true
+end
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc', 'lib/**/*.rb')
+  rdoc.options << '--all'
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.warning = true
+  t.rcov = false
+end

data/cronman.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name = 'cronman'
+  s.version = '0.0.1'
+  s.author = 'Renato Moya'
+  s.email = 'imexto@gmail.com'
+  s.homepage = 'http://github.com/renatomoya/cronman'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'A crontab(5) entry parser'
+  s.files = [
+    'lib/cronman.rb',
+    'lib/cronman/entry.rb',
+    'lib/cronman/schedule.rb',
+    'spec/cronman_spec.rb',
+    'spec/cronman/entry_spec.rb',
+    'spec/cronman/schedule_spec.rb',
+    'cronman.gemspec',
+    'Rakefile',
+    'README.md'
+  ]
+  s.add_runtime_dependency('cron2english', ['0.1.3'])
+  s.has_rdoc = true
+  s.rubyforge_project = 'n/a'
+end

data/lib/cronman/entry.rb

@@ -0,0 +1,54 @@
+require 'cron2english'
+
+class Cronman
+  # A class which represents a job line in crontab(5).
+  class Entry
+    # Creates a crontab(5) entry.
+    #
+    # * <tt>schedule</tt> A Cronman::Schedule instance.
+    # * <tt>command</tt>
+    # * <tt>uid</tt>
+    def initialize(schedule, command, cron_definition, uid=nil)
+      raise ArgumentError, 'invalid schedule' unless schedule.is_a? Schedule
+      raise ArgumentError, 'invalid command' unless command.is_a? String
+
+      @schedule = schedule.freeze
+      @command = command.freeze
+      @cron_definition = cron_definition.freeze
+      @translation = Cron2English.parse(@cron_definition).freeze
+      @uid =
+        case uid
+        when String
+          Etc.getpwnam(uid).uid
+        when Integer
+          uid
+        when nil
+          Process.uid
+        else
+          raise ArgumentError, 'invalid uid'
+        end
+    end
+
+    attr_reader :schedule, :command, :cron_definition, :translation, :uid
+    class << self
+      # Parses a string line in crontab(5) job format.
+      #
+      # * <tt>options[:system]</tt> when true system wide crontab is assumed
+      #   and <tt>@uid</tt> is extracted from <i>line</i>.
+      def parse(line, options={})
+        options = { :system => false }.merge(options)
+        line = line.strip
+        number_of_fields = 1
+        number_of_fields += line.start_with?('@') ? 1 : 5
+        number_of_fields += 1 if options[:system]
+        words = line.split(/\s+/, number_of_fields)
+        command = words.pop
+        uid = options[:system] ? words.pop : Process.uid
+        cron_definition = words.first(5).join(' ')
+        spec = words.join(' ')
+        schedule = Cronman::Schedule.new(spec)
+        new(schedule, command, cron_definition, uid)
+      end
+    end
+  end
+end

data/lib/cronman/schedule.rb

@@ -0,0 +1,242 @@
+require 'date'
+
+class Cronman
+
+  # A class which represents schedules in crontab(5).
+  class Schedule
+
+    MONTH_NAMES = %w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
+    DAY_OF_WEEK_NAMES = %w(Sun Mon Tue Wed Thu Fri Sat)
+    DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+    # Creates a cron job schedule.
+    #
+    # * <tt>spec</tt> schedule specifier defined in crontab(5).
+    #   Both numeric and named spec are supported.
+    # * <tt>start</tt> the time *or* date this schedule begins.
+    #
+    # Supported named specs are:
+    # * <tt>@yearly</tt>, <tt>@annually</tt>
+    # * <tt>@monthly</tt>
+    # * <tt>@weekly</tt>
+    # * <tt>@daily</tt>, <tt>@midnight</tt>
+    # * <tt>@hourly</tt>
+    def initialize(spec, start=Time.now)
+      raise ArgumentError, 'empty spec' if spec == '' or spec.nil?
+      @start = ensure_time(start)
+      spec = spec.strip
+      if spec.start_with?('@')
+        parse_symbolic_spec(spec)
+      else
+        parse_spec(spec)
+      end
+    end
+
+    def ==(other)
+      self.minutes == other.minutes &&
+      self.hours == other.hours &&
+      self.day_of_months == other.day_of_months &&
+      self.months == other.months &&
+      self.day_of_months_given? == other.day_of_months_given? &&
+      self.day_of_weeks == other.day_of_weeks &&
+      self.day_of_weeks_given? == other.day_of_weeks_given? &&
+      self.start == other.start
+    end
+
+    def hash
+      [ minutes, hours, day_of_months, months, day_of_weeks, day_of_months_given?, day_of_weeks_given?, start ].map(&:hash).inject(:^)
+    end
+
+    attr_reader :minutes, :hours, :day_of_months, :months, :day_of_weeks, :start
+
+    # Changes the start timing of this schedule to <i>time_or_date</i>.
+    def start=(time_or_date)
+      @start = ensure_time(time_or_date)
+    end
+
+    # Creates new schedule which starts at the given <i>time_or_date</i>.
+    def from(time_or_date)
+      self.dup.tap {|new_schedule| new_schedule.start = ensure_time(time_or_date) }
+    end
+
+    def day_of_months_given?
+      !!@day_of_months_given # ensures boolean
+    end
+
+    def day_of_weeks_given?
+      !!@day_of_weeks_given # ensures boolean
+    end
+
+    # Iterates over timings specified in this schedule, starting at <tt>@start</tt>.
+    def each
+      return to_enum unless block_given?
+      year = @start.year
+      seeking = Hash.new {|h,k| h[k] = true }
+      loop do
+        @months.each do |month|
+          next if seeking[:month] and month < @start.month and @start.month <= @months.max
+          seeking[:month] = false
+          days = matching_days(year, month)
+          days.each do |day_of_month|
+            next if seeking[:day_of_month] and day_of_month < @start.day and @start.day <= days.max
+            seeking[:day_of_month] = false
+            @hours.each do |hour|
+              next if seeking[:hour] and hour < @start.hour and @start.hour <= @hours.max
+              seeking[:hour] = false
+              @minutes.each do |minute|
+                begin
+                  t = Time.local(year, month, day_of_month, hour, minute)
+                rescue ArgumentError
+                  raise StopIteration
+                end
+                yield(t) if @start <= t
+              end
+            end
+          end
+        end
+        year += 1
+      end
+    end
+
+    include Enumerable
+
+    # Iterates over timings from <tt>@start</tt> until given <i>time_or_date</i>.
+    def until(time_or_date)
+      time = ensure_time(time_or_date)
+      if block_given?
+        each do |t|
+          break if time < t
+          yield(t)
+        end
+      else
+        inject([]) do |timings, t|
+          break timings if time < t
+          timings << t
+        end
+      end
+    end
+
+    private
+
+    def parse_spec(spec)
+      args = spec.split(/\s+/)
+      raise ArgumentError, 'wrong number of spec fields: %d' % args.size unless args.size == 5
+      @minutes = parse_spec_field(args[0], 0..59, :accept_name => false)
+      @hours = parse_spec_field(args[1], 0..23, :accept_name => false)
+      @day_of_months = parse_spec_field(args[2], 1..31, :accept_name => false)
+      @day_of_months_given = args[2] != '*'
+      @months = parse_spec_field(args[3], 1..12, :names => MONTH_NAMES, :base => 1, :accept_name => true)
+      @day_of_weeks = parse_spec_field(args[4], 0..6, :names => DAY_OF_WEEK_NAMES, :base => 0, :accept_name => true, :allow_end => true)
+      @day_of_weeks_given = args[4] != '*'
+    end
+
+    def parse_symbolic_spec(spec)
+      case spec
+      when '@yearly', '@annually'
+        parse_spec('0 0 1 1 *')
+      when '@monthly'
+        parse_spec('0 0 1 * *')
+      when '@weekly'
+        parse_spec('0 0 * * 0')
+      when '@daily', '@midnight'
+        parse_spec('0 0 * * *')
+      when '@hourly'
+        parse_spec('0 * * * *')
+      when '@reboot'
+        raise NotImplementedError, '@reboot is not supported'
+      else
+        raise ArgumentError, 'unknown crontab spec: %s' % spec
+      end
+    end
+
+    def parse_spec_field(spec, range, options={})
+      options = { :accept_name => true, :allow_end => false }.merge(options)
+      case spec
+      when '*'
+        range.to_a
+      when /\A\d+\z/
+        [ parse_number(spec, range, options) ]
+      when /\A[a-z]{3}\z/i
+        [ parse_name(spec, range, options) ]
+      when /\A(\d+)-(\d+)\z/i
+        parse_range($1, $2, range, options.merge(:accept_name => false))
+      when /,/
+        parse_list(spec.split(/,/), range, options.merge(:accept_name => false))
+      when /\A(\*|\d+-\d+)\/(\d+)\z/
+        parse_step($1, $2.to_i, range, options.merge(:accept_name => false))
+      else
+        raise ArgumentError, 'wrong spec format: %s' % spec
+      end.tap do |result|
+        if options[:allow_end] && result.include?(range.first) && result.include?(range.last.succ)
+          result.delete(range.last.succ)
+        end
+      end.sort.uniq.freeze
+    end
+
+    def parse_number(spec, range, options)
+      v = spec.to_i
+      return v if range.include?(v) or options[:allow_end] && range.last.succ == v
+      raise ArgumentError, 'argument out of range: %s' % spec
+    end
+
+    def parse_name(spec, range, options)
+      raise ArgumentError, 'names not allowed in this field: %s' % spec unless options[:names] and options[:base]
+      raise ArgumentError, 'names not allowed in this context: %s' % spec unless options[:accept_name]
+      v = options[:names].index {|name| name.downcase == spec.downcase }
+      base = options[:base]
+      return v + base if v && range.include?(v + base)
+      raise ArgumentError, 'argument out of range: %s' % spec
+    end
+
+    def parse_range(from, to, range, options)
+      from = parse_number(from, range, options[:allow_end])
+      to = parse_number(to, range, options[:allow_end])
+      raise ArgumentError, 'start is after or equal to end: %s' % spec unless from < to
+      (from..to).to_a
+    end
+
+    def parse_list(specs, range, options)
+      specs.map{|spec| parse_spec_field(spec, range, options) }.flatten
+    end
+
+    def parse_step(first, step, range, options)
+      v = parse_spec_field(first, range, options)
+      v.first.step(v.size == 1 ? range.last : v.last, step).to_a
+    end
+
+    def matching_days(year, month)
+      days = number_of_days(year, month)
+      (1..days).select do |day|
+        wday = day_of_week(year, month, day)
+        if day_of_months_given?
+          if day_of_weeks_given?
+            @day_of_months.include?(day) or @day_of_weeks.include?(wday)
+          else
+            @day_of_months.include?(day)
+          end
+        else
+          if day_of_weeks_given?
+            @day_of_weeks.include?(wday)
+          else
+            true
+          end
+        end
+      end
+    end
+
+    def ensure_time(time_or_date)
+      time_or_date.is_a?(Date) ? Time.local(time_or_date.year, time_or_date.month, time_or_date.day) : time_or_date
+    end
+
+    def number_of_days(year, month)
+      days = DAYS_IN_MONTH[month]
+      days += 1 if month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
+      days
+    end
+
+    def day_of_week(year, month, day)
+      Date.new(year, month, day).wday
+    end
+  end
+
+end

data/lib/cronman.rb

@@ -0,0 +1,34 @@
+require 'cronman/schedule'
+require 'cronman/entry'
+
+# A class which represents crontab(5) content.
+class Cronman
+  class << self
+    # Parses a crontab(5) text.
+    #
+    # * <tt>src</tt> string in crontab(5) format
+    def parse(src)
+      entries = []
+      env = {}
+      src.lines.each do |line|
+        line.strip!
+        case line
+        when /\A[\d*]/
+          entries << Cronman::Entry.parse(line)
+        when /\A([A-Z][A-Z0-9_]*)\s*=\s*/, /\A"([A-Z][A-Z0-9_]*)"\s*=\s*/, /\A'([A-Z][A-Z0-9_]*)'\s*=\s*/
+          name = $1
+          value = $'
+          value = $1 if /\A'(.*)'\z/ =~ value or /\A"(.*)"\z/ =~ value
+          env[name] = value
+        end
+      end
+      new(entries, env)
+    end
+  end
+
+  def initialize(entries, env)
+    @entries = entries.dup.freeze
+    @env = env.dup.freeze
+  end
+  attr_reader :entries, :env
+end

data/spec/cronman/entry_spec.rb

@@ -0,0 +1,153 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'cronman/entry'
+require 'cronman/schedule'
+
+describe Cronman::Entry do
+  describe 'when instantiating' do
+    before :each do
+      @cron_definition = '0 0 * * *'
+      @schedule = Cronman::Schedule.new(@cron_definition) # @daily
+      @command = 'echo hello'
+    end
+
+    it 'should accpet Cronman::Schedule and command String' do
+      entry = Cronman::Entry.new(@schedule, @command, @cron_definition)
+      entry.uid.should == Process.uid
+    end
+
+    it 'should accpet Cronman::Schedule, command String and user String' do
+      uid = Process.uid
+      user = Etc.getpwuid(uid)
+      entry = Cronman::Entry.new(@schedule, @command, @cron_definition, user.name)
+      entry.uid.should == uid
+    end
+
+    it 'should accpet Cronman::Schedule, command String and user ID' do
+      uid = Process.uid
+      entry = Cronman::Entry.new(@schedule, @command, @cron_definition, uid)
+      entry.uid.should == uid
+    end
+
+    it 'should reject invalid arguments' do
+      lambda { Cronman::Entry.new(@schedule, nil) }.should raise_error(ArgumentError)
+      lambda { Cronman::Entry.new(@schedule, Object.new) }.should raise_error(ArgumentError)
+      lambda { Cronman::Entry.new(@schedule) }.should raise_error(ArgumentError)
+      lambda { Cronman::Entry.new(nil, @command) }.should raise_error(ArgumentError)
+      lambda { Cronman::Entry.new(Object.new, @command) }.should raise_error(ArgumentError)
+      lambda { Cronman::Entry.new(@command) }.should raise_error(ArgumentError)
+      lambda { Cronman::Entry.new }.should raise_error(ArgumentError)
+      lambda { Cronman::Entry.new(nil) }.should raise_error(ArgumentError)
+    end
+
+    describe 'by parsing' do
+      it 'should parse crontab entry line' do
+        entry = Cronman::Entry.parse('0 0 * * * echo hello')
+        entry.schedule.from(@schedule.start).should == @schedule and
+        entry.command.should == @command and
+        entry.uid.should == Process.uid
+
+        entry = Cronman::Entry.parse('0 0 * * * echo hello', :system => false)
+        entry.schedule.from(@schedule.start).should == @schedule and
+        entry.command.should == @command and
+        entry.uid.should == Process.uid
+      end
+
+      it 'should parse crontab entry line with symbolic schedule' do
+        entry = Cronman::Entry.parse('@daily echo hello')
+        entry.schedule.from(@schedule.start).should == @schedule and
+        entry.command.should == @command and
+        entry.uid.should == Process.uid
+
+        entry = Cronman::Entry.parse('0 0 * * * echo hello', :system => false)
+        entry.schedule.from(@schedule.start).should == @schedule and
+        entry.command.should == @command and
+        entry.uid.should == Process.uid
+      end
+
+      it 'should parse system crontab entry line' do
+        entry = Cronman::Entry.parse('0 0 * * * root echo hello', :system => true)
+        entry.schedule.from(@schedule.start).should == @schedule and
+        entry.command.should == @command and
+        entry.uid.should == Etc.getpwnam('root').uid
+      end
+
+      it 'should parse system crontab entry line with symbolic schedule' do
+        entry = Cronman::Entry.parse('@daily root echo hello', :system => true)
+        entry.schedule.from(@schedule.start).should == @schedule and
+        entry.command.should == @command and
+        entry.uid.should == Etc.getpwnam('root').uid
+      end
+
+      it 'should ignore leading whitespaces' do
+        entry = Cronman::Entry.parse('  @daily  echo hello')
+        entry.schedule.from(@schedule.start).should == @schedule and
+        entry.command.should == @command
+
+        entry = Cronman::Entry.parse('  0 0 * * *  echo hello')
+        entry.schedule.from(@schedule.start).should == @schedule and
+        entry.command.should == @command
+      end
+    end
+  end
+
+  describe 'when accessing' do
+    before :each do
+      @schedule = Cronman::Schedule.new('@hourly')
+      @other_schedule = Cronman::Schedule.new('@monthly')
+      @command = 'ehco hello'
+      @other_command = 'echo bonjour'
+      @cron_definition = '0 0 * * *'
+      @other_cron_definition = '0,30 0 * * *'
+      @translation = ['midnight', 'every day']
+      @other_translation = ['0 and 30 minutes past', 'midnight of', 'every day']
+      @entry = Cronman::Entry.new(@schedule, @command, @cron_definition)
+    end
+
+    it 'should be read-accessible to schedule' do
+      @entry.schedule.should == @schedule and
+      lambda { @entry.schedule = @other_schedule }.should raise_error(NoMethodError)
+      @entry.schedule.should == @schedule
+    end
+
+    it 'should freeze schedule' do
+      @entry.schedule.should be_frozen
+    end
+
+    it 'should be read-accessible to command' do
+      @entry.command.should == @command and
+      lambda { @entry.command = @other_command }.should raise_error(NoMethodError)
+      @entry.command.should == @command
+    end
+
+    it 'should freeze command' do
+      @entry.command.should be_frozen
+    end
+
+    it 'should be read-accessible to uid' do
+      @entry.uid.should == Process.uid and
+      Process.uid.should_not == 0 and
+      lambda { @entry.uid = 0 }.should raise_error(NoMethodError)
+      @entry.uid.should == Process.uid
+    end
+
+    it 'should be freeze cron_definition' do
+      @entry.cron_definition.should be_frozen
+    end
+
+    it 'should be read-accessible to cron_definition' do
+      @entry.cron_definition == @cron_definition and
+      lambda { @entry.cron_definition = @other_cron_definition }.should raise_error(NoMethodError)
+      @entry.cron_definition == @cron_definition
+    end
+
+    it 'should be freeze translation' do
+      @entry.translation.should be_frozen
+    end
+
+    it 'should be read-accessible to translation' do
+      @entry.translation == @translation and
+      lambda { @entry.translation = @other_translation }.should raise_error(NoMethodError)
+      @entry.translation == @translation
+    end
+  end
+end

data/spec/cronman/schedule_spec.rb

@@ -0,0 +1,356 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'cronman/schedule'
+
+describe Cronman::Schedule do
+  describe 'when parsing spec' do
+    it 'should accept spec with asterisks' do
+      schedule = Cronman::Schedule.new('* * * * *')
+      schedule.minutes.should == (0..59).to_a and
+      schedule.hours.should == (0..23).to_a and
+      schedule.day_of_months.should == (1..31).to_a and
+      schedule.months.should == (1..12).to_a and
+      schedule.day_of_weeks.should == (0..6).to_a
+    end
+
+    it 'should accept spec with simple numbers' do
+      schedule = Cronman::Schedule.new('0 0 1 1 0')
+      schedule.minutes.should == [0] and
+      schedule.hours.should == [0] and
+      schedule.day_of_months.should == [1] and
+      schedule.months.should == [1] and
+      schedule.day_of_weeks.should == [0]
+    end
+
+    it 'should accept spec with names(Jan, Sun etc.)' do
+      schedule = Cronman::Schedule.new('0 0 1 Jan sUn')
+      schedule.minutes.should == [0] and
+      schedule.hours.should == [0] and
+      schedule.day_of_months.should == [1] and
+      schedule.months.should == [1] and
+      schedule.day_of_weeks.should == [0]
+    end
+
+    it 'should accept spec with ranges(N-N)' do
+      schedule = Cronman::Schedule.new('0-1 0-1 1-2 1-2 0-1')
+      schedule.minutes.should == [0, 1] and
+      schedule.hours.should == [0, 1] and
+      schedule.day_of_months.should == [1, 2] and
+      schedule.months.should == [1, 2] and
+      schedule.day_of_weeks.should == [0, 1]
+    end
+
+    it 'should accept spec with lists(comma separaged ranges/numbers)' do
+      schedule = Cronman::Schedule.new('0,10,20 0,10,20 1,11,21 1,3,5 0,4,5,6')
+      schedule.minutes.should == [0, 10, 20] and
+      schedule.hours.should == [0, 10, 20] and
+      schedule.day_of_months.should == [1, 11, 21] and
+      schedule.months.should == [1, 3, 5] and
+      schedule.day_of_weeks.should == [0, 4, 5, 6]
+
+      schedule = Cronman::Schedule.new('0,1-5,10 0,1-5,10 1,2-5,10 1,2-4,10 0,1-3,7')
+      schedule.minutes.should == [0, 1, 2, 3, 4, 5, 10] and
+      schedule.hours.should == [0, 1, 2, 3, 4, 5, 10] and
+      schedule.day_of_months.should == [1, 2, 3, 4, 5, 10] and
+      schedule.months.should == [1, 2, 3, 4, 10] and
+      schedule.day_of_weeks.should == [0, 1, 2, 3]
+    end
+
+    it 'should accept spec with steps(range/STEP or */STEP)' do
+      schedule = Cronman::Schedule.new('0-30/10 1-20/5 5-30/7 4-10/2 1-5/2')
+      schedule.minutes.should == [0, 10, 20, 30] and
+      schedule.hours.should == [1, 6, 11, 16 ] and
+      schedule.day_of_months.should == [5, 12, 19, 26 ] and
+      schedule.months.should == [4, 6, 8, 10] and
+      schedule.day_of_weeks.should == [1, 3, 5]
+
+      schedule = Cronman::Schedule.new('*/25 */5 */10 */4 */2')
+      schedule.minutes.should == [0, 25, 50] and
+      schedule.hours.should == [0, 5, 10, 15, 20] and
+      schedule.day_of_months.should == [1, 11, 21, 31] and
+      schedule.months.should == [1, 5, 9] and
+      schedule.day_of_weeks.should == [0, 2, 4, 6]
+    end
+
+    it 'should reject spec with incorrect number of fields' do
+      lambda { Cronman::Schedule.new }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new(nil) }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('x') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('* * * *') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('* * * * * *') }.should raise_error(ArgumentError)
+    end
+
+    it 'should reject spec with incorrect values' do
+      lambda { Cronman::Schedule.new('x 0 1 0 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('-1 0 1 1 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('60 0 1 1 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 24 1 1 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 32 1 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1 13 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1 1 8') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1 Mon 8') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('Jan Sun 1 1 8') }.should raise_error(ArgumentError)
+    end
+
+    it 'should reject spec with names in lists and ranges' do
+      lambda { Cronman::Schedule.new('0 0 1 Jan-Feb *') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1 Jan,Feb *') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1 * Sun-Fri') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1 * Sun,Fri') }.should raise_error(ArgumentError)
+    end
+
+    it 'should reject spec with simple numbers with step' do
+      lambda { Cronman::Schedule.new('0/2 0 1 1 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0/2 1 1 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1/2 1 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1 1/2 0') }.should raise_error(ArgumentError)
+      lambda { Cronman::Schedule.new('0 0 1 1 0/2') }.should raise_error(ArgumentError)
+    end
+
+    it 'should accept symblic specs' do
+      start = Time.now
+      Cronman::Schedule.new('@yearly', start).should == Cronman::Schedule.new('0 0 1 1 *', start) and
+      Cronman::Schedule.new('@annually', start).should == Cronman::Schedule.new('0 0 1 1 *', start) and
+      Cronman::Schedule.new('@monthly', start).should == Cronman::Schedule.new('0 0 1 * *', start) and
+      Cronman::Schedule.new('@weekly', start).should == Cronman::Schedule.new('0 0 * * 0', start) and
+      Cronman::Schedule.new('@daily', start).should == Cronman::Schedule.new('0 0 * * *', start) and
+      Cronman::Schedule.new('@midnight', start).should == Cronman::Schedule.new('0 0 * * *', start) and
+      Cronman::Schedule.new('@hourly', start).should == Cronman::Schedule.new('0 * * * *', start)
+    end
+
+    it 'should reject @reboot' do
+      lambda { Cronman::Schedule.new('@reboot') }.should raise_error(NotImplementedError)
+    end
+
+    it 'should reject unknown symbolic spec' do
+      lambda { Cronman::Schedule.new('@unknown') }.should raise_error(ArgumentError)
+    end
+
+    it 'should ignore leading/trailing whitespaces' do
+      lambda {
+        Cronman::Schedule.new(' @daily')
+        Cronman::Schedule.new('@daily ')
+        Cronman::Schedule.new(' * * * * *')
+        Cronman::Schedule.new('* * * * * ')
+      }.should_not raise_error
+    end
+  end
+
+  describe 'when accessing' do
+    it 'should accept Time as start parameter' do
+      start = Time.local(2009, 3, 25, 10, 20, 30)
+      lambda {
+        schedule = Cronman::Schedule.new('* * * * *', start)
+        schedule.start.should == start
+      }.should_not raise_error
+    end
+
+    it 'should accept Date as start parameter' do
+      start = Date.new(2009, 3, 25)
+      lambda {
+        schedule = Cronman::Schedule.new('* * * * *', start)
+        schedule.start.should == Time.local(start.year, start.month, start.day)
+      }.should_not raise_error
+    end
+
+    it 'should set start to given Time' do
+      initial_start = Time.local(2009, 3, 25, 10, 20, 30)
+      schedule = Cronman::Schedule.new('* * * * *', initial_start)
+      schedule.start.should == initial_start and
+
+      new_start = Time.local(2009, 4, 25, 11, 21, 31)
+      schedule.start = new_start
+      schedule.start.should == new_start
+    end
+
+    it 'should set start to given Date' do
+      initial_start = Time.local(2009, 3, 25, 10, 20, 30)
+      schedule = Cronman::Schedule.new('* * * * *', initial_start)
+      schedule.start.should == initial_start and
+
+      new_start = Date.new(2009, 4, 25)
+      new_start_as_time = Time.local(new_start.year, new_start.month, new_start.day)
+      schedule.start = new_start
+      schedule.start.should == new_start_as_time
+    end
+  end
+
+  describe 'when duplicating' do
+    it 'should return a new schedule starting at given Time' do
+      initial_start = Time.local(2009, 3, 25, 10, 20, 30)
+      schedule = Cronman::Schedule.new('* * * * *', initial_start)
+      new_start = Time.local(2009, 4, 25, 11, 21, 31)
+      new_schedule = schedule.from(new_start)
+
+      new_schedule.object_id.should_not == schedule.object_id and
+      new_schedule.hash.should_not == schedule.hash and
+      new_schedule.should_not == schedule and
+
+      new_schedule.start.should == new_start and
+      new_schedule.minutes.should == schedule.minutes and
+      new_schedule.hours.should == schedule.hours and
+      new_schedule.day_of_months.should == schedule.day_of_months and
+      new_schedule.months.should == schedule.months and
+      new_schedule.day_of_weeks.should == schedule.day_of_weeks and
+      new_schedule.send(:day_of_months_given?).should == schedule.send(:day_of_months_given?) and
+      new_schedule.send(:day_of_weeks_given?).should == schedule.send(:day_of_weeks_given?)
+    end
+
+    it 'should return a new schedule starting at given Date' do
+      initial_start = Time.local(2009, 3, 25, 10, 20, 30)
+      schedule = Cronman::Schedule.new('* * * * *', initial_start)
+      new_start = Date.new(2009, 4, 25)
+      new_start_as_time = Time.local(new_start.year, new_start.month, new_start.day)
+      new_schedule = schedule.from(new_start)
+
+      new_schedule.object_id.should_not == schedule.object_id and
+      new_schedule.hash.should_not == schedule.hash and
+      new_schedule.should_not == schedule and
+
+      new_schedule.start.should == new_start_as_time and
+      new_schedule.minutes.should == schedule.minutes and
+      new_schedule.hours.should == schedule.hours and
+      new_schedule.day_of_months.should == schedule.day_of_months and
+      new_schedule.months.should == schedule.months and
+      new_schedule.day_of_weeks.should == schedule.day_of_weeks and
+      new_schedule.send(:day_of_months_given?).should == schedule.send(:day_of_months_given?) and
+      new_schedule.send(:day_of_weeks_given?).should == schedule.send(:day_of_weeks_given?)
+    end
+  end
+
+  describe 'when comparing' do
+    it 'should equal to other if and only if both are created from equivalent spec and start time' do
+      start = Time.now
+      Cronman::Schedule.new('0 0 1 1 0', start).should == Cronman::Schedule.new('0 0 1 1 0', start) and
+      Cronman::Schedule.new('0 0 1 1 0', start).should == Cronman::Schedule.new('0 0 1 Jan 0', start) and
+      Cronman::Schedule.new('0 0 1 1 0', start).should == Cronman::Schedule.new('0 0 1 1 Sun', start) and
+
+      Cronman::Schedule.new('0 0 1 1 0', start).should_not == Cronman::Schedule.new('1 0 1 1 0', start) and
+      Cronman::Schedule.new('0 0 1 1 0', start).should_not == Cronman::Schedule.new('0 1 1 1 0', start) and
+      Cronman::Schedule.new('0 0 1 1 0', start).should_not == Cronman::Schedule.new('0 0 2 1 0', start) and
+      Cronman::Schedule.new('0 0 1 1 0', start).should_not == Cronman::Schedule.new('0 0 1 2 0', start) and
+      Cronman::Schedule.new('0 0 1 1 0', start).should_not == Cronman::Schedule.new('0 0 1 1 1', start) and
+
+      Cronman::Schedule.new('0 0 1-5 1 0', start).should == Cronman::Schedule.new('0 0 1,2,3,4,5 1 0', start) and
+      Cronman::Schedule.new('0 0 1 1 0-4', start).should == Cronman::Schedule.new('0 0 1 1 0,1,2,3,4', start)
+    end
+  end
+
+  describe 'when enumerating' do
+    it 'should return given number of timings' do
+      schedule = Cronman::Schedule.new('* * * * *', Time.local(2009, 3, 8, 4, 30, 15))
+      expected = [
+        Time.local(2009, 3, 8, 4, 31),
+        Time.local(2009, 3, 8, 4, 32),
+        Time.local(2009, 3, 8, 4, 33),
+        Time.local(2009, 3, 8, 4, 34),
+        Time.local(2009, 3, 8, 4, 35),
+      ]
+      schedule.first(expected.size).should == expected and
+
+      schedule = Cronman::Schedule.new('5 10 3-5,10 * *', Time.local(2009, 3, 8, 10, 30, 15))
+      expected = [
+        Time.local(2009, 3, 10, 10, 5),
+        Time.local(2009, 4,  3, 10, 5),
+        Time.local(2009, 4,  4, 10, 5),
+        Time.local(2009, 4,  5, 10, 5),
+        Time.local(2009, 4, 10, 10, 5),
+        Time.local(2009, 5,  3, 10, 5),
+        Time.local(2009, 5,  4, 10, 5),
+        Time.local(2009, 5,  5, 10, 5),
+        Time.local(2009, 5, 10, 10, 5),
+        Time.local(2009, 6,  3, 10, 5),
+      ]
+      schedule.first(expected.size).should == expected
+    end
+
+    it 'should return timings matching day of month or day of week' do
+      schedule = Cronman::Schedule.new('0 0 1,10,11 3 0,1', Time.local(2009, 3, 8, 10, 30, 15))
+      expected = [
+        Time.local(2009, 3,  9, 0, 0),
+        Time.local(2009, 3, 10, 0, 0),
+        Time.local(2009, 3, 11, 0, 0),
+        Time.local(2009, 3, 15, 0, 0),
+        Time.local(2009, 3, 16, 0, 0),
+        Time.local(2009, 3, 22, 0, 0),
+        Time.local(2009, 3, 23, 0, 0),
+        Time.local(2009, 3, 29, 0, 0),
+        Time.local(2009, 3, 30, 0, 0),
+      ]
+      schedule.first(expected.size).should == expected and
+
+      schedule = Cronman::Schedule.new('0 0 1,10,11 3 *', Time.local(2009, 3, 8, 10, 30, 15))
+      expected = [
+        Time.local(2009, 3, 10, 0, 0),
+        Time.local(2009, 3, 11, 0, 0),
+      ]
+      schedule.first(expected.size).should == expected and
+
+      schedule = Cronman::Schedule.new('0 0 * 3 0,1', Time.local(2009, 3, 8, 10, 30, 15))
+      expected = [
+        Time.local(2009, 3,  9, 0, 0),
+        Time.local(2009, 3, 15, 0, 0),
+        Time.local(2009, 3, 16, 0, 0),
+        Time.local(2009, 3, 22, 0, 0),
+        Time.local(2009, 3, 23, 0, 0),
+        Time.local(2009, 3, 29, 0, 0),
+        Time.local(2009, 3, 30, 0, 0),
+      ]
+      schedule.first(expected.size).should == expected
+    end
+
+    it 'should return timings until given time' do
+      schedule = Cronman::Schedule.new('* * * * *', Time.local(2009, 3, 8, 4, 30, 15))
+      expected = [
+        Time.local(2009, 3, 8, 4, 31),
+        Time.local(2009, 3, 8, 4, 32),
+        Time.local(2009, 3, 8, 4, 33),
+        Time.local(2009, 3, 8, 4, 34),
+        Time.local(2009, 3, 8, 4, 35),
+        Time.local(2009, 3, 8, 4, 36),
+        Time.local(2009, 3, 8, 4, 37),
+        Time.local(2009, 3, 8, 4, 38),
+        Time.local(2009, 3, 8, 4, 39),
+        Time.local(2009, 3, 8, 4, 40),
+      ]
+      schedule.until(Time.local(2009, 3, 8, 4, 40, 10)).should == expected and
+
+      result = []
+      schedule.until(Time.local(2009, 3, 8, 4, 40, 10)) do |t|
+        result << t
+      end
+      result.should == expected and
+
+      schedule = Cronman::Schedule.new('*/20 0 21 * *', Time.local(2009, 3, 8, 4, 30, 15))
+      expected = [
+        Time.local(2009, 3, 21, 0,  0),
+        Time.local(2009, 3, 21, 0, 20),
+        Time.local(2009, 3, 21, 0, 40),
+        Time.local(2009, 4, 21, 0,  0),
+        Time.local(2009, 4, 21, 0, 20),
+        Time.local(2009, 4, 21, 0, 40),
+        Time.local(2009, 5, 21, 0, 00),
+        Time.local(2009, 5, 21, 0, 20),
+        Time.local(2009, 5, 21, 0, 40),
+      ]
+      schedule.until(Time.local(2009, 6, 1)).should == expected
+    end
+
+    it 'should exclude invalid day of month' do
+      schedule = Cronman::Schedule.new('5 0 27,29,31 * *', Time.local(2009, 1, 1, 10, 30, 15))
+      expected = [
+        Time.local(2009, 1, 27, 0, 5),
+        Time.local(2009, 1, 29, 0, 5),
+        Time.local(2009, 1, 31, 0, 5),
+        Time.local(2009, 2, 27, 0, 5),
+        # Time.local(2009, 2, 29, 0, 5), # should exclude this!
+        # Time.local(2009, 2, 31, 0, 5), # should exclude this!
+        Time.local(2009, 3, 27, 0, 5),
+        Time.local(2009, 3, 29, 0, 5),
+        Time.local(2009, 3, 31, 0, 5),
+      ]
+
+      schedule.first(expected.size).should == expected
+    end
+  end
+end

data/spec/cronman_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'cronman'
+
+describe Cronman do
+  describe 'parsing' do
+    it 'should recognize entries' do
+      crontab = Cronman.parse(File.read('spec/data/crontab.txt'))
+      crontab.entries.size.should == 5 and
+      crontab.entries.should be_frozen
+      crontab.entries[0].tap do |e|
+        e.schedule.minutes.should == [8] and
+        e.schedule.hours.should == [3] and
+        e.schedule.day_of_months.should == (1..31).to_a and
+        e.schedule.months.should == (1..12).to_a and
+        e.schedule.day_of_weeks.should == [6]
+      end
+    end
+
+    it 'should recognize variables assignments' do
+      crontab = Cronman.parse(File.read('spec/data/crontab.txt'))
+      crontab.env.should == {
+        'SHELL' => '/bin/zsh',
+        'MAIL_TO' => 'nobody@example.com',
+        'FOO' => 'foo',
+        'BAR' => 'bar',
+        'BAZ' => 'baz'
+      }
+    end
+  end
+end
+# 8 3 * * 6 run-parts $HOME/.cron.d/weekly
+# 50 2 * * * run-parts $HOME/.cron.d/daily
+# 3 * * * * run-parts $HOME/.cron.d/hourly
+#
+# */5 * * * * curl -sI http://example.com >/dev/null
+#
+# * * * * * awk 'BEGIN{ srand(); exit(rand() * 24 * 60.0 < 12.0 ? 0 : 1); }' && fortune

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: cronman
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Renato Moya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cron2english
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+description: 
+email: imexto@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cronman.rb
+- lib/cronman/entry.rb
+- lib/cronman/schedule.rb
+- spec/cronman_spec.rb
+- spec/cronman/entry_spec.rb
+- spec/cronman/schedule_spec.rb
+- cronman.gemspec
+- Rakefile
+- README.md
+homepage: http://github.com/renatomoya/cronman
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: n/a
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A crontab(5) entry parser
+test_files: []