taskloop 0.1.0

data/lib/taskloop/rules/before_scope_rule.rb

@@ -0,0 +1,90 @@
+module TaskLoop
+  class BeforeScopeRule < ScopeRule
+
+    attr_accessor :right
+
+    def initialize(unit, scope, right)
+      super unit, scope
+      @right = right
+    end
+
+    def invalidate!
+      super
+      if @unit == :day
+        unless Task::WEEK.has_key?(@right) || Task::DAY.has_key?(@right)
+          raise ArgumentError, "#{@right} must be a Symbol defined in Task::WEEK or Task::DAY"
+        end
+        return
+      end
+
+      if @unit == :month
+        unless Task::MONTH.has_key?(@right)
+          raise ArgumentError, "#{@right} must be a Symbol defined in Task::MONTH"
+        end
+        return
+      end
+
+      unless @right.is_a?(Integer)
+        raise TypeError, "'right' need to be Symbol or Integer"
+      end
+
+      if @unit == :minute && (@right < 0 || @right > 59)
+        raise ArgumentError, "'right' for 'minute' must >= 0 and <= 59"
+      end
+
+      if @unit == :hour && (@right < 0 || @right > 23)
+        raise ArgumentError, "'right' for 'hour' must >= 0 and <= 23"
+      end
+    end
+
+    def right_value
+      if (Task::DAY.has_key?(@right))
+        return Task::DAY[@right]
+      end
+      if (Task::WEEK.has_key?(@right))
+        return Task::WEEK[@right]
+      end
+      if (Task::MONTH.has_key?(@right))
+        return Task::MONTH[@right]
+      end
+
+      unless @right != nil && @right.is_a?(Integer)
+        return -1
+      end
+
+      return @right
+    end
+
+    def is_week_value?
+      if @unit == :day && Task::WEEK.has_key?(@right)
+        return true
+      end
+      return false
+    end
+
+    def is_conform_rule?(last_exec_time)
+      current = Time.now
+      value = right_value
+      result = false
+      case @unit
+      when :year then
+        result = current.year < value
+      when :month then
+        result = current.month < value
+      when :day then
+        if is_week_value?
+          result = current.wday < (value % TaskLoop::WEEK_BASE)
+        else
+          result = current.day < value
+        end
+      when :hour then
+        result = current.hour < value
+      end
+      return result
+    end
+
+    def desc
+      super + " #{right}"
+    end
+  end
+end

data/lib/taskloop/rules/between_scope_rule.rb

@@ -0,0 +1,130 @@
+module TaskLoop
+  class BetweenScopeRule < ScopeRule
+
+    attr_accessor :left
+
+    attr_accessor :right
+
+    def initialize(unit, scope, left, right)
+      super unit, scope
+      @left = left
+      @right = right
+    end
+
+    def invalidate!
+      super
+      if @unit == :day
+        if Task::WEEK.has_key?(@left) && Task::WEEK.has_key?(@right)
+          unless Task::WEEK[@left] < Task::WEEK[@right]
+            raise ArgumentError, "'left' must less than 'right'"
+          end
+          return
+        end
+        if Task::DAY.has_key?(@left) && Task::DAY.has_key?(@right)
+          unless Task::WEEK[@left] < Task::WEEK[@right]
+            raise ArgumentError, "'left' must less than 'right'"
+          end
+          return
+        end
+
+        raise ArgumentError, "'left' and 'right' must be the same type."
+      end
+
+      if @unit == :month
+        unless Task::MONTH.has_key?(@left)
+          raise ArgumentError, "#{left} must be a Symbol defined in Task::MONTH"
+        end
+        return
+      end
+
+      unless @left.is_a?(Integer) && @right.is_a?(Integer)
+        raise TypeError, "both 'left' and 'right' need to be Symbol or Integer"
+      end
+
+      unless @left < @right
+        raise ArgumentError, "'left' must less than 'right'"
+      end
+
+      if @unit == :minute && (@left < 0 || @right > 59)
+        raise ArgumentError, "'left' and 'right' for 'minute' must >= 0 and <= 59"
+      end
+
+      if @unit == :hour && (@left < 0 || @right > 23)
+        raise ArgumentError, "'left', 'right' for 'hour' must >= 0 and <= 23"
+      end
+
+      if @unit == :year && @left < 0
+        raise ArgumentError, "'left' must greater than 0"
+      end
+    end
+
+    def left_value
+      if (Task::DAY.has_key?(@left))
+        return Task::DAY[@left]
+      end
+      if (Task::WEEK.has_key?(@left))
+        return Task::WEEK[@left]
+      end
+      if (Task::MONTH.has_key?(@left))
+        return Task::MONTH[@left]
+      end
+
+      unless @left != nil && @left.is_a?(Integer)
+        return -1
+      end
+
+      return @left
+    end
+
+    def right_value
+      if (Task::DAY.has_key?(@right))
+        return Task::DAY[@right]
+      end
+      if (Task::WEEK.has_key?(@right))
+        return Task::WEEK[@right]
+      end
+      if (Task::MONTH.has_key?(@right))
+        return Task::MONTH[@right]
+      end
+
+      unless @right != nil && @right.is_a?(Integer)
+        return -1
+      end
+
+      return @right
+    end
+
+    def is_week_value?
+      if @unit == :day && Task::WEEK.has_key?(@left) && Task::WEEK.has_key?(@right)
+        return true
+      end
+      return false
+    end
+
+    def is_conform_rule?(last_exec_time)
+      current = Time.now
+      left = left_value
+      right = right_value
+      result = false
+      case @unit
+      when :year then
+        result = left <= current.year >= left && current.year <= right
+      when :month then
+        result = left <= current.month && current.month <= right
+      when :day then
+        if is_week_value?
+          result = (left % TaskLoop::WEEK_BASE) <= current.wday && current.wday <= (right % TaskLoop::WEEK_BASE)
+        else
+          result = left <= current.day && current.day <= right
+        end
+      when :hour then
+        result = left <= current.hour && current.hour <= right
+      end
+      return result
+    end
+
+    def desc
+      super + " #{left}, #{right}"
+    end
+  end
+end

data/lib/taskloop/rules/date_list_rule.rb

@@ -0,0 +1,47 @@
+module TaskLoop
+  class DateListRule < Rule
+    require 'time'
+
+    attr_writer :dates
+
+    def dates
+      @dates ||= []
+    end
+
+    def dates_values
+      values = []
+      dates.each do |date|
+        date_format = "%Y-%m-%d"
+        date_object = Time.strptime(date, date_format)
+        values.push(date_object)
+      end
+      return values
+    end
+
+    def initialize(unit, dates)
+      super unit
+      unless dates != nil && dates.length > 0
+        raise ArgumentError, "dates arguments need at least one value."
+      end
+      @dates = dates
+    end
+
+    def is_week_value?
+      return false
+    end
+
+    def is_conform_rule?(last_exec_time)
+      current = Time.now
+      result = false
+
+      dates_values.each do |date|
+        result = result || (date.year == current.year && date.month == current.month && date.day == current.day)
+      end
+      return result
+    end
+
+    def desc
+      super + "; date_list: #{dates.join(', ')}"
+    end
+  end
+end

data/lib/taskloop/rules/default_rule.rb

@@ -0,0 +1,19 @@
+module TaskLoop
+  class DefaultRule < Rule
+    def initialize(unit)
+      super unit
+    end
+
+    def is_week_value?
+      return false
+    end
+
+    def is_conform_rule?(last_exec_time)
+      return true
+    end
+
+    def desc
+      super + "; default rule"
+    end
+  end
+end

data/lib/taskloop/rules/interval_rule.rb

@@ -0,0 +1,26 @@
+module TaskLoop
+  class IntervalRule < Rule
+
+    attr_accessor :interval
+
+    def initialize(unit, interval)
+      super unit
+      @interval = interval
+    end
+
+    def is_week_value?
+      return false
+    end
+
+    def is_conform_rule?(last_exec_time)
+      # interval rule is different for other rules. It should be calculated by combining the interval times of all units.
+      # So here returns false
+      return false
+    end
+
+    def desc
+      super + "; interval: #{interval}"
+    end
+  end
+
+end

data/lib/taskloop/rules/loop_rule.rb

@@ -0,0 +1,25 @@
+module TaskLoop
+  class LoopRule < Rule
+
+    attr_accessor :count
+
+    def initialize(unit, count)
+      super unit
+      @count = count
+    end
+
+    def is_week_value?
+      return false
+    end
+
+    def is_conform_rule?(last_exec_time)
+      # loop rule is different for other rules. It should based on task loop file.
+      # So here returns false
+      return false
+    end
+
+    def desc
+      super + "; loop: #{count}"
+    end
+  end
+end

data/lib/taskloop/rules/rule.rb

@@ -0,0 +1,34 @@
+module TaskLoop
+  class Rule
+
+    UNIT = {
+      :unknown     => 0,
+      :minute      => 1,      # support interval/specific syntax
+      :hour        => 2,      # support interval/scope/specific syntax
+      :day         => 3,      # support interval/scope/specific syntax
+      :month       => 4,      # support interval/scope/specific syntax
+      :year        => 5,      # support interval/scope/specific syntax
+      :loop        => 7,      # only support loop syntax
+      :date        => 8,      # only support date list syntax
+      :time        => 9,      # only support time list syntax
+    }
+
+    attr_accessor :unit
+
+    def initialize(unit = :unknown)
+      @unit = unit
+    end
+
+    def is_week_value?
+      raise NotImplementedError, 'subclass need implement this method!'
+    end
+
+    def is_conform_rule?(last_exec_time)
+      raise NotImplementedError, 'subclass need implement this method!'
+    end
+
+    def desc
+      "unit: #{unit.to_s}"
+    end
+  end
+end

data/lib/taskloop/rules/scope_rule.rb

@@ -0,0 +1,22 @@
+module TaskLoop
+
+  class ScopeRule < Rule
+
+    SCOPE = {
+      :before    => 0,
+      :between   => 1,
+      :after     => 2,
+    }
+
+    attr_accessor :scope
+
+    def initialize(unit, scope)
+      super unit
+      @scope = scope
+    end
+
+    def desc
+      super + "; scope: #{scope.to_s}"
+    end
+  end
+end

data/lib/taskloop/rules/specific_rule.rb

@@ -0,0 +1,64 @@
+module TaskLoop
+
+  class SpecificRule < Rule
+
+    attr_accessor :value
+
+    def initialize(unit, value)
+      super unit
+      @value = value
+    end
+
+    def value_value
+      if (Task::DAY.has_key?(@value))
+        return Task::DAY[@value]
+      end
+      if (Task::WEEK.has_key?(@value))
+        return Task::WEEK[@value]
+      end
+      if (Task::MONTH.has_key?(@value))
+        return Task::MONTH[@value]
+      end
+
+      unless @value != nil && @value.is_a?(Integer)
+        return -1
+      end
+
+      return @value
+    end
+
+    def is_week_value?
+      if @unit == :day && Task::WEEK.has_key?(@value)
+        return true
+      end
+      return false
+    end
+
+    def is_conform_rule?(last_exec_time)
+      current = Time.now
+      value = value_value
+      result = false
+      case @unit
+      when :year then
+        result = current.year == value
+      when :month then
+        result = current.month == value
+      when :day then
+        if is_week_value?
+          result = current.wday == (value % TaskLoop::WEEK_BASE)
+        else
+          result = current.day == value
+        end
+      when :hour then
+        result = current.hour == value
+      when :minute then
+        result = current.min == value
+      end
+      return result
+    end
+
+    def desc
+      super + "; specific: #{value}"
+    end
+  end
+end

data/lib/taskloop/rules/time_list_rule.rb

@@ -0,0 +1,49 @@
+module TaskLoop
+  class TimeListRule < Rule
+
+    require 'time'
+
+    attr_writer :times
+
+    def times
+      @times ||= []
+    end
+
+    def times_values
+      values = []
+      times.each do |time|
+        time_format = "%H:%M:%S"
+        time_object = Time.strptime(time, time_format)
+        values.push(time_object)
+      end
+      return values
+    end
+
+    def initialize(unit, times)
+      super unit
+      unless times != nil && times.length > 0
+        raise ArgumentError, "times arguments need at least one value."
+      end
+
+      @times = times
+    end
+
+    def is_week_value?
+      return false
+    end
+
+    def is_conform_rule?(last_exec_time)
+      current = Time.now
+      result = false
+
+      times_values.each do |time|
+        result = result || (time.hour == current.hour && time.min == current.min)
+      end
+      return result
+    end
+
+    def desc
+      super + "; time_list: #{times.join(', ')}"
+    end
+  end
+end