ice_cube_cron 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7aa5090dd5b494487fe66f7f731bed0b90b59ce
-  data.tar.gz: 7822df6b8b1d227cb23ad9e64f7db313084476b6
+  metadata.gz: 75073a57e6693975beb5f23a78daf4aa3e82fbf8
+  data.tar.gz: 8a6a29270f4b92bd20b4642307d3cf8e79d6c80b
 SHA512:
-  metadata.gz: 92b1a9335aaa0dbc98bcb5ef7966d17da696567158c7afd6e1308b19d2118564928cd233e89e19017a4da8bba3003c1761057156a0f8d9d43d2e1a9031a08281
-  data.tar.gz: f884daabb064dc2ab03802bef9cf9361cd05ac1b2e85d91e190b1d35d28fb67b19ac29940cb9f2e5561b44c0da6ce386ce9ebc5569ce45314a2657e89ce6c7c1
+  metadata.gz: 06a51ee2d28f4725be2058c6009ea2eedddd8a35634690492e001132078aef5e404651530a2286f7a9c606b37e14c60169d7e3ffadcf15703f12867ca931c1cd
+  data.tar.gz: aa95de45173bfb490d5e7fb29058126af81a2b9a2d8f4af5fbee8381435310117b5d5b3ce0f5338f0d633aa1f0960fbbb864c455ba71850e0a74ed18c4c5df63

data/.rdoc_options

@@ -0,0 +1,25 @@
+--- !ruby/object:RDoc::Options
+encoding: UTF-8
+static_path: []
+rdoc_include:
+- ./README.md
+- "/Users/matthewnichols/Code/ice_cube_cron/."
+charset: UTF-8
+exclude:
+- ./Gemfile*
+- ./Guardfile
+hyperlink_all: false
+line_numbers: false
+locale:
+locale_dir: locale
+locale_name:
+main_page: README.md
+markup: markdown
+output_decoration: true
+page_dir:
+show_hash: false
+tab_width: 8
+template_stylesheets: []
+title:
+visibility: :protected
+webcvs:

data/.rubocop.yml

@@ -8,6 +8,9 @@ Style/AccessModifierIndentation:
   EnforcedStyle: outdent
 
 Style/Documentation:
+  Enabled: true
+
+Style/SignalException:
   Enabled: false
 
 Metrics/LineLength:
@@ -15,3 +18,4 @@ Metrics/LineLength:
 
 Metrics/MethodLength:
   Max: 15
+

data/Gemfile

@@ -1,11 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-# DEVUP--
-gem 'guard-zeus', :group => :development
-gem 'guard-rspec', :group => :development
-gem 'guard-rubocop', :group => :development
-gem 'rb-fsevent', :group => :development
-gem 'terminal-notifier-guard', :group => :development
-gem 'wirble', :group => :development
-# --DEVUP

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ice_cube_cron (0.0.1)
+    ice_cube_cron (0.0.2)
       activesupport (>= 3.0.0)
       ice_cube (= 0.13.0)
 
@@ -19,42 +19,11 @@ GEM
       parser (~> 2.2)
     coderay (1.1.0)
     diff-lcs (1.2.5)
-    ffi (1.9.10)
-    formatador (0.2.5)
-    guard (2.13.0)
-      formatador (>= 0.2.4)
-      listen (>= 2.7, <= 4.0)
-      lumberjack (~> 1.0)
-      nenv (~> 0.1)
-      notiffany (~> 0.0)
-      pry (>= 0.9.12)
-      shellany (~> 0.0)
-      thor (>= 0.18.1)
-    guard-compat (1.2.1)
-    guard-rspec (4.6.4)
-      guard (~> 2.1)
-      guard-compat (~> 1.1)
-      rspec (>= 2.99.0, < 4.0)
-    guard-rubocop (1.2.0)
-      guard (~> 2.0)
-      rubocop (~> 0.20)
-    guard-zeus (2.0.1)
-      guard (~> 2.0)
-      guard-compat (~> 1.1)
-      zeus (~> 0)
     i18n (0.7.0)
     ice_cube (0.13.0)
     json (1.8.3)
-    listen (3.0.3)
-      rb-fsevent (>= 0.9.3)
-      rb-inotify (>= 0.9)
-    lumberjack (1.0.9)
     method_source (0.8.2)
     minitest (5.8.1)
-    nenv (0.2.0)
-    notiffany (0.0.8)
-      nenv (~> 0.1)
-      shellany (~> 0.0)
     parser (2.2.3.0)
       ast (>= 1.1, < 3.0)
     powerpack (0.1.1)
@@ -64,9 +33,6 @@ GEM
       slop (~> 3.4)
     rainbow (2.0.0)
     rake (10.4.2)
-    rb-fsevent (0.9.6)
-    rb-inotify (0.9.5)
-      ffi (>= 0.5.0)
     rspec (3.3.0)
       rspec-core (~> 3.3.0)
       rspec-expectations (~> 3.3.0)
@@ -87,32 +53,20 @@ GEM
       rainbow (>= 1.99.1, < 3.0)
       ruby-progressbar (~> 1.4)
     ruby-progressbar (1.7.5)
-    shellany (0.0.1)
     slop (3.6.0)
-    terminal-notifier-guard (1.6.4)
-    thor (0.19.1)
     thread_safe (0.3.5)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
-    wirble (0.1.3)
-    zeus (0.15.4)
-      method_source (>= 0.6.7)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  guard-rspec
-  guard-rubocop
-  guard-zeus
   ice_cube_cron!
   pry
   rake
-  rb-fsevent
   rspec
   rubocop
-  terminal-notifier-guard
-  wirble
 
 BUNDLED WITH
    1.10.6

data/README.md

@@ -1,10 +1,12 @@
+[![Gem Version](https://badge.fury.io/rb/ice_cube_cron.svg)](https://badge.fury.io/rb/ice_cube_cron)
+
 # ice_cube_cron
 
 Adds new methods to ice_cube to create schedules using standard cron expressions.
 
 ## description
 
-**ice_cube** is a sold library for projecting and querying recurrence rules. **Cron** is _the_ standard for expressing recurrence rules. This gem will allow you to generate ice_cube schedules using standard cron expressions [explained here](https://en.wikipedia.org/wiki/Cron). This includes range expressions, series expressions, "last" day of month, Nth weekday of month, etc.
+**[ice_cube](https://github.com/seejohnrun/ice_cube)** is a sold library for projecting and querying recurrence rules. **[Cron](https://en.wikipedia.org/wiki/Cron)** is _the_ standard for expressing recurrence rules. This gem will allow you to generate ice_cube schedules using standard cron expressions [explained here](https://en.wikipedia.org/wiki/Cron). This includes range expressions, series expressions, "last" day of month, Nth weekday of month, etc.
 
 PLEASE NOTE:
 This gem is a work-in-progress. Many features have yet to be implemented.
@@ -19,7 +21,6 @@ or add to Gemfile
 
 ## example
 
-Cron expression can be specified using a hash or a string in the format:
 ```
  # * * * * * *  command to execute
  # │ │ │ │ │ │
@@ -31,9 +32,12 @@ Cron expression can be specified using a hash or a string in the format:
  # │ └──────────────────── hour (0 - 23)
  # └───────────────────────── min (0 - 59)
 ```
+
 *[chart source](https://en.wikipedia.org/wiki/Cron)*
 
 
+Cron expression can be specified using a hash or a string in the format:
+
 ```ruby
 require 'ice_cube_cron'
 

data/lib/ice_cube_cron/base.rb

@@ -1,4 +1,4 @@
-module IceCube
+module IceCube # :nodoc: all
   class Schedule
     extend ::IceCubeCron::Extension
   end

data/lib/ice_cube_cron/expression_parser.rb

@@ -1,92 +1,106 @@
-module IceCubeCron
+module IceCubeCron # :nodoc:
+  ##
+  # Parses the incoming expression and splits it into meaningful parts.
+  #
   class ExpressionParser
-    attr_accessor :expression_hash
-
-    def initialize(exp)
-      self.expression_hash = {
-        :repeat_interval => 1,
-        :repeat_year => nil,
-        :repeat_month => nil,
-        :repeat_day => nil,
-        :repeat_weekday => nil
-      }
-
-      if exp.is_a?(::Hash)
-        exp.each do |name, val|
-          send("#{name}=", val)
-        end
-      elsif exp.is_a?(::String)
-        fail ArgumentError, 'string cron expressions are not yet supported'
+    include ::IceCubeCron::ParserAttribute
+
+    EXPRESSION_PART_DEFAULTS = {
+      :repeat_interval => 1,
+      :repeat_year => nil,
+      :repeat_month => nil,
+      :repeat_day => nil,
+      :repeat_weekday => nil,
+      :repeat_until => nil
+    }
+
+    EXPRESSION_PART_KEYS = [
+      :repeat_minute,
+      :repeat_hour,
+      :repeat_day,
+      :repeat_month,
+      :repeat_weekday,
+      :repeat_year
+    ]
+
+    ##
+    # Create a parsed expression
+    #
+    # Takes a hash of cron expression parts.
+    #
+    # ### Expression values:
+    # - interval
+    # - year
+    # - month
+    # - day
+    # - weekday
+    def initialize(*expression)
+      expression_parts = expression.last.is_a?(::Hash) ? expression.last : {}
+
+      expression_str = expression[0].is_a?(::String) ? expression[0] : nil
+      expression_parts.merge!(string_to_expression_parts(expression_str))
+
+      self.expression_hash = EXPRESSION_PART_DEFAULTS.dup
+
+      expression_parts.each do |name, val|
+        send("#{name}=", val)
       end
     end
 
-    def [](val_name)
-      send(val_name)
+    parser_attribute_accessor :interval do |val|
+      ExpressionParser.sanitize_integer_param(val, 1)
     end
 
-    def []=(val_name, new_val)
-      send("#{val_name}=", new_val)
+    parser_attribute_accessor :day do |val|
+      ExpressionParser.sanitize_day_param(val)
     end
 
-    def interval
-      expression_hash[:repeat_interval]
+    parser_attribute_accessor :month do |val|
+      ExpressionParser.sanitize_integer_array_param(val)
     end
-    alias_method :repeat_interval, :interval
 
-    def interval=(val)
-      expression_hash[:repeat_interval] = sanitize_integer_param(val, 1)
-    end
-    alias_method :repeat_interval=, :interval=
+    parser_attribute_accessor :until
 
-    def day
-      expression_hash[:repeat_day]
+    parser_attribute_accessor :year do |val|
+      ExpressionParser.sanitize_integer_array_param(val)
     end
-    alias_method :repeat_day, :day
 
-    def day=(val)
-      expression_hash[:repeat_day] = sanitize_day_param(val)
+    parser_attribute_accessor :weekday do |val|
+      ExpressionParser.sanitize_week_day_param(val)
     end
-    alias_method :repeat_day=, :day=
 
-    def month
-      expression_hash[:repeat_month]
-    end
-    alias_method :repeat_month, :month
+    ##
+    # Split string expression into parts
+    #
+    def string_to_expression_parts(expression_str)
+      return {} if expression_str.nil?
 
-    def month=(val)
-      expression_hash[:repeat_month] = sanitize_integer_array_param(val)
-    end
-    alias_method :repeat_month=, :month=
+      parts = expression_str.split(/ +/)
 
-    def year
-      expression_hash[:repeat_year]
-    end
-    alias_method :repeat_year, :year
-
-    def year=(val)
-      expression_hash[:repeat_year] = sanitize_integer_array_param(val)
-    end
-    alias_method :repeat_year=, :year=
+      expression_parts = ::Hash[EXPRESSION_PART_KEYS.zip(parts)]
+      expression_parts.select! do |_key, value|
+        next false if value.nil?
+        next false if value == '*'
 
-    def weekday
-      expression_hash[:repeat_weekday]
-    end
-    alias_method :repeat_weekday, :weekday
+        true
+      end
 
-    def weekday=(val)
-      expression_hash[:repeat_weekday] = sanitize_week_day_param(val)
+      expression_parts
     end
-    alias_method :repeat_weekday=, :weekday=
-
-  private
 
-    def sanitize_integer_param(param, default = nil)
+    ##
+    # Sanitize given value to an integer
+    #
+    def self.sanitize_integer_param(param, default = nil)
       return default if param.blank?
 
       param.to_i
     end
 
-    def sanitize_day_param(param)
+    ##
+    # Sanitize given value to a valid day parameter
+    #
+    def self.sanitize_day_param(param)
       return nil if param.blank?
       return param if param.is_a?(::Array)
       return [param] if param.is_a?(::Integer)
@@ -94,30 +108,47 @@ module IceCubeCron
       param.to_s.split(',').map do |element|
         next -1 if element == 'L'
 
-        element.to_i
-      end
+        ExpressionParser.sanitize_integer_array_param(element)
+      end.flatten.uniq
     end
 
-    def sanitize_week_day_param(param)
+    ##
+    # Sanitize given value to a valid weekday parameter
+    #
+    def self.sanitize_week_day_param(param)
       return nil if param.blank?
       param.to_s.split(',').map do |element|
         if element =~ /[0-9]+#[0-9]+/
           parts = element.split('#')
-          { sanitize_integer_param(parts[0]) => sanitize_integer_array_param(parts[1]) }
+          { ExpressionParser.sanitize_integer_param(parts[0]) => ExpressionParser.sanitize_integer_array_param(parts[1]) }
         elsif element =~ /[0-9]+L/
-          { sanitize_integer_param(element) => [-1] }
+          { ExpressionParser.sanitize_integer_param(element) => [-1] }
         else
-          sanitize_integer_param(element)
+          ExpressionParser.sanitize_integer_param(element)
         end
       end
     end
 
-    def sanitize_integer_array_param(param)
+    ##
+    # Sanitize given value to an integer array
+    #
+    #--
+    # rubocop:disable Metrics/AbcSize
+    #++
+    def self.sanitize_integer_array_param(param)
       return nil if param.blank?
       return param if param.is_a?(::Array)
       return [param] if param.is_a?(::Integer)
 
-      param.split(',').map(&:to_i)
+      param.split(',').map do |element|
+        if element =~ /[0-9]+\-[0-9]+/
+          parts = element.split('-')
+          (parts[0].to_i..parts[1].to_i).to_a
+        else
+          element.to_i
+        end
+      end.flatten.uniq
     end
+    # rubocop:enable Metrics/AbcSize
   end
 end

data/lib/ice_cube_cron/extension.rb

@@ -1,8 +1,26 @@
-module IceCubeCron
+module IceCubeCron # :nodoc:
+  ##
+  # This adds the `.from_cron` extension to the `::IceCube::Schedule` class
+  #
   module Extension
-    def from_cron(start_time, expression = {})
-      expression_parser = ::IceCubeCron::ExpressionParser.new(expression)
-      rule = ::IceCubeCron::RuleBuilder.new.build_rule(expression_parser)
+    ##
+    # Generates an ::IceCube::Schedule from a cron expression_parts
+    #
+    # :args: start_time, expression_parts
+    #
+    # ## Examples
+    #
+    # ```ruby
+    # schedule = ::IceCube::Schedule.from_cron(::Date.current, "* * * * 5")
+    #
+    # schedule = ::IceCube::Schedule.from_cron(::Date.new(2015, 1, 5), :repeat_day => 5)
+    #
+    # schedule.occurrences_between(::Date.new(2015, 3, 5), ::Date.new(2015, 6, 5))
+    # # => [2015-03-05 00:00:00 UTC, 2015-04-05 00:00:00 UTC, 2015-05-05 00:00:00 UTC, 2015-06-05 00:00:00 UTC]
+    #
+    def from_cron(start_time, *expression_parts)
+      expression = ::IceCubeCron::ExpressionParser.new(*expression_parts)
+      rule = ::IceCubeCron::RuleBuilder.new.build_rule(expression)
 
       schedule = ::IceCube::Schedule.new(::IceCubeCron::Util.sanitize_date_param(start_time))
       schedule.add_recurrence_rule(rule)

data/lib/ice_cube_cron/parser_attribute.rb

@@ -0,0 +1,28 @@
+module IceCubeCron # :nodoc: all
+  module ParserAttribute # :nodoc:
+    def self.included(base)
+      base.extend(::IceCubeCron::ParserAttribute::ClassMethods)
+    end
+
+    attr_accessor :expression_hash
+
+    module ClassMethods # :nodoc:
+      def parser_attribute_accessor(attr_name, &cleanser)
+        getter = "repeat_#{attr_name}".to_sym
+        setter = "repeat_#{attr_name}=".to_sym
+
+        define_method(getter) do
+          expression_hash[getter]
+        end
+
+        define_method(setter) do |val|
+          val = cleanser.call(val) if cleanser
+          expression_hash[getter] = val
+        end
+
+        alias_method attr_name, getter
+        alias_method "#{attr_name}=".to_sym, setter
+      end
+    end
+  end
+end

data/lib/ice_cube_cron/rule_builder.rb

@@ -1,34 +1,54 @@
-module IceCubeCron
+module IceCubeCron # :nodoc:
+  ##
+  # Generates Rules based on parsed expression
+  #
   class RuleBuilder
-    def build_rule(params)
-      rule = build_root_recurrence_rule(params)
-      rule = rule.month_of_year(*params[:month]) unless params[:month].blank?
-      rule = rule.day_of_month(*params[:day]) unless params[:day].blank?
-      rule = build_weekday_rule(rule, params)
+    ##
+    # Generates a rule based on a parsed expression
+    #
+    def build_rule(expression)
+      rule = build_root_recurrence_rule(expression)
+      rule = build_yearly_rules(rule, expression)
+      rule = build_weekday_rule(rule, expression)
+      rule = rule.day_of_month(*expression.day) unless expression.day.blank?
+      rule = rule.until(expression.until) unless expression.until.blank?
 
       rule
     end
 
-    def build_weekday_rule(rule, params)
-      return rule.day_of_week(*params[:weekday]) if !params[:weekday].blank? && nth_day?(params[:weekday])
-      return rule.day(*params[:weekday]) unless params[:weekday].blank?
+    # :nodoc:
+    def nth_day?(param)
+      return false if param.nil? || param.empty?
+      param[0].is_a?(::Hash)
+    end
+
+  private
+
+    # :nodoc:
+    def build_weekday_rule(rule, expression)
+      return rule.day_of_week(*expression.weekday) if !expression.weekday.blank? && nth_day?(expression.weekday)
+      return rule.day(*expression.weekday) unless expression.weekday.blank?
 
       rule
     end
 
-    # rubocop:disable Metrics/AbcSize
-    def build_root_recurrence_rule(params)
-      return ::IceCube::Rule.yearly(params[:interval]) unless params[:month].blank?
-      return ::IceCube::Rule.monthly(params[:interval]) if !params[:weekday].blank? && nth_day?(params[:weekday])
-      return ::IceCube::Rule.weekly(params[:interval]) unless params[:weekday].blank?
+    # :nodoc:
+    def build_yearly_rules(rule, expression)
+      rule = rule.year(*expression.year) unless expression.year.blank?
+      rule = rule.month_of_year(*expression.month) unless expression.month.blank?
 
-      ::IceCube::Rule.monthly(params[:interval])
+      rule
     end
-    # rubocop:enable Metrics/AbcSize
 
-    def nth_day?(param)
-      return false if param.nil? || param.empty?
-      param[0].is_a?(::Hash)
+    # rubocop:disable Metrics/AbcSize
+    def build_root_recurrence_rule(expression) # :nodoc:
+      return ::IceCube::Rule.yearly(expression.interval) unless expression.month.blank?
+      return ::IceCube::Rule.monthly(expression.interval) if !expression.weekday.blank? && nth_day?(expression.weekday)
+      return ::IceCube::Rule.monthly(expression.interval) unless expression.day.blank?
+      return ::IceCube::Rule.weekly(expression.interval) unless expression.weekday.blank?
+
+      ::IceCube::Rule.monthly(expression.interval)
     end
+    # rubocop:enable Metrics/AbcSize
   end
 end

data/lib/ice_cube_cron/util.rb

@@ -1,4 +1,7 @@
-module IceCubeCron
+module IceCubeCron # :nodoc: all
+  ##
+  # :category: Utilities
+  #
   module Util
     def self.sanitize_date_param(date)
       date = date.to_time(:utc) if date.is_a?(::Date) && !date.is_a?(::DateTime)

data/lib/ice_cube_cron/version.rb

@@ -1,3 +1,3 @@
-module IceCubeCron
-  VERSION = '0.0.2'
+module IceCubeCron # :nodoc: all
+  VERSION = '0.0.3'
 end

data/lib/ice_cube_cron.rb

@@ -1,11 +1,17 @@
 require 'ice_cube'
 
+# core extensions
 require 'active_support/core_ext/date'
 require 'active_support/core_ext/integer'
 
+# ice_cube extentions
+require 'ice_cube_ext/validations/year.rb'
+require 'ice_cube_ext/validated_rule.rb'
+
 require 'ice_cube_cron/version'
 require 'ice_cube_cron/util'
 require 'ice_cube_cron/rule_builder'
+require 'ice_cube_cron/parser_attribute'
 require 'ice_cube_cron/expression_parser'
 require 'ice_cube_cron/extension'
 require 'ice_cube_cron/base'

data/lib/ice_cube_ext/validated_rule.rb

@@ -0,0 +1,5 @@
+module IceCube
+  class ValidatedRule < Rule # :nodoc:
+    include Validations::Year
+  end
+end

data/lib/ice_cube_ext/validations/year.rb

@@ -0,0 +1,55 @@
+module IceCube
+  module Validations
+    ##
+    # Allows addition of a year (non-standard cron) to the repeat rules.
+    #
+    module Year
+      ##
+      # Call to filter occurrences to one or more years.
+      #
+      def year(*years)
+        years.flatten.each do |year|
+          unless year.is_a?(Fixnum)
+            raise ArgumentError, "expecting Fixnum value for year, got #{year.inspect}"
+          end
+          validations_for(:year) << Validation.new(year)
+        end
+        ::IceCube::Validations::FixedValue::INTERVALS[:year] = 100
+        self
+      end
+
+      class Validation < Validations::FixedValue # :nodoc:
+        attr_reader :year
+        alias_method :value, :year
+
+        def initialize(year)
+          @year = year
+        end
+
+        def type
+          :year
+        end
+
+        def dst_adjust?
+          true
+        end
+
+        def build_s(builder)
+          builder.piece(:year) << StringBuilder.nice_number(year)
+        end
+
+        def build_hash(builder)
+          builder.validations_array(:year) << year
+        end
+
+        def build_ical(builder)
+          builder['BYYEAR'] << year
+        end
+
+        StringBuilder.register_formatter(:year) do |entries|
+          "in #{StringBuilder.sentence(entries)} "
+        end
+      end
+    end
+  end
+end

data/spec/lib/ice_cube_cron/base_spec.rb

@@ -214,6 +214,67 @@ describe ::IceCubeCron do
         expect(ice_cube_model.occurrences_between(::Date.new(2016, 2, 1), ::Date.new(2016, 4, 30))).to eq([::Date.new(2016, 2, 8), ::Date.new(2016, 3, 14), ::Date.new(2016, 4, 11)])
       end
     end
+
+    context 'every month until date' do
+      let(:schedule) do
+        ::IceCube::Schedule.from_cron(
+          ::Date.new(2015, 1, 1),
+          :repeat_day => '1',
+          :repeat_until => ::Date.new(2015, 3, 1)
+        )
+      end
+
+      it 'ends on specified end date' do
+        expect(schedule.occurrences_between(::Date.new(2015, 1, 1), ::Date.new(2015, 6, 30))).to eq([::Date.new(2015, 1, 1), ::Date.new(2015, 2, 1), ::Date.new(2015, 3, 1)])
+      end
+    end
+
+    context 'year expression support (non-standard)' do
+      context 'in month of a year' do
+        let(:ice_cube_model) do
+          ::IceCube::Schedule.from_cron(
+            ::Date.new(2015, 1, 1),
+            :year => '2015',
+            :month => '6',
+            :day => '10'
+          )
+        end
+
+        it '#occurrences_between' do
+          expect(ice_cube_model.occurrences_between(::Date.new(2013, 1, 1), ::Date.new(2017, 12, 31))).to eq([::Date.new(2015, 6, 10)])
+        end
+      end
+
+      context 'in a month of multiple years' do
+        let(:ice_cube_model) do
+          ::IceCube::Schedule.from_cron(
+            ::Date.new(2015, 1, 1),
+            :year => '2015,2017',
+            :month => '6',
+            :day => '10'
+          )
+        end
+
+        it '#occurrences_between' do
+          expect(ice_cube_model.occurrences_between(::Date.new(2013, 1, 1), ::Date.new(2018, 12, 31))).to eq([::Date.new(2015, 6, 10), ::Date.new(2017, 6, 10)])
+        end
+      end
+
+      context 'multiple days in month of a year' do
+        let(:ice_cube_model) do
+          ::IceCube::Schedule.from_cron(
+            ::Date.new(2015, 1, 1),
+            :year => '2015',
+            :month => '6',
+            :day => '10,15'
+          )
+        end
+
+        it '#occurrences_between' do
+          expect(ice_cube_model.occurrences_between(::Date.new(2013, 1, 1), ::Date.new(2017, 12, 31))).to eq([::Date.new(2015, 6, 10), ::Date.new(2015, 6, 15)])
+        end
+      end
+    end
   end
 
   context 'input types' do
@@ -223,7 +284,7 @@ describe ::IceCubeCron do
         :repeat_day => '1',
         :repeat_interval => '2'
       )
-      expect(ice_cube_model.occurrences_between(::DateTime.new(2015, 7, 1), ::DateTime.new(2015, 7, 31))).to eq([::DateTime.new(2015, 7, 1)])
+      expect(ice_cube_model.occurrences_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 31))).to eq([::Date.new(2015, 7, 1)])
     end
 
     it 'handles integer (epoch) as input' do
@@ -232,7 +293,7 @@ describe ::IceCubeCron do
         :repeat_day => '1',
         :repeat_interval => '2'
       )
-      expect(ice_cube_model.occurrences_between(::DateTime.new(2015, 7, 1), ::DateTime.new(2015, 7, 31))).to eq([::DateTime.new(2015, 7, 1)])
+      expect(ice_cube_model.occurrences_between(::Date.new(2015, 7, 1), ::Date.new(2015, 7, 31))).to eq([::Date.new(2015, 7, 1)])
     end
   end
 end

data/spec/lib/ice_cube_cron/expression_parser_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
 
 describe ::IceCubeCron::ExpressionParser do
-  let(:expression_parser) do
+  let(:expression) do
     described_class.new(
+      nil,
       :repeat_interval => 2,
       :repeat_day => 3,
       :repeat_month => 4,
@@ -11,144 +12,196 @@ describe ::IceCubeCron::ExpressionParser do
     )
   end
 
+  describe 'parses ::String expression' do
+    # rubocop:disable Style/SymbolProc
+    let(:expression_str) { |example| example.description }
+    # rubocop:enable Style/SymbolProc
+    let(:expression) { described_class.new(expression_str) }
+
+    it '* * 2 * *' do
+      expect(expression.expression_hash[:repeat_interval]).to eq(1)
+      expect(expression.expression_hash[:repeat_year]).to eq(nil)
+      expect(expression.expression_hash[:repeat_month]).to eq(nil)
+      expect(expression.expression_hash[:repeat_day]).to eq([2])
+      expect(expression.expression_hash[:repeat_weekday]).to eq(nil)
+    end
+
+    it '* * 1,15 * *' do
+      expect(expression.expression_hash[:repeat_interval]).to eq(1)
+      expect(expression.expression_hash[:repeat_year]).to eq(nil)
+      expect(expression.expression_hash[:repeat_month]).to eq(nil)
+      expect(expression.expression_hash[:repeat_day]).to eq([1, 15])
+      expect(expression.expression_hash[:repeat_weekday]).to eq(nil)
+    end
+
+    it '* * 1 6,12 *' do
+      expect(expression.expression_hash[:repeat_interval]).to eq(1)
+      expect(expression.expression_hash[:repeat_year]).to eq(nil)
+      expect(expression.expression_hash[:repeat_month]).to eq([6, 12])
+      expect(expression.expression_hash[:repeat_day]).to eq([1])
+      expect(expression.expression_hash[:repeat_weekday]).to eq(nil)
+    end
+
+    it '* * 1 6 * 2015' do
+      expect(expression.expression_hash[:repeat_interval]).to eq(1)
+      expect(expression.expression_hash[:repeat_year]).to eq([2015])
+      expect(expression.expression_hash[:repeat_month]).to eq([6])
+      expect(expression.expression_hash[:repeat_day]).to eq([1])
+      expect(expression.expression_hash[:repeat_weekday]).to eq(nil)
+    end
+
+    it '* * * 6 1L *' do
+      expect(expression.expression_hash[:repeat_interval]).to eq(1)
+      expect(expression.expression_hash[:repeat_year]).to eq(nil)
+      expect(expression.expression_hash[:repeat_month]).to eq([6])
+      expect(expression.expression_hash[:repeat_day]).to eq(nil)
+      expect(expression.expression_hash[:repeat_weekday]).to eq([1 => [-1]])
+    end
+  end
+
   describe 'parses ::Hash expression' do
     describe 'repeat_interval' do
       it '[]' do
-        expect(expression_parser[:repeat_interval]).to eq(2)
+        expect(expression.interval).to eq(2)
       end
 
       it '[]=' do
-        expression_parser[:repeat_interval] = 13
-        expect(expression_parser[:repeat_interval]).to eq(13)
+        expression.interval = 13
+        expect(expression.interval).to eq(13)
       end
 
       it 'sanitizes' do
-        expression_parser[:repeat_interval] = 2
-        expect(expression_parser[:repeat_interval]).to eq(2)
+        expression.interval = 2
+        expect(expression.interval).to eq(2)
 
-        expression_parser[:repeat_interval] = nil
-        expect(expression_parser[:repeat_interval]).to eq(1)
+        expression.interval = nil
+        expect(expression.interval).to eq(1)
 
-        expression_parser[:repeat_interval] = '3'
-        expect(expression_parser[:repeat_interval]).to eq(3)
+        expression.interval = '3'
+        expect(expression.interval).to eq(3)
       end
     end
 
     describe 'repeat_day' do
       it '[]' do
-        expect(expression_parser[:repeat_day]).to eq([3])
+        expect(expression.day).to eq([3])
       end
 
       it '[]=' do
-        expression_parser[:repeat_day] = 6
-        expect(expression_parser[:repeat_day]).to eq([6])
+        expression.day = 6
+        expect(expression.day).to eq([6])
       end
 
       it 'sanitizes' do
-        expression_parser[:repeat_day] = 2
-        expect(expression_parser[:repeat_day]).to eq([2])
+        expression.day = 2
+        expect(expression.day).to eq([2])
 
-        expression_parser[:repeat_day] = nil
-        expect(expression_parser[:repeat_day]).to eq(nil)
+        expression.day = nil
+        expect(expression.day).to eq(nil)
 
-        expression_parser[:repeat_day] = '3'
-        expect(expression_parser[:repeat_day]).to eq([3])
+        expression.day = '3'
+        expect(expression.day).to eq([3])
       end
 
       it 'should accept single day expression' do
-        expression_parser.repeat_day = '1'
-        expect(expression_parser.repeat_day).to eq([1])
+        expression.day = '1'
+        expect(expression.day).to eq([1])
       end
 
       it 'should accept series expression' do
-        expression_parser.repeat_day = '1,3'
-        expect(expression_parser.repeat_day).to eq([1, 3])
+        expression.day = '1,3'
+        expect(expression.day).to eq([1, 3])
+      end
+
+      it 'should accept range expression' do
+        expression.day = '1-3'
+        expect(expression.day).to eq([1, 2, 3])
       end
 
       it 'should accept last day expression' do
-        expression_parser.repeat_day = 'L'
-        expect(expression_parser.repeat_day).to eq([-1])
+        expression.day = 'L'
+        expect(expression.day).to eq([-1])
       end
     end
 
     describe 'repeat_month' do
       it '[]' do
-        expect(expression_parser[:repeat_month]).to eq([4])
+        expect(expression.month).to eq([4])
       end
 
       it '[]=' do
-        expression_parser[:repeat_month] = 11
-        expect(expression_parser[:repeat_month]).to eq([11])
+        expression.month = 11
+        expect(expression.month).to eq([11])
       end
 
       it 'sanitizes' do
-        expression_parser[:repeat_month] = 2
-        expect(expression_parser[:repeat_month]).to eq([2])
+        expression.month = 2
+        expect(expression.month).to eq([2])
 
-        expression_parser[:repeat_month] = nil
-        expect(expression_parser[:repeat_month]).to eq(nil)
+        expression.month = nil
+        expect(expression.month).to eq(nil)
 
-        expression_parser[:repeat_month] = '3'
-        expect(expression_parser[:repeat_month]).to eq([3])
+        expression.month = '3'
+        expect(expression.month).to eq([3])
       end
     end
 
     describe 'repeat_year' do
       it '[]' do
-        expect(expression_parser[:repeat_year]).to eq([1990])
+        expect(expression.year).to eq([1990])
       end
 
       it '[]=' do
-        expression_parser[:repeat_year] = 1994
-        expect(expression_parser[:repeat_year]).to eq([1994])
+        expression.year = 1994
+        expect(expression.year).to eq([1994])
       end
 
       it 'sanitizes' do
-        expression_parser[:repeat_year] = 1992
-        expect(expression_parser[:repeat_year]).to eq([1992])
+        expression.year = 1992
+        expect(expression.year).to eq([1992])
 
-        expression_parser[:repeat_year] = nil
-        expect(expression_parser[:repeat_year]).to eq(nil)
+        expression.year = nil
+        expect(expression.year).to eq(nil)
 
-        expression_parser[:repeat_year] = '2001'
-        expect(expression_parser[:repeat_year]).to eq([2001])
+        expression.year = '2001'
+        expect(expression.year).to eq([2001])
       end
     end
 
     describe 'repeat_weekday' do
       it '[]' do
-        expect(expression_parser[:repeat_weekday]).to eq([0])
+        expect(expression.weekday).to eq([0])
       end
 
       it '[]=' do
-        expression_parser[:repeat_weekday] = 4
-        expect(expression_parser[:repeat_weekday]).to eq([4])
+        expression.weekday = 4
+        expect(expression.weekday).to eq([4])
       end
 
       it 'sanitizes' do
-        expression_parser[:repeat_weekday] = 2
-        expect(expression_parser[:repeat_weekday]).to eq([2])
+        expression.weekday = 2
+        expect(expression.weekday).to eq([2])
 
-        expression_parser[:repeat_weekday] = nil
-        expect(expression_parser[:repeat_weekday]).to eq(nil)
+        expression.weekday = nil
+        expect(expression.weekday).to eq(nil)
 
-        expression_parser[:repeat_weekday] = '3'
-        expect(expression_parser[:repeat_weekday]).to eq([3])
+        expression.weekday = '3'
+        expect(expression.weekday).to eq([3])
       end
 
       it 'should accept non-nth weekday expression' do
-        expression_parser.weekday = '1'
-        expect(expression_parser.weekday).to eq([1])
+        expression.weekday = '1'
+        expect(expression.weekday).to eq([1])
       end
 
       it 'should accept nth weekday expression' do
-        expression_parser.weekday = '1#3'
-        expect(expression_parser.weekday).to eq([{ 1 => [3] }])
+        expression.weekday = '1#3'
+        expect(expression.weekday).to eq([{ 1 => [3] }])
       end
 
       it 'should accept last weekday expression' do
-        expression_parser.weekday = '1L'
-        expect(expression_parser.weekday).to eq([{ 1 => [-1] }])
+        expression.weekday = '1L'
+        expect(expression.weekday).to eq([{ 1 => [-1] }])
       end
     end
   end

data/spec/lib/ice_cube_cron/rule_builder_spec.rb

@@ -18,6 +18,11 @@ describe ::IceCubeCron::RuleBuilder do
       expect(rule_builder.build_rule(expression)).to be_a(IceCube::WeeklyRule)
     end
 
+    it 'monthly (last week day of month)' do
+      expression.weekday = '2L'
+      expect(rule_builder.build_rule(expression)).to be_a(IceCube::MonthlyRule)
+    end
+
     it 'yearly' do
       expression.month = 2
       expect(rule_builder.build_rule(expression)).to be_a(IceCube::YearlyRule)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube_cron
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Matt Nichols
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-15 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ice_cube
@@ -103,6 +103,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rdoc_options"
 - ".rspec"
 - ".rubocop.yml"
 - Gemfile
@@ -115,9 +116,12 @@ files:
 - lib/ice_cube_cron/base.rb
 - lib/ice_cube_cron/expression_parser.rb
 - lib/ice_cube_cron/extension.rb
+- lib/ice_cube_cron/parser_attribute.rb
 - lib/ice_cube_cron/rule_builder.rb
 - lib/ice_cube_cron/util.rb
 - lib/ice_cube_cron/version.rb
+- lib/ice_cube_ext/validated_rule.rb
+- lib/ice_cube_ext/validations/year.rb
 - spec/lib/ice_cube_cron/base_spec.rb
 - spec/lib/ice_cube_cron/expression_parser_spec.rb
 - spec/lib/ice_cube_cron/rule_builder_spec.rb