ice_cube_cron 0.0.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4177ac895e629d1b81080c4fadb639109705eb5
-  data.tar.gz: 55c6f84a783a4d5d0e5cb27fe2b729809782860c
+  metadata.gz: 1b14af35504a36135e5f349fa1daa0436c608848
+  data.tar.gz: a5344d84ce8b858875732e5c594c93444a8afc22
 SHA512:
-  metadata.gz: 6a1a73ec0d09f91490dde50e6de214c4cd53b1a22295dbd672e220da40b0af8f45c1722c274de0e24b715fa144f9fbac84ba6f47095ecb8bc83ee590e6cc6dea
-  data.tar.gz: 2bc4d36810f9d788217f6a82e81b4e1d22e0addfc3ced87dc5d402307c6ad7c4b300409cbf9e2b5a52972165ea7202a313ee10e56740a1232d447a7647f19ae2
+  metadata.gz: bb37fb552f54bfacf7cd4c05ad2ad24682732dc0804b9e7d43abc67187c86f811ab289bab932109c49d85252f7fa571e7c8cb5d37e114ba623fa7645d3419940
+  data.tar.gz: 8d1e857a18f5510ec8f88a23bbaf11a2371414b8f6d96950325f06413999e3a6ba186c253f4a9492a4e7ce869da0467575cee2c40b08cc5b1def62d4e9c6386a

data/.gitignore

@@ -34,3 +34,4 @@ build/
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
 vendor/cache
+Gemfile.lock

data/.rubocop.yml

@@ -19,3 +19,5 @@ Metrics/LineLength:
 Metrics/MethodLength:
   Max: 15
 
+Metrics/ClassLength:
+  Max: 200

data/README.md

@@ -45,7 +45,7 @@ require 'ice_cube_cron'
 schedule = ::IceCube::Schedule.from_cron(::Date.current, "* * * * 5")
 
 # using hash
-schedule = ::IceCube::Schedule.from_cron(::Date.new(2015, 1, 5), :repeat_day => 5)
+schedule = ::IceCube::Schedule.from_cron(::Date.new(2015, 1, 5), :day_of_month => 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]
@@ -53,7 +53,7 @@ schedule.occurrences_between(::Date.new(2015, 3, 5), ::Date.new(2015, 6, 5))
 
 ## recurrence rule examples (date)
 
-|desc|interval|year|month|day|weekday|
+|desc|interval|year|month|day_of_month|day_of_week|
 |----|-------:|---:|----:|--:|------:|
 |1st of every month||||1||
 |1st and 15th of every month||||1,15||
@@ -69,4 +69,6 @@ schedule.occurrences_between(::Date.new(2015, 3, 5), ::Date.new(2015, 6, 5))
 - Does not yet support all recurrence options. More coming.
 
 ## todo
-- Add support for time options
+- Add support for W special character
+- Change hash param `day` to `day_of_month`
+- Improve expression validation

data/lib/ice_cube_cron/expression_parser.rb

@@ -6,21 +6,23 @@ module IceCubeCron # :nodoc:
     include ::IceCubeCron::ParserAttribute
 
     EXPRESSION_PART_DEFAULTS = {
-      :repeat_interval => 1,
-      :repeat_year => nil,
-      :repeat_month => nil,
-      :repeat_day => nil,
-      :repeat_weekday => nil,
-      :repeat_until => nil
+      :interval => 1,
+      :year => nil,
+      :month => nil,
+      :day_of_month => nil,
+      :day_of_week => nil,
+      :hour => nil,
+      :minute => nil,
+      :until => nil
     }
 
     EXPRESSION_PART_KEYS = [
-      :repeat_minute,
-      :repeat_hour,
-      :repeat_day,
-      :repeat_month,
-      :repeat_weekday,
-      :repeat_year
+      :minute,
+      :hour,
+      :day_of_month,
+      :month,
+      :day_of_week,
+      :year
     ]
 
     ##
@@ -43,7 +45,11 @@ module IceCubeCron # :nodoc:
       self.expression_hash = EXPRESSION_PART_DEFAULTS.dup
 
       expression_parts.each do |name, val|
-        send("#{name}=", val)
+        begin
+          send("#{name}=", val)
+        rescue NoMethodError
+          raise ArgumentError, "Invalid parameter: #{name}"
+        end
       end
     end
 
@@ -51,41 +57,47 @@ module IceCubeCron # :nodoc:
       ExpressionParser.sanitize_integer_param(val, 1)
     end
 
-    parser_attribute_accessor :day do |val|
+    parser_attribute_accessor :day_of_month do |val|
       ExpressionParser.sanitize_day_param(val)
     end
+    _define_parser_attribute_aliases(:day, :day_of_month, :day_of_month=)
 
     parser_attribute_accessor :month do |val|
       ExpressionParser.sanitize_integer_array_param(val)
     end
 
-    parser_attribute_accessor :until
-
     parser_attribute_accessor :year do |val|
       ExpressionParser.sanitize_integer_array_param(val)
     end
 
-    parser_attribute_accessor :weekday do |val|
+    parser_attribute_accessor :day_of_week do |val|
       ExpressionParser.sanitize_week_day_param(val)
     end
+    _define_parser_attribute_aliases(:weekday, :day_of_week, :day_of_week=)
 
-    ##
-    # Split string expression into parts
-    #
-    def string_to_expression_parts(expression_str)
-      return {} if expression_str.nil?
+    parser_attribute_accessor :hour do |val|
+      ExpressionParser.sanitize_integer_array_param(val)
+    end
 
-      parts = expression_str.split(/ +/)
+    parser_attribute_accessor :minute do |val|
+      ExpressionParser.sanitize_integer_array_param(val)
+    end
 
-      expression_parts = ::Hash[EXPRESSION_PART_KEYS.zip(parts)]
-      expression_parts.select! do |_key, value|
-        next false if value.nil?
-        next false if value == '*'
+    parser_attribute_accessor :until
 
-        true
-      end
+    ##
+    # 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)
 
-      expression_parts
+      param.to_s.split(',').map do |element|
+        next -1 if element == 'L'
+
+        ExpressionParser.sanitize_integer_array_param(element)
+      end.flatten.uniq
     end
 
     ##
@@ -98,19 +110,26 @@ module IceCubeCron # :nodoc:
     end
 
     ##
-    # Sanitize given value to a valid day parameter
+    # Sanitize given value to an integer array
     #
-    def self.sanitize_day_param(param)
+    #--
+    # 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.to_s.split(',').map do |element|
-        next -1 if element == 'L'
-
-        ExpressionParser.sanitize_integer_array_param(element)
+      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
 
     ##
     # Sanitize given value to a valid weekday parameter
@@ -129,26 +148,39 @@ module IceCubeCron # :nodoc:
       end
     end
 
+  private
+
     ##
-    # Sanitize given value to an integer array
+    # Split a cron string and extract the LAST interval that appears
     #
-    #--
-    # 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)
+    def split_parts_and_interval(expression_str)
+      interval = nil
+      parts = expression_str.split(/ +/).map do |part|
+        part, part_interval = part.split('/')
+        interval = part_interval unless part_interval.blank?
+        next nil if part.blank? || part == '*'
+
+        part
+      end
 
-      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
+      [parts, interval]
+    end
+
+    ##
+    # Split string expression into parts
+    #
+    def string_to_expression_parts(expression_str)
+      return {} if expression_str.nil?
+
+      parts, interval = split_parts_and_interval(expression_str)
+
+      expression_parts = ::Hash[EXPRESSION_PART_KEYS.zip(parts)]
+      expression_parts.select! do |_key, value|
+        !value.nil?
+      end
+      expression_parts.merge!(:interval => interval) unless interval.nil?
+
+      expression_parts
     end
-    # rubocop:enable Metrics/AbcSize
   end
 end

data/lib/ice_cube_cron/parser_attribute.rb

@@ -4,12 +4,14 @@ module IceCubeCron # :nodoc: all
       base.extend(::IceCubeCron::ParserAttribute::ClassMethods)
     end
 
+  private
+
     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
+        getter = "#{attr_name}".to_sym
+        setter = "#{attr_name}=".to_sym
 
         define_method(getter) do
           expression_hash[getter]
@@ -20,8 +22,16 @@ module IceCubeCron # :nodoc: all
           expression_hash[getter] = val
         end
 
-        alias_method attr_name, getter
-        alias_method "#{attr_name}=".to_sym, setter
+        _define_parser_attribute_aliases(attr_name, getter, setter)
+      end
+
+    private
+
+      def _define_parser_attribute_aliases(attr_name, getter, setter)
+        alias_method "repeat_#{attr_name}=".to_sym, setter
+        alias_method "repeat_#{attr_name}".to_sym, getter
+        alias_method "cron_#{attr_name}=".to_sym, setter
+        alias_method "cron_#{attr_name}".to_sym, getter
       end
     end
   end

data/lib/ice_cube_cron/rule_builder.rb

@@ -8,9 +8,10 @@ module IceCubeCron # :nodoc:
     #
     def build_rule(expression)
       rule = build_root_recurrence_rule(expression)
-      rule = build_yearly_rules(rule, expression)
+      rule = build_year_rules(rule, expression)
       rule = build_weekday_rule(rule, expression)
-      rule = rule.day_of_month(*expression.day) unless expression.day.blank?
+      rule = build_day_rules(rule, expression)
+      rule = build_time_rules(rule, expression)
       rule = rule.until(expression.until) unless expression.until.blank?
 
       rule
@@ -24,31 +25,53 @@ module IceCubeCron # :nodoc:
 
   private
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def build_root_recurrence_rule(expression) # :nodoc:
+      return ::IceCube::Rule.minutely(expression.interval) if expression.minute.blank?
+      return ::IceCube::Rule.hourly(expression.interval) if expression.hour.blank?
+      unless nth_day?(expression.day_of_week)
+        return ::IceCube::Rule.weekly(expression.interval) if expression.day_of_month.blank? && !expression.day_of_week.blank?
+        return ::IceCube::Rule.daily(expression.interval) if expression.day_of_month.blank?
+      end
+      return ::IceCube::Rule.monthly(expression.interval) if expression.month.blank?
+
+      ::IceCube::Rule.yearly(expression.interval)
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    # :nodoc:
+    def build_year_rules(rule, expression)
+      rule = rule.year(*expression.year) unless expression.year.blank?
+      rule = rule.month_of_year(*expression.month) unless expression.month.blank?
+
+      rule
+    end
+
     # :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?
+      return rule.day_of_week(*expression.day_of_week) if !expression.day_of_week.blank? && nth_day?(expression.day_of_week)
+      return rule.day(*expression.day_of_week) unless expression.day_of_week.blank?
 
       rule
     end
 
     # :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?
+    def build_day_rules(rule, expression)
+      rule = rule.day_of_month(*expression.day_of_month) unless expression.day_of_month.blank?
 
       rule
     end
 
-    # 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?
+    # :nodoc:
+    def build_time_rules(rule, expression)
+      rule = rule.hour_of_day(*expression.hour) unless expression.hour.blank? || expression.hour == [0]
+      rule = rule.minute_of_hour(*expression.minute) unless expression.minute.blank? || expression.minute == [0]
 
-      ::IceCube::Rule.monthly(expression.interval)
+      rule
     end
-    # rubocop:enable Metrics/AbcSize
   end
 end

data/lib/ice_cube_cron/version.rb

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