taskloop 0.1.0 → 0.2.0

data/lib/taskloop/rules/specific_rule.rb

@@ -2,63 +2,56 @@ module TaskLoop
 
   class SpecificRule < Rule
 
-    attr_accessor :value
+    attr_accessor :values
 
-    def initialize(unit, value)
+    def initialize(unit, values)
       super unit
-      @value = value
+      unless values != nil && values.length > 0
+        raise ArgumentError, "values arguments need at least one value."
+      end
+
+      @values = values
     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]
+    def values_values
+      if @unit == :week
+        return @values.map { |key| Task::WEEK[key] }
       end
 
-      unless @value != nil && @value.is_a?(Integer)
-        return -1
+      if @unit == :day
+        return @values.map { |key| Task::DAY[key] }
       end
 
-      return @value
-    end
-
-    def is_week_value?
-      if @unit == :day && Task::WEEK.has_key?(@value)
-        return true
+      if @unit == :month
+        return @values.map { |key| Task::MONTH[key] }
       end
-      return false
+
+      return @values
     end
 
     def is_conform_rule?(last_exec_time)
       current = Time.now
-      value = value_value
+      vals = values_values
       result = false
       case @unit
       when :year then
-        result = current.year == value
+        result = vals.include?(current.year)
       when :month then
-        result = current.month == value
+        result = vals.include?(current.month)
+      when :week then
+        result = vals.include?(TaskLoop::WEEK_BASE + current.wday)
       when :day then
-        if is_week_value?
-          result = current.wday == (value % TaskLoop::WEEK_BASE)
-        else
-          result = current.day == value
-        end
+        result = vals.include?(current.day)
       when :hour then
-        result = current.hour == value
+        result = vals.include?(current.hour)
       when :minute then
-        result = current.min == value
+        result = vals.include?(current.min)
       end
       return result
     end
 
     def desc
-      super + "; specific: #{value}"
+      super + "; specific: #{values.join(', ')}"
     end
   end
 end

data/lib/taskloop/rules/start_point_boundary_rule.rb

@@ -0,0 +1,21 @@
+module TaskLoop
+  class StartPointBoundaryRule < BoundaryRule
+    attr_accessor :value
+    def initialize(unit, value)
+      super unit, :start
+      @value = value
+    end
+
+    def is_conform_rule?(last_exec_time)
+      current = Time.now.to_i
+      date_format = "%Y-%m-%d %H:%M:%S"
+      date_object = Time.strptime(value, date_format)
+      start_time = date_object.to_i
+      return current >= start_time
+    end
+
+    def desc
+      super + " from #{value}"
+    end
+  end
+end

data/lib/taskloop/rules/time_list_rule.rb

@@ -28,10 +28,6 @@ module TaskLoop
       @times = times
     end
 
-    def is_week_value?
-      return false
-    end
-
     def is_conform_rule?(last_exec_time)
       current = Time.now
       result = false

data/lib/taskloop/task/task.rb

@@ -19,7 +19,7 @@ module TaskLoop
       @@tasklist = value
     end
 
-    def initialize()
+    def initialize
       yield self
       check = true
       unless @name
@@ -73,20 +73,20 @@ module TaskLoop
     def check_rule_conflict?
       result = true
       # check year/month/day with date, they cannot be set at the same time
-      if hasYMD? && hasDate?
+      if has_ymd? && has_date?
         puts "Error: #{desc} => <year/month/day> and <date> cannot be set at the same time.".ansi.red
         result = false
       end
 
       # check hour/minute with time, they cannot be set at the same time
-      if hasHM? && hasTime?
+      if has_hm? && has_time?
         puts "Error: #{desc} => <hour/minute> and <time> cannot be set at the same time.".ansi.red
         result = false
       end
 
       # check rule type
 
-      if hasYMD? && hasHM?
+      if has_ymd? && has_hm?
         # check minute/hour/day/month/year. Get the last IntervalRule, than check if there is SpecificRule or ScopeRule before
         rules = [minute, hour, day, month, year]
         rIdx = rules.rindex { |rule| rule.is_a?(IntervalRule) }
@@ -104,7 +104,7 @@ module TaskLoop
 
       end
 
-      if hasYMD? && hasTime?
+      if has_ymd? && has_time?
         # check year/month/day with time, YMD can not have IntervalRule
         rules = [day, month, year]
         hasInterval = rules.any? { |rule| rule.is_a?(IntervalRule) }
@@ -114,11 +114,11 @@ module TaskLoop
         end
       end
 
-      if hasDate? && hasHM?
+      if has_date? && has_hm?
         # it's ok
       end
 
-      if hasDate? && hasTime?
+      if has_date? && has_time?
         # it's ok
       end
 
@@ -129,6 +129,7 @@ module TaskLoop
       last_exec_time = last_time
 
       result = true
+      result &&= check_boundary_rule?(last_exec_time)
       result &&= check_interval_rule?(last_exec_time)
       result &&= check_scope_rule?(last_exec_time)
       result &&= check_specific_fule?(last_exec_time)
@@ -176,6 +177,9 @@ module TaskLoop
       if minute.is_a?(ScopeRule)
         result &&= minute.is_conform_rule?(last_exec_time)
       end
+      if week.is_a?(ScopeRule)
+        result &&= week.is_conform_rule?(last_exec_time)
+      end
       return result
     end
 
@@ -196,6 +200,9 @@ module TaskLoop
       if minute.is_a?(SpecificRule)
         result &&= minute.is_conform_rule?(last_exec_time)
       end
+      if week.is_a?(SpecificRule)
+        result &&= week.is_conform_rule?(last_exec_time)
+      end
       if time.is_a?(TimeListRule)
         result &&= time.is_conform_rule?(last_exec_time)
       end
@@ -215,6 +222,12 @@ module TaskLoop
       return result
     end
 
+    private def check_boundary_rule?(last_exec_time)
+      result = true
+      result &&= start_point.is_conform_rule?(last_exec_time)
+      result &&= end_point.is_conform_rule?(last_exec_time)
+      return result
+    end
 
     #################################
     # Sha1 and description

data/lib/taskloop/task/task_property.rb

@@ -1,5 +1,14 @@
 module TaskLoop
   module TaskProperty
+    WEEK = {
+      :Sun       => 0,
+      :Mon       => 1,
+      :Tue       => 2,
+      :Wed       => 3,
+      :Thu       => 4,
+      :Fri       => 5,
+      :Sat       => 6,
+    }
 
     MONTH = {
       :Jan       => 1,
@@ -27,17 +36,6 @@ module TaskLoop
       :mon12     => 12,
     }
 
-    WEEK_BASE = 10000
-    WEEK = {
-      :Sun       => 10000,
-      :Mon       => 10001,
-      :Tue       => 10002,
-      :Wed       => 10003,
-      :Thu       => 10004,
-      :Fri       => 10005,
-      :Sat       => 10006,
-    }
-
     DAY = {
       :day1      => 1,
       :day2      => 2,
@@ -78,11 +76,35 @@ module TaskLoop
     attr_accessor :path
 
     #################################
-    # Setters & Getters
+    # Week Property
+    # specific syntax
+    #   - at
+    #     - example: at :Mon, :Tue, :Fri
+    # scope syntax
+    #   - before
+    #     - example: before :Mon
+    #   - between
+    #     - example: between :Mon, :Fri
+    #   - after
+    #     0 example: after :Tue
     #################################
+    def week=(rule)
+      unless rule.is_a?(SpecificRule) || rule.is_a?(ScopeRule)
+        raise TypeError, "the rule of week must be SpecificRule or ScopeRule or IntervalRule"
+      end
+      @week = rule
+      @week.unit = :week
+    end
+
+    def week
+      @week ||= DefaultRule.new(:week)
+    end
+
+    #################################
+    # Year Property
     # specific syntax
     #   - of
-    #     - example: in 2024
+    #     - example: at 2024, 2025 ...
     # interval syntax
     #   - interval
     #     - example: interval 1.year
@@ -92,12 +114,12 @@ module TaskLoop
     #   - between
     #     - example: between 2025, 2026
     #   - after
-    #     - examle: after 2023
+    #     - example: after 2023
+    #################################
     def year=(rule)
-      unless rule.is_a?(Rule)
-        raise TypeError, "the rule of year must be a class or subclass of Rule"
+      unless rule.is_a?(SpecificRule) || rule.is_a?(ScopeRule) || rule.is_a?(IntervalRule)
+        raise TypeError, "the rule of year must be SpecificRule or ScopeRule or IntervalRule"
       end
-
       @year = rule
       @year.unit = :year
     end
@@ -106,10 +128,12 @@ module TaskLoop
       @year ||= DefaultRule.new(:year)
     end
 
+    #################################
+    # Month Property
     # specific syntax
-    #   - of
-    #     - example: of :Jan, :Feb, :Mar, :Apr, :Jun, :Jul, :Aug, :Sep, :Oct, :Nov, :Dec;
-    #     - example: of :month1, :month2, :month3, ....
+    #   - at
+    #     - example: at :Jan, :Feb, :Mar, :Apr, :Jun, :Jul, :Aug, :Sep, :Oct, :Nov, :Dec;
+    #     - example: at :month1, :month2, :month3 ...
     # interval syntax
     #   - every
     #     - example: interval 1.month
@@ -120,9 +144,10 @@ module TaskLoop
     #     - example: between 2025, 2026
     #   - after
     #     - examle: after 2023
+    #################################
     def month=(rule)
-      unless rule.is_a?(Rule)
-        raise TypeError, "the rule of month must be a class or subclass of Rule"
+      unless rule.is_a?(SpecificRule) || rule.is_a?(ScopeRule) || rule.is_a?(IntervalRule)
+        raise TypeError, "the rule of month must be SpecificRule or ScopeRule or IntervalRule"
       end
       @month = rule
       @month.unit = :month
@@ -132,10 +157,11 @@ module TaskLoop
       @month||= DefaultRule.new(:month)
     end
 
+    #################################
+    # Day Property
     # specific syntax
-    #   - on
-    #     - example: on :Mon, :Tue, :Wed, :Thu, :Fri, :Sat, :Sun;
-    #     - example: on :day1, :day2, :day3;
+    #   - at
+    #     - example: at :day1, :day2, :day3 ...
     # interval syntax
     #   - interval
     #     - example: interval 10.day
@@ -147,9 +173,10 @@ module TaskLoop
     #     - example: between :Mon, :Fri
     #   - after
     #     - example: after :day10
+    #################################
     def day=(rule)
-      unless rule.is_a?(Rule)
-        raise TypeError, "the rule of day must be a class or subclass of Rule"
+      unless rule.is_a?(SpecificRule) || rule.is_a?(ScopeRule) || rule.is_a?(IntervalRule)
+        raise TypeError, "the rule of day must be SpecificRule or ScopeRule or IntervalRule"
       end
       @day = rule
       @day.unit = :day
@@ -159,9 +186,11 @@ module TaskLoop
       @day ||= DefaultRule.new(:day)
     end
 
+    #################################
+    # Hour Property
     # specific syntax
     #   - at
-    #     - example: at 10; at 23
+    #     - example: at 10, 11, 13 ...
     # interval syntax
     #   - interval
     #     - example: interval 10.hour
@@ -172,9 +201,10 @@ module TaskLoop
     #     - example: between 10, 12
     #   - after
     #     - example: after 11
+    #################################
     def hour=(rule)
-      unless rule.is_a?(Rule)
-        raise TypeError, "the rule of hour must be a class or subclass of Rule"
+      unless rule.is_a?(SpecificRule) || rule.is_a?(ScopeRule) || rule.is_a?(IntervalRule)
+        raise TypeError, "the rule of hour must be SpecificRule or ScopeRule or IntervalRule"
       end
       @hour = rule
       @hour.unit = :hour
@@ -184,19 +214,17 @@ module TaskLoop
       @hour ||= DefaultRule.new(:hour)
     end
 
+    #################################
+    # Minute Property
     # specific syntax
     #   - at
-    #     - example: at 59; at 45
+    #     - example: at 59, 23 ...
     # interval syntax
     #   - interval
     #     - example: interval 5.minute
     def minute=(rule)
-      unless rule.is_a?(Rule)
-        raise TypeError, "the rule of minute must be a class or subclass of Rule"
-      end
-
-      if rule.is_a?(ScopeRule)
-        raise TypeError, "the rule of minute cannot be a class or subclass of ScopeRule"
+      unless rule.is_a?(SpecificRule) || rule.is_a?(IntervalRule)
+        raise TypeError, "the rule of minute must be SpecificRule or IntervalRule"
       end
       @minute = rule
       @minute.unit = :minute
@@ -206,12 +234,15 @@ module TaskLoop
       @minute ||= DefaultRule.new(:minute)
     end
 
+    #################################
+    # Loop Property
     # loop syntax
     #   - loop
     #     - example: loop 5.times
+    #################################
     def loop=(rule)
-      unless rule.is_a?(Rule)
-        raise TypeError, "the rule of loop must be a class or subclass of Rule"
+      unless rule.is_a?(LoopRule)
+        raise TypeError, "the rule of loop must be LoopRule"
       end
 
       @loop = rule
@@ -221,12 +252,15 @@ module TaskLoop
       @loop ||= DefaultRule.new(:loop)
     end
 
+    #################################
+    # Time Property
     # time list syntax
     #   - time
     #     - example: time "10:10:30", "9:10:20", "20:10:20"
+    #################################
     def time=(rule)
       unless rule.is_a?(TimeListRule)
-        raise TypeError, "the rule of time must be a TimeList Rule"
+        raise TypeError, "the rule of time must be TimeListRule"
       end
 
       @time = rule
@@ -236,12 +270,15 @@ module TaskLoop
       @time ||= DefaultRule.new(:time)
     end
 
+    #################################
+    # Date Property
     # date list syntax
     #   - date
     #     - example: date "2023-10-10", "2013-10-11", "2023-11-10"
+    #################################
     def date=(rule)
       unless rule.is_a?(DateListRule)
-        raise TypeError, "the rule of time must be a DateList Rule"
+        raise TypeError, "the rule of time must be DateListRule"
       end
 
       @date = rule
@@ -251,22 +288,61 @@ module TaskLoop
       @date ||= DefaultRule.new(:date)
     end
 
+    #################################
+    # StartPoint Property
+    # boundary syntax
+    #   - start_point
+    #     - example: from "2023-10-11 10:00:00"
+    #################################
+    def start_point=(rule)
+      unless rule.is_a?(StartPointBoundaryRule)
+        raise TypeError, "the rule of start_point must be StartPointBoundaryRule"
+      end
+      @start_point = rule
+      @start_point.unit = :full
+    end
+
+    def start_point
+      @start_point ||= DefaultRule.new(:full)
+    end
+
+    #################################
+    # EndPoint Property
+    # boundary syntax
+    #   - end_point
+    #     - example: to "2023-10-11 10:00:00"
+    #################################
+    def end_point=(rule)
+      unless rule.is_a?(EndPointBoundaryRule)
+        raise TypeError, "the rule of end_point must be EndPointBoundaryRule"
+      end
+      @end_point = rule
+      @end_point.unit = :full
+    end
+
+    def end_point
+      @end_point ||= DefaultRule.new(:full)
+    end
+
     #################################
     # Help Methods
     #################################
-    def hasDate?
+    def has_week?
+      !week.is_a?(DefaultRule)
+    end
+    def has_date?
       !date.is_a?(DefaultRule)
     end
 
-    def hasTime?
+    def has_time?
       !time.is_a?(DefaultRule)
     end
 
-    def hasYMD?
+    def has_ymd?
       [year, month, day].any? { |rule| !rule.is_a?(DefaultRule) }
     end
 
-    def hasHM?
+    def has_hm?
       [hour, minute].any? { |rule| !rule.is_a?(DefaultRule) }
     end
 

data/lib/taskloop/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TaskLoop
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/sig/integer.rbs

@@ -0,0 +1,11 @@
+class Integer
+  def day: () -> Integer
+
+  def hour: () -> Integer
+
+  def minute: () -> Integer
+
+  def month: () -> Integer
+
+  def year: () -> Integer
+end

data/sig/string.rbs

@@ -0,0 +1,7 @@
+class String
+  def sha1: () -> String
+
+  def sha1_32bit: () -> String
+
+  def sha1_8bit: () -> String
+end

data/sig/task_loop/after_scope_rule.rbs

@@ -0,0 +1,11 @@
+module TaskLoop
+  class AfterScopeRule
+    attr_accessor left: [Symbol | Integer]
+
+    def desc: () -> String
+
+    def is_conform_rule?: (Time) -> bool
+
+    def left_value: () -> Integer
+  end
+end

data/sig/task_loop/before_scope_rule.rbs

@@ -0,0 +1,11 @@
+module TaskLoop
+  class BeforeScopeRule
+    attr_accessor right: [Symbol | Integer]
+
+    def desc: () -> String
+
+    def is_conform_rule?: (Time) -> bool
+
+    def right_value: () -> Integer
+  end
+end

data/sig/task_loop/between_scope_rule.rbs

@@ -0,0 +1,14 @@
+module TaskLoop
+  class BetweenScopeRule
+    attr_accessor left: [Symbol | Integer]
+    attr_accessor right: [Symbol | Integer]
+
+    def desc: () -> String
+
+    def is_conform_rule?: (Time) -> bool
+
+    def left_value: () -> Integer
+
+    def right_value: () -> Integer
+  end
+end

data/sig/task_loop/boundary_rule.rbs

@@ -0,0 +1,9 @@
+module TaskLoop
+  class BoundaryRule
+    BOUNDARY: Hash[Symbol, Integer]
+
+    attr_accessor boundary: Symbol
+
+    def desc: () -> String
+  end
+end

data/sig/task_loop/date_list_rule.rbs

@@ -0,0 +1,11 @@
+module TaskLoop
+  class DateListRule
+    attr_writer dates: Array[String]
+
+    def dates_values: () -> Array[Time]
+
+    def desc: () -> String
+
+    def is_conform_rule?: (Time) -> bool
+  end
+end

data/sig/task_loop/default_rule.rbs

@@ -0,0 +1,8 @@
+module TaskLoop
+  class DefaultRule
+
+    def desc: () -> String
+
+    def is_conform_rule?: (Time) -> bool
+  end
+end

data/sig/task_loop/deploy.rbs

@@ -0,0 +1,18 @@
+module TaskLoop
+  class Deploy
+    def run: () -> void
+    def register_taskfile_dir_if_needed: () -> void
+
+    def tasklist: () -> Array[Task]
+
+    private
+
+    def clean_loopfile_if_needed: () -> void
+
+    def deploy_lint?: () -> bool
+
+    def eval_taskfile: (String) -> void
+
+    def generate_taskfile_deploy: () -> void
+  end
+end

data/sig/task_loop/dsl.rbs

@@ -0,0 +1,25 @@
+module TaskLoop
+  module DSL
+    def after: ([Symbol | Integer]) -> AfterScopeRule
+
+    def at: (*[Symbol | Integer]) -> SpecificRule
+
+    def before: ([Symbol | Integer]) -> BeforeScopeRule
+
+    def between: ([Symbol | Integer], [Symbol | Integer]) -> BetweenScopeRule
+
+    def date: (*String) -> DateListRule
+
+    def env: (String, String) -> void
+
+    def from: (String) -> StartPointBoundaryRule
+
+    def interval: (Integer) -> IntervalRule
+
+    def loop: (Integer) -> LoopRule
+
+    def time: (*String) -> TimeListRule
+
+    def to: (String) -> EndPointBoundaryRule
+  end
+end

data/sig/task_loop/end_point_boundary_rule.rbs

@@ -0,0 +1,9 @@
+module TaskLoop
+  class EndPointBoundaryRule
+    attr_accessor value: String
+
+    def desc: () -> String
+
+    def is_conform_rule?: (Time) -> bool
+  end
+end