checkoff 0.18.0 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebf4493d6d8ae139dcc63fa7178ed04f1aa596b2b6b4c82d16f512daac2d19e0
-  data.tar.gz: b6116733287bc50b94aaadd541b1d9789cd3a17f0ff82e0d2fc645a4c279070f
+  metadata.gz: b6a571f1d0bef00f4e030c22ea9a1cfae923c5253f8949deeaa24d537709c723
+  data.tar.gz: 1545211bc1d508f12fd26769d41201818ea280714c96c685ca31148950ba56f9
 SHA512:
-  metadata.gz: 408c57bfb26c63a750c8eb38723eb27b4b33fdf283b99b8890f84d59515a0cea2274226059e4c4cd848e5cef5b73c99a1d9bdb78746210ec06aef0ff6dd60aaf
-  data.tar.gz: 29e6d4ebfccf6b1bee268d0cf1e753f70402be79c63def06610e13a0b426ed9e534db230f32b13385831c473ae56cb21feb0d4812f3bfa2c70ab0b187c884111
+  metadata.gz: '08f83449b8628676c61c2afc08a9723b0639572e42c646e2fd81dc8571f446ac5a5e46ccbc58ce3ea2dddc5538ac7736081f5efde01bf46fc3b2111872f7fa93'
+  data.tar.gz: ddefd4b5d02bb05a610e0ead08c3126c76f9373ceb6a339ac61777a997de753b25491447df52c4127b96bf4fb8dac01f9e57183d82da3c61f121c629f0e1a757

data/.circleci/config.yml

@@ -83,6 +83,7 @@ commands:
 
 jobs:
   overcommit:
+    working_directory: ~/checkoff
     docker:
       - image: apiology/circleci-ruby:latest
     steps:

data/Gemfile.lock

@@ -12,7 +12,7 @@ GIT
 PATH
   remote: .
   specs:
-    checkoff (0.18.0)
+    checkoff (0.19.1)
       activesupport
       asana (> 0.10.0)
       cache_method
@@ -63,7 +63,7 @@ GEM
       faraday_middleware
       multi_json
     gli (2.21.0)
-    i18n (1.11.0)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     imagen (0.1.8)
       parser (>= 2.5, != 2.5.1.1)
@@ -138,7 +138,7 @@ GEM
     simplecov-lcov (0.8.0)
     simplecov_json_formatter (0.1.3)
     tomlrb (2.0.3)
-    tzinfo (2.0.4)
+    tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
     undercover (0.4.3)
       imagen (>= 0.1.8)

data/coverage/.last_run.json

@@ -1,6 +1,6 @@
 {
   "result": {
-    "line": 98.68,
-    "branch": 93.26
+    "line": 99.61,
+    "branch": 86.52
   }
 }

data/lib/checkoff/internal/search_url_parser.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+module Checkoff
+  module Internal
+    # base class for handling different custom_field_#{gid}.variant params
+    class CustomFieldVariant
+      def initialize(gid, remaining_params)
+        @gid = gid
+        @remaining_params = remaining_params
+      end
+
+      private
+
+      attr_reader :gid, :remaining_params
+    end
+
+    # custom_field_#{gid}.variant = 'less_than'
+    class LessThanCustomFieldVariant < CustomFieldVariant
+      def convert
+        max_param = "custom_field_#{gid}.max"
+        case remaining_params.keys
+        when [max_param]
+          convert_single_custom_field_less_than_params_max_param(max_param)
+        else
+          raise "Teach me how to handle #{remaining_params}"
+        end
+      end
+
+      private
+
+      def convert_single_custom_field_less_than_params_max_param(max_param)
+        max_values = remaining_params.fetch(max_param)
+        unless max_values.length == 1
+          raise "Teach me how to handle these remaining keys for #{max_param}: #{remaining_params}"
+        end
+
+        max_value = max_values[0]
+        empty_task_selector = []
+        [{ "custom_fields.#{gid}.less_than" => max_value }, empty_task_selector]
+      end
+    end
+
+    # custom_field_#{gid}.variant = 'is_not'
+    class IsNotCustomFieldVariant < CustomFieldVariant
+      def convert
+        case remaining_params.keys
+        when ["custom_field_#{gid}.selected_options"]
+          convert_single_custom_field_is_not_params_selected_options
+        else
+          raise "Teach me how to handle #{remaining_params}"
+        end
+      end
+
+      private
+
+      def convert_single_custom_field_is_not_params_selected_options
+        selected_options = remaining_params.fetch("custom_field_#{gid}.selected_options")
+        raise "Teach me how to handle #{remaining_params}" unless selected_options.length == 1
+
+        [{ "custom_fields.#{gid}.is_set" => 'true' },
+         ['not',
+          ['custom_field_gid_value_contains_any_gid',
+           gid,
+           selected_options.fetch(0).split('~')]]]
+      end
+    end
+
+    # custom_field_#{gid}.variant = 'no_value'
+    class NoValueCustomFieldVariant < CustomFieldVariant
+      def convert
+        unless remaining_params.length.zero?
+          raise "Teach me how to handle these remaining keys for #{variant_key}: #{remaining_params}"
+        end
+
+        empty_task_selector = []
+        [{ "custom_fields.#{gid}.is_set" => 'false' }, empty_task_selector]
+      end
+    end
+
+    # custom_field_#{gid}.variant = 'is'
+    class IsCustomFieldVariant < CustomFieldVariant
+      def convert
+        unless remaining_params.length == 1
+          raise "Teach me how to handle these remaining keys for #{variant_key}: #{remaining_params}"
+        end
+
+        key, values = remaining_params.to_a[0]
+        convert_custom_field_is_arg(key, values)
+      end
+
+      private
+
+      def convert_custom_field_is_arg(key, values)
+        empty_task_selector = []
+
+        if key.end_with? '.selected_options'
+          raise "Too many values found for #{key}: #{values}" if values.length != 1
+
+          return [{ "custom_fields.#{gid}.value" => values[0] },
+                  empty_task_selector]
+        end
+
+        raise "Teach me how to handle #{key} = #{values}"
+      end
+    end
+
+    # Convert custom field parameters from an Asana search URL into
+    # API search arguments and Checkoff task selectors
+    class CustomFieldParamConverter
+      def initialize(custom_field_params:)
+        @custom_field_params = custom_field_params
+      end
+
+      def convert
+        args = {}
+        task_selector = []
+        by_custom_field.each do |gid, single_custom_field_params|
+          new_args, new_task_selector = convert_single_custom_field_params(gid,
+                                                                           single_custom_field_params)
+          args, task_selector = merge_args_and_task_selectors(args, new_args,
+                                                              task_selector, new_task_selector)
+        end
+        [args, task_selector]
+      end
+
+      private
+
+      def by_custom_field
+        custom_field_params.group_by do |key, _value|
+          gid_from_custom_field_key(key)
+        end.transform_values(&:to_h)
+      end
+
+      def merge_args_and_task_selectors(args, new_args, task_selector, new_task_selector)
+        args = args.merge(new_args)
+        return [args, task_selector] if new_task_selector == []
+
+        raise 'Teach me how to merge task selectors' unless task_selector == []
+
+        task_selector = new_task_selector
+
+        [args, task_selector]
+      end
+
+      VARIANTS = {
+        'is' => IsCustomFieldVariant,
+        'no_value' => NoValueCustomFieldVariant,
+        'is_not' => IsNotCustomFieldVariant,
+        'less_than' => LessThanCustomFieldVariant,
+      }.freeze
+
+      def convert_single_custom_field_params(gid, single_custom_field_params)
+        variant_key = "custom_field_#{gid}.variant"
+        variant = single_custom_field_params.fetch(variant_key)
+        remaining_params = single_custom_field_params.reject { |k, _v| k == variant_key }
+        raise "Teach me how to handle #{variant_key} = #{variant}" unless variant.length == 1
+
+        variant_class = VARIANTS[variant[0]]
+        return variant_class.new(gid, remaining_params).convert unless variant_class.nil?
+
+        raise "Teach me how to handle #{variant_key} = #{variant}"
+      end
+
+      def gid_from_custom_field_key(key)
+        key.split('_')[2].split('.')[0]
+      end
+
+      attr_reader :custom_field_params
+    end
+
+    # Parse Asana search URLs into parameters suitable to pass into
+    # the /workspaces/{workspace_gid}/tasks/search endpoint
+    class SearchUrlParser
+      def initialize(_deps = {}); end
+
+      def convert_params(url)
+        url_params = CGI.parse(URI.parse(url).query)
+        custom_field_params, regular_url_params = partition_url_params(url_params)
+        custom_field_args, task_selector = convert_custom_field_params(custom_field_params)
+        regular_url_args = convert_regular_params(regular_url_params)
+        [custom_field_args.merge(regular_url_args), task_selector]
+      end
+
+      private
+
+      def convert_regular_params(regular_url_params)
+        regular_url_params.to_a.map do |key, values|
+          convert_arg(key, values)
+        end.to_h
+      end
+
+      def convert_custom_field_params(custom_field_params)
+        CustomFieldParamConverter.new(custom_field_params: custom_field_params).convert
+      end
+
+      def partition_url_params(url_params)
+        url_params.to_a.partition do |key, _values|
+          key.start_with? 'custom_field_'
+        end.map(&:to_h)
+      end
+
+      # https://developers.asana.com/docs/search-tasks-in-a-workspace
+      def convert_arg(key, values)
+        case key
+        when 'any_projects.ids'
+          ['projects.any', values.join(',')]
+        when 'completion'
+          raise "Teach me how to handle #{key} = #{values}" if values.length != 1
+
+          value = values.fetch(0)
+          raise "Teach me how to handle #{key} = #{values}" if value != 'incomplete'
+
+          ['completed', false]
+        end
+      end
+    end
+  end
+end

data/lib/checkoff/internal/task_selector_evaluator.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Checkoff
+  # Base class to evaluate a task selector function given fully evaluated arguments
+  class FunctionEvaluator
+    def initialize(task_selector:)
+      @task_selector = task_selector
+    end
+
+    def evaluate_arg?(_index)
+      true
+    end
+
+    private
+
+    def fn?(object, fn_name)
+      object.is_a?(Array) && !object.empty? && [fn_name, fn_name.to_s].include?(object[0])
+    end
+
+    attr_reader :task_selector
+  end
+
+  # :not function
+  class NotFunctionEvaluator < FunctionEvaluator
+    def matches?
+      fn?(task_selector, :not)
+    end
+
+    def evaluate(_task, subvalue)
+      !subvalue
+    end
+  end
+
+  # :nil? function
+  class NilPFunctionEvaluator < FunctionEvaluator
+    def matches?
+      fn?(task_selector, :nil?)
+    end
+
+    def evaluate(_task, subvalue)
+      subvalue.nil?
+    end
+  end
+
+  # :tag function
+  class TagPFunctionEvaluator < FunctionEvaluator
+    def matches?
+      fn?(task_selector, :tag)
+    end
+
+    def evaluate_arg?(_index)
+      false
+    end
+
+    def evaluate(task, tag_name)
+      task.tags.map(&:name).include? tag_name
+    end
+  end
+
+  # :custom_field_value function
+  class CustomFieldValueFunctionEvaluator < FunctionEvaluator
+    def matches?
+      fn?(task_selector, :custom_field_value)
+    end
+
+    def evaluate_arg?(_index)
+      false
+    end
+
+    def evaluate(task, custom_field_name)
+      custom_fields = task.custom_fields
+      if custom_fields.nil?
+        raise "custom fields not found on task - did you add 'custom_field' in your extra_fields argument?"
+      end
+
+      custom_field = custom_fields.find { |field| field.fetch('name') == custom_field_name }
+      return nil if custom_field.nil?
+
+      custom_field['display_value']
+    end
+  end
+
+  # :custom_field_gid_value_contains_any_gid function
+  class CustomFieldGidValueContainsAnyGidFunctionEvaluator < FunctionEvaluator
+    def matches?
+      fn?(task_selector, :custom_field_gid_value_contains_any_gid)
+    end
+
+    def evaluate_arg?(_index)
+      false
+    end
+
+    def evaluate(task, custom_field_gid, custom_field_values_gids)
+      actual_custom_field_values_gids = pull_custom_field_values_gids(task, custom_field_gid)
+
+      (custom_field_values_gids - actual_custom_field_values_gids).empty?
+    end
+
+    private
+
+    def pull_custom_field_or_raise(task, custom_field_gid)
+      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
+
+      matched_custom_field = custom_fields.find { |data| data.fetch('gid') == custom_field_gid }
+      raise "Could not find custom field with gid #{custom_field_gid}" if matched_custom_field.nil?
+
+      matched_custom_field
+    end
+
+    def pull_custom_field_values_gids(task, custom_field_gid)
+      matched_custom_field = pull_custom_field_or_raise(task, custom_field_gid)
+
+      enum_value = matched_custom_field.fetch('enum_value')
+      actual_custom_field_values_gids = []
+      unless enum_value.nil?
+        if enum_value.fetch('enabled') == false
+          raise "Unexpected enabled value on custom field: #{matched_custom_field}"
+        end
+
+        actual_custom_field_values_gids = [enum_value.fetch('gid')]
+      end
+      actual_custom_field_values_gids
+    end
+  end
+
+  # Evaluator task selectors against a task
+  class TaskSelectorEvaluator
+    def initialize(task:)
+      @task = task
+    end
+
+    FUNCTION_EVALUTORS = [
+      NotFunctionEvaluator,
+      NilPFunctionEvaluator,
+      TagPFunctionEvaluator,
+      CustomFieldValueFunctionEvaluator,
+      CustomFieldGidValueContainsAnyGidFunctionEvaluator,
+    ].freeze
+
+    def evaluate(task_selector)
+      return true if task_selector == []
+
+      FUNCTION_EVALUTORS.each do |evaluator_class|
+        evaluator = evaluator_class.new(task_selector: task_selector)
+
+        next unless evaluator.matches?
+
+        return try_this_evaluator(task_selector, evaluator)
+      end
+
+      raise "Syntax issue trying to handle #{task_selector}"
+    end
+
+    private
+
+    def try_this_evaluator(task_selector, evaluator)
+      evaluated_args = task_selector[1..].map.with_index do |item, index|
+        if evaluator.evaluate_arg?(index)
+          evaluate(item)
+        else
+          item
+        end
+      end
+
+      evaluator.evaluate(task, *evaluated_args)
+    end
+
+    attr_reader :task, :task_selector
+  end
+end

data/lib/checkoff/task_searches.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'cache_method'
+require_relative 'internal/config_loader'
+require_relative 'workspaces'
+require_relative 'projects'
+require_relative 'clients'
+require_relative 'task_selectors'
+require 'asana/resource_includes/collection'
+require 'asana/resource_includes/response_helper'
+
+require 'checkoff/internal/search_url_parser'
+
+# https://developers.asana.com/docs/task-searches
+module Checkoff
+  # Run task searches against the Asana API
+  class TaskSearches
+    MINUTE = 60
+    HOUR = MINUTE * 60
+    DAY = 24 * HOUR
+    REALLY_LONG_CACHE_TIME = HOUR * 1
+    LONG_CACHE_TIME = MINUTE * 15
+    SHORT_CACHE_TIME = MINUTE
+
+    include Asana::Resources::ResponseHelper
+
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana),
+                   workspaces: Checkoff::Workspaces.new(config: config),
+                   task_selectors: Checkoff::TaskSelectors.new(config: config),
+                   projects: Checkoff::Projects.new(config: config),
+                   clients: Checkoff::Clients.new(config: config),
+                   client: clients.client,
+                   search_url_parser: Checkoff::Internal::SearchUrlParser.new,
+                   asana_resources_collection_class: Asana::Resources::Collection)
+      @workspaces = workspaces
+      @task_selectors = task_selectors
+      @projects = projects
+      @client = client
+      @search_url_parser = search_url_parser
+      @asana_resources_collection_class = asana_resources_collection_class
+    end
+
+    def task_search(workspace_name, url, extra_fields: [])
+      workspace = workspaces.workspace_or_raise(workspace_name)
+      api_params, task_selector = @search_url_parser.convert_params(url)
+      path = "/workspaces/#{workspace.gid}/tasks/search"
+      options = calculate_api_options(extra_fields)
+      tasks = @asana_resources_collection_class.new(parse(client.get(path,
+                                                                     params: api_params,
+                                                                     options: options)),
+                                                    type: Asana::Resources::Task,
+                                                    client: client)
+      tasks.select { |task| task_selectors.filter_via_task_selector(task, task_selector) }
+    end
+    cache_method :task_search, LONG_CACHE_TIME
+
+    private
+
+    def calculate_api_options(extra_fields)
+      options = projects.task_options[:options]
+      options[:fields] += ['custom_fields']
+      options[:fields] += extra_fields
+      options
+    end
+
+    # bundle exec ./task_searches.rb
+    # :nocov:
+    class << self
+      def run
+        workspace_name = ARGV[0] || raise('Please pass workspace name as first argument')
+        url = ARGV[1] || raise('Please pass task search URL as second argument')
+        task_searches = Checkoff::TaskSearches.new
+        task_search = task_searches.task_search(workspace_name, url)
+        puts "Results: #{task_search}"
+      end
+    end
+    # :nocov:
+
+    attr_reader :task_selectors, :projects, :workspaces, :client
+  end
+end
+
+# :nocov:
+abs_program_name = File.expand_path($PROGRAM_NAME)
+Checkoff::TaskSearches.run if abs_program_name == __FILE__
+# :nocov:

data/lib/checkoff/task_selectors.rb

@@ -6,8 +6,7 @@ require 'forwardable'
 require 'cache_method'
 require 'json'
 require_relative 'internal/config_loader'
-require_relative 'workspaces'
-require_relative 'clients'
+require_relative 'internal/task_selector_evaluator'
 
 # https://developers.asana.com/docs/task-selectors
 
@@ -21,49 +20,17 @@ module Checkoff
     LONG_CACHE_TIME = MINUTE * 15
     SHORT_CACHE_TIME = MINUTE
 
-    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana),
-                   workspaces: Checkoff::Workspaces.new(config: config),
-                   clients: Checkoff::Clients.new(config: config),
-                   client: clients.client)
-      @workspaces = workspaces
-      @client = client
+    def initialize(config: Checkoff::Internal::ConfigLoader.load(:asana))
+      @config = config
     end
 
     # @param [Hash<Symbol, Object>] task_selector Filter based on
     #        description.  Examples: {tag: 'foo'} {:not {tag: 'foo'} (:tag 'foo')
     def filter_via_task_selector(task, task_selector)
-      return true if task_selector == []
-
-      return !filter_via_task_selector(task, task_selector.fetch(1)) if fn?(task_selector, :not)
-
-      return filter_via_task_selector(task, task_selector.fetch(1)).nil? if fn?(task_selector, :nil?)
-
-      return contains_tag?(task, task_selector.fetch(1)) if fn?(task_selector, :tag)
-
-      return custom_field_value(task, task_selector.fetch(1)) if fn?(task_selector, :custom_field_value)
-
-      raise "Syntax issue trying to handle #{task_selector}"
-    end
-
-    private
-
-    def contains_tag?(task, tag_name)
-      task.tags.map(&:name).include? tag_name
-    end
-
-    def custom_field_value(task, custom_field_name)
-      custom_field = task.custom_fields.find { |field| field.fetch('name') == custom_field_name }
-      return nil if custom_field.nil?
-
-      custom_field['display_value']
+      evaluator = TaskSelectorEvaluator.new(task: task)
+      evaluator.evaluate(task_selector)
     end
 
-    def fn?(object, fn_name)
-      object.is_a?(Array) && !object.empty? && [fn_name, fn_name.to_s].include?(object[0])
-    end
-
-    attr_reader :workspaces, :client
-
     # bundle exec ./task_selectors.rb
     # :nocov:
     class << self
@@ -84,12 +51,13 @@ module Checkoff
         require 'checkoff/projects'
 
         task_selectors = Checkoff::TaskSelectors.new
-        extra_fields = []
+        extra_fields = ['custom_fields']
         projects = Checkoff::Projects.new
-        project = projects.project(workspace_name, project_name)
+        project = projects.project_or_raise(workspace_name, project_name)
         raw_tasks = projects.tasks_from_project(project, extra_fields: extra_fields)
         tasks = raw_tasks.filter { |task| task_selectors.filter_via_task_selector(task, task_selector) }
-        puts "Results: #{tasks}"
+        # avoid n+1 queries generating the full task formatting
+        puts JSON.pretty_generate(tasks.map(&:to_h))
       end
     end
     # :nocov:

data/lib/checkoff/version.rb

@@ -3,5 +3,5 @@
 # Command-line and gem client for Asana (unofficial)
 module Checkoff
   # Version of library
-  VERSION = '0.18.0'
+  VERSION = '0.19.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: checkoff
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.1
 platform: ruby
 authors:
 - Vince Broz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-12 00:00:00.000000000 Z
+date: 2022-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -322,11 +322,14 @@ files:
 - lib/checkoff/custom_fields.rb
 - lib/checkoff/internal/config_loader.rb
 - lib/checkoff/internal/create-class.sh
+- lib/checkoff/internal/search_url_parser.rb
+- lib/checkoff/internal/task_selector_evaluator.rb
 - lib/checkoff/my_tasks.rb
 - lib/checkoff/projects.rb
 - lib/checkoff/sections.rb
 - lib/checkoff/subtasks.rb
 - lib/checkoff/tags.rb
+- lib/checkoff/task_searches.rb
 - lib/checkoff/task_selectors.rb
 - lib/checkoff/tasks.rb
 - lib/checkoff/version.rb