checkoff 0.58.1 → 0.59.0

data/lib/checkoff/internal/selector_classes/task/function_evaluator.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative '../function_evaluator'
+
+module Checkoff
+  module SelectorClasses
+    module Task
+      # Base class to evaluate a task selector function given fully evaluated arguments
+      class FunctionEvaluator < ::Checkoff::SelectorClasses::FunctionEvaluator
+        # @param selector [Array<(Symbol, Array)>,String]
+        # @param tasks [Checkoff::Tasks]
+        def initialize(selector:,
+                       tasks:)
+          @selector = selector
+          @tasks = tasks
+          super()
+        end
+
+        private
+
+        # @param task [Asana::Resources::Task]
+        # @param field_name [Symbol]
+        #
+        # @sg-ignore
+        # @return [Date, nil]
+        def pull_date_field_by_name(task, field_name)
+          if field_name == :modified
+            return Time.parse(task.modified_at).to_date unless task.modified_at.nil?
+
+            return nil
+          end
+
+          if field_name == :due
+            return Time.parse(task.due_at).to_date unless task.due_at.nil?
+
+            return Date.parse(task.due_on) unless task.due_on.nil?
+
+            return nil
+          end
+
+          raise "Teach me how to handle field #{field_name}"
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param field_name [Symbol]
+        #
+        # @sg-ignore
+        # @return [Date, Time, nil]
+        def pull_date_or_time_field_by_name(task, field_name)
+          if field_name == :due
+            return Time.parse(task.due_at) unless task.due_at.nil?
+
+            return Date.parse(task.due_on) unless task.due_on.nil?
+
+            return nil
+          end
+
+          if field_name == :start
+            return Time.parse(task.start_at) unless task.start_at.nil?
+
+            return Date.parse(task.start_on) unless task.start_on.nil?
+
+            return nil
+          end
+
+          raise "Teach me how to handle field #{field_name}"
+        end
+
+        # @sg-ignore
+        # @param task [Asana::Resources::Task]
+        # @param custom_field_gid [String]
+        # @return [Hash]
+        def pull_custom_field_or_raise(task, custom_field_gid)
+          # @type [Array<Hash>]
+          custom_fields = task.custom_fields
+          if custom_fields.nil?
+            raise "Could not find custom_fields under task (was 'custom_fields' included in 'extra_fields'?)"
+          end
+
+          # @sg-ignore
+          # @type [Hash, nil]
+          matched_custom_field = custom_fields.find { |data| data.fetch('gid') == custom_field_gid }
+          if matched_custom_field.nil?
+            raise "Could not find custom field with gid #{custom_field_gid} " \
+                  "in task #{task.gid} with custom fields #{custom_fields}"
+          end
+
+          matched_custom_field
+        end
+
+        # @return [Array<(Symbol, Array)>]
+        attr_reader :selector
+
+        # @sg-ignore
+        # @param custom_field [Hash]
+        # @return [Array<String>]
+        def pull_enum_values(custom_field)
+          resource_subtype = custom_field.fetch('resource_subtype')
+          case resource_subtype
+          when 'enum'
+            [custom_field.fetch('enum_value')]
+          when 'multi_enum'
+            custom_field.fetch('multi_enum_values')
+          else
+            raise "Teach me how to handle resource_subtype #{resource_subtype}"
+          end
+        end
+
+        # @param custom_field [Hash]
+        # @param enum_value [Object, nil]
+        # @return [Array<String>]
+        def find_gids(custom_field, enum_value)
+          if enum_value.nil?
+            []
+          else
+            raise "Unexpected enabled value on custom field: #{custom_field}" if enum_value.fetch('enabled') == false
+
+            [enum_value.fetch('gid')]
+          end
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param custom_field_gid [String]
+        # @return [Array<String>]
+        def pull_custom_field_values_gids(task, custom_field_gid)
+          custom_field = pull_custom_field_or_raise(task, custom_field_gid)
+          pull_enum_values(custom_field).flat_map do |enum_value|
+            find_gids(custom_field, enum_value)
+          end
+        end
+
+        # @sg-ignore
+        # @param task [Asana::Resources::Task]
+        # @param custom_field_name [String]
+        # @return [Hash, nil]
+        def pull_custom_field_by_name(task, custom_field_name)
+          custom_fields = task.custom_fields
+          if custom_fields.nil?
+            raise "custom fields not found on task - did you add 'custom_fields' in your extra_fields argument?"
+          end
+
+          # @sg-ignore
+          # @type [Hash, nil]
+          custom_fields.find { |field| field.fetch('name') == custom_field_name }
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param custom_field_name [String]
+        # @return [Hash]
+        def pull_custom_field_by_name_or_raise(task, custom_field_name)
+          custom_field = pull_custom_field_by_name(task, custom_field_name)
+          if custom_field.nil?
+            raise "Could not find custom field with name #{custom_field_name} " \
+                  "in task #{task.gid} with custom fields #{task.custom_fields}"
+          end
+          custom_field
+        end
+      end
+    end
+  end
+end

data/lib/checkoff/internal/selector_classes/task.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require_relative 'task/function_evaluator'
+
+module Checkoff
+  module SelectorClasses
+    module Task
+      # :tag function
+      class TagPFunctionEvaluator < FunctionEvaluator
+        def matches?
+          fn?(selector, :tag)
+        end
+
+        # @param _index [Integer]
+        def evaluate_arg?(_index)
+          false
+        end
+
+        # @sg-ignore
+        # @param task [Asana::Resources::Task]
+        # @param tag_name [String]
+        # @return [Boolean]
+        def evaluate(task, tag_name)
+          task.tags.map(&:name).include? tag_name
+        end
+      end
+
+      # :due function
+      class DuePFunctionEvaluator < FunctionEvaluator
+        def matches?
+          fn?(selector, :due)
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param ignore_dependencies [Boolean]
+        # @return [Boolean]
+        def evaluate(task, ignore_dependencies: false)
+          @tasks.task_ready?(task, ignore_dependencies: ignore_dependencies)
+        end
+      end
+
+      # :unassigned function
+      class UnassignedPFunctionEvaluator < FunctionEvaluator
+        def matches?
+          fn?(selector, :unassigned)
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @return [Boolean]
+        def evaluate(task)
+          task.assignee.nil?
+        end
+      end
+
+      # :due_date_set function
+      class DueDateSetPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :due_date_set
+
+        def matches?
+          fn?(selector, FUNCTION_NAME)
+        end
+
+        # @sg-ignore
+        # @param task [Asana::Resources::Task]
+        # @return [Boolean]
+        def evaluate(task)
+          !task.due_at.nil? || !task.due_on.nil?
+        end
+      end
+
+      # :due_between_n_days function
+      class DueBetweenRelativePFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :due_between_relative
+
+        def matches?
+          fn?(selector, FUNCTION_NAME)
+        end
+
+        # @param _index [Integer]
+        def evaluate_arg?(_index)
+          false
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param beginning_num_days_from_now [Integer]
+        # @param end_num_days_from_now [Integer]
+        # @param ignore_dependencies [Boolean]
+        #
+        # @return [Boolean]
+        def evaluate(task, beginning_num_days_from_now, end_num_days_from_now, ignore_dependencies: false)
+          beginning_n_days_from_now_time = (Time.now + (beginning_num_days_from_now * 24 * 60 * 60))
+          end_n_days_from_now_time = (Time.now + (end_num_days_from_now * 24 * 60 * 60))
+
+          # @type [Date, Time, nil]
+          task_date_or_time = pull_date_or_time_field_by_name(task, :start) ||
+                              pull_date_or_time_field_by_name(task, :due)
+
+          return false if task_date_or_time.nil?
+
+          # if time
+          in_range = if task_date_or_time.is_a?(Time)
+                       task_date_or_time > beginning_n_days_from_now_time &&
+                         task_date_or_time <= end_n_days_from_now_time
+                     else
+                       # if date
+                       task_date_or_time > beginning_n_days_from_now_time.to_date &&
+                         task_date_or_time <= end_n_days_from_now_time.to_date
+                     end
+
+          return false unless in_range
+
+          return false if !ignore_dependencies && @tasks.incomplete_dependencies?(task)
+
+          true
+        end
+      end
+
+      # :field_less_than_n_days_ago
+      class FieldLessThanNDaysAgoPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :field_less_than_n_days_ago
+
+        def matches?
+          fn?(selector, FUNCTION_NAME)
+        end
+
+        def evaluate_arg?(_index)
+          false
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param field_name [Symbol]
+        # @param num_days [Integer]
+        #
+        # @return [Boolean]
+        def evaluate(task, field_name, num_days)
+          date = pull_date_field_by_name(task, field_name)
+
+          return false if date.nil?
+
+          # @sg-ignore
+          n_days_ago = Date.today - num_days
+          # @sg-ignore
+          date < n_days_ago
+        end
+      end
+
+      # :field_greater_than_or_equal_to_n_days_from_today
+      class FieldGreaterThanOrEqualToNDaysFromTodayPFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :field_greater_than_or_equal_to_n_days_from_today
+
+        def matches?
+          fn?(selector, FUNCTION_NAME)
+        end
+
+        def evaluate_arg?(_index)
+          false
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param field_name [Symbol]
+        # @param num_days [Integer]
+        #
+        # @return [Boolean]
+        def evaluate(task, field_name, num_days)
+          date = pull_date_field_by_name(task, field_name)
+
+          return false if date.nil?
+
+          # @sg-ignore
+          n_days_from_today = Date.today + num_days
+          # @sg-ignore
+          date >= n_days_from_today
+        end
+      end
+
+      # :custom_field_less_than_n_days_from_now function
+      class CustomFieldLessThanNDaysFromNowFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :custom_field_less_than_n_days_from_now
+
+        def matches?
+          fn?(selector, FUNCTION_NAME)
+        end
+
+        def evaluate_arg?(_index)
+          false
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param custom_field_name [String]
+        # @param num_days [Integer]
+        # @return [Boolean]
+        def evaluate(task, custom_field_name, num_days)
+          custom_field = pull_custom_field_by_name_or_raise(task, custom_field_name)
+
+          # @sg-ignore
+          # @type [String, nil]
+          time_str = custom_field.fetch('display_value')
+          return false if time_str.nil?
+
+          time = Time.parse(time_str)
+          n_days_from_now = (Time.now + (num_days * 24 * 60 * 60))
+          time < n_days_from_now
+        end
+      end
+
+      # :custom_field_greater_than_or_equal_to_n_days_from_now function
+      class CustomFieldGreaterThanOrEqualToNDaysFromNowFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :custom_field_greater_than_or_equal_to_n_days_from_now
+
+        def matches?
+          fn?(selector, FUNCTION_NAME)
+        end
+
+        def evaluate_arg?(_index)
+          false
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param custom_field_name [String]
+        # @param num_days [Integer]
+        # @return [Boolean]
+        def evaluate(task, custom_field_name, num_days)
+          custom_field = pull_custom_field_by_name_or_raise(task, custom_field_name)
+
+          # @sg-ignore
+          # @type [String, nil]
+          time_str = custom_field.fetch('display_value')
+          return false if time_str.nil?
+
+          time = Time.parse(time_str)
+          n_days_from_now = (Time.now + (num_days * 24 * 60 * 60))
+          time >= n_days_from_now
+        end
+      end
+
+      # :last_story_created_less_than_n_days_ago function
+      class LastStoryCreatedLessThanNDaysAgoFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :last_story_created_less_than_n_days_ago
+
+        def matches?
+          fn?(selector, FUNCTION_NAME)
+        end
+
+        def evaluate_arg?(_index)
+          false
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @param num_days [Integer]
+        # @param excluding_resource_subtypes [Array<String>]
+        # @return [Boolean]
+        def evaluate(task, num_days, excluding_resource_subtypes)
+          # for whatever reason, .last on the enumerable does not impose ordering; .to_a does!
+
+          # @type [Array<Asana::Resources::Story>]
+          stories = task.stories(per_page: 100).to_a.reject do |story|
+            excluding_resource_subtypes.include? story.resource_subtype
+          end
+          return true if stories.empty? # no stories == infinitely old!
+
+          last_story = stories.last
+          last_story_created_at = Time.parse(last_story.created_at)
+          n_days_ago = Time.now - (num_days * 24 * 60 * 60)
+          last_story_created_at < n_days_ago
+        end
+      end
+
+      # :estimate_exceeds_duration
+      class EstimateExceedsDurationFunctionEvaluator < FunctionEvaluator
+        FUNCTION_NAME = :estimate_exceeds_duration
+
+        def matches?
+          fn?(selector, FUNCTION_NAME)
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @return [Float]
+        def calculate_allocated_hours(task)
+          due_on = nil
+          start_on = nil
+          start_on = Date.parse(task.start_on) unless task.start_on.nil?
+          due_on = Date.parse(task.due_on) unless task.due_on.nil?
+          allocated_hours = 8.0
+          # @sg-ignore
+          allocated_hours = (due_on - start_on + 1).to_i * 8.0 if start_on && due_on
+          allocated_hours
+        end
+
+        # @param task [Asana::Resources::Task]
+        # @return [Boolean]
+        def evaluate(task)
+          custom_field = pull_custom_field_by_name_or_raise(task, 'Estimated time')
+
+          # @sg-ignore
+          # @type [Integer, nil]
+          estimate_minutes = custom_field.fetch('number_value')
+
+          # no estimate set
+          return false if estimate_minutes.nil?
+
+          estimate_hours = estimate_minutes / 60.0
+
+          allocated_hours = calculate_allocated_hours(task)
+
+          estimate_hours > allocated_hours
+        end
+      end
+    end
+  end
+end

data/lib/checkoff/internal/selector_evaluator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Checkoff
+  # Base class to evaluate Asana resource selectors against an Asana resource
+  class SelectorEvaluator
+    # @param selector [Array]
+    # @return [Boolean, Object, nil]
+    def evaluate(selector)
+      return true if selector.empty?
+
+      function_evaluators.each do |evaluator_class|
+        # @type [SelectorClasses::FunctionEvaluator]
+        # @sg-ignore
+        evaluator = evaluator_class.new(selector: selector,
+                                        **initializer_kwargs)
+
+        next unless evaluator.matches?
+
+        return try_this_evaluator(selector, evaluator)
+      end
+
+      raise "Syntax issue trying to handle #{selector.inspect}"
+    end
+
+    private
+
+    # @return [Hash]
+    def initializer_kwargs
+      {}
+    end
+
+    # @return [Array<Class<FunctionEvaluator>>]
+    # @sg-ignore
+    def function_evaluators
+      raise 'Implement me!'
+    end
+
+    # @param selector [Array]
+    # @param evaluator [SelectorClasses::FunctionEvaluator]
+    # @return [Array]
+    def evaluate_args(selector, evaluator)
+      return [] unless selector.is_a?(Array)
+
+      selector[1..].map.with_index do |item, index|
+        if evaluator.evaluate_arg?(index)
+          evaluate(item)
+        else
+          item
+        end
+      end
+    end
+
+    # @param selector [Array]
+    # @param evaluator [SelectorClasses::FunctionEvaluator]
+    # @return [Boolean, Object, nil]
+    def try_this_evaluator(selector, evaluator)
+      # if selector is an array
+      evaluated_args = evaluate_args(selector, evaluator)
+
+      evaluator.evaluate(item, *evaluated_args)
+    end
+
+    # @return [Asana::Resources::Resource]
+    attr_reader :item
+  end
+end