checkoff 0.6.0 → 0.11.0

data/lib/checkoff/cli.rb

@@ -4,6 +4,7 @@
 
 require 'ostruct'
 require 'dalli'
+require 'gli'
 require 'cache_method'
 require_relative 'workspaces'
 require_relative 'projects'
@@ -11,40 +12,44 @@ require_relative 'tasks'
 require_relative 'sections'
 
 module Checkoff
-  # Provide ability for CLI to pull Asana items
-  class CLI
-    attr_reader :sections, :stderr
-
-    def initialize(config: Checkoff::ConfigLoader.load(:asana),
-                   workspaces: Checkoff::Workspaces.new(config: config),
+  # CLI subcommand that shows tasks in JSON form
+  class ViewSubcommand
+    def initialize(workspace_name, project_name, section_name,
+                   task_name,
+                   config: Checkoff::ConfigLoader.load(:asana),
                    projects: Checkoff::Projects.new(config: config),
                    sections: Checkoff::Sections.new(config: config,
                                                     projects: projects),
-                   tasks: Checkoff::Tasks.new(config: config),
-                   stderr: $stderr,
-                   kernel: Kernel)
-      @workspaces = workspaces
-      @projects = projects
+                   tasks: Checkoff::Tasks.new(config: config,
+                                              sections: sections),
+                   stderr: $stderr)
+      @workspace_name = workspace_name
+      @stderr = stderr
+      validate_and_assign_project_name(project_name)
+      @section_name = section_name
+      @task_name = task_name
       @sections = sections
       @tasks = tasks
-      @kernel = kernel
-      @stderr = stderr
     end
 
-    def task_to_hash(task)
-      task_out = {
-        name: task.name,
-      }
-      if task.due_on
-        task_out[:due] = task.due_on
-      elsif task.due_at
-        task_out[:due] = task.due_at
+    def run
+      if section_name.nil?
+        run_on_project(workspace_name, project_name)
+      elsif task_name.nil?
+        run_on_section(workspace_name, project_name, section_name)
+      else
+        run_on_task(workspace_name, project_name, section_name, task_name)
       end
-      task_out
     end
 
-    def tasks_to_hash(tasks)
-      tasks.map { |task| task_to_hash(task) }
+    private
+
+    def validate_and_assign_project_name(project_name)
+      @project_name = if project_name.start_with? ':'
+                        project_name[1..].to_sym
+                      else
+                        project_name
+                      end
     end
 
     def run_on_project(workspace, project)
@@ -62,72 +67,88 @@ module Checkoff
       tasks_to_hash(tasks).to_json
     end
 
-    def quickadd(workspace_name, task_name)
-      workspace = @workspaces.workspace_by_name(workspace_name)
-      @tasks.add_task(task_name,
-                      workspace_gid: workspace.gid)
+    def run_on_task(workspace, project, section, task_name)
+      section = nil if section == ''
+      task = tasks.task(workspace, project, task_name, section_name: section)
+      task_to_hash(task).to_json
     end
 
-    def validate_args!(args)
-      return unless args.length < 2 || !%w[view quickadd].include?(args[0])
-
-      output_help
-      exit(1)
+    def task_to_hash(task)
+      task_out = {
+        name: task.name,
+      }
+      if task.due_on
+        task_out[:due] = task.due_on
+      elsif task.due_at
+        task_out[:due] = task.due_at
+      end
+      task_out
     end
 
-    def parse_view_args(subargs, args)
-      subargs.workspace = args[1]
-      subargs.project = args[2]
-      subargs.section = args[3]
+    def tasks_to_hash(tasks)
+      tasks.map { |task| task_to_hash(task) }
     end
 
-    def parse_quickadd_args(subargs, args)
-      subargs.workspace = args[1]
-      subargs.task_name = args[2]
-    end
+    attr_reader :workspace_name, :project_name, :section_name, :task_name, :sections, :tasks, :stderr
+  end
 
-    def parse_args(args)
-      mode = args[0]
-      subargs = OpenStruct.new
-      case mode
-      when 'view'
-        parse_view_args(subargs, args)
-      when 'quickadd'
-        parse_quickadd_args(subargs, args)
-      else
-        raise
-      end
-      [mode, subargs]
+  # CLI subcommand that creates a task
+  class QuickaddSubcommand
+    def initialize(workspace_name, task_name,
+                   config: Checkoff::ConfigLoader.load(:asana),
+                   workspaces: Checkoff::Workspaces.new(config: config),
+                   tasks: Checkoff::Tasks.new(config: config))
+      @workspace_name = workspace_name
+      @task_name = task_name
+      @workspaces = workspaces
+      @tasks = tasks
     end
 
-    def output_help
-      stderr.puts 'View tasks:'
-      stderr.puts "  #{$PROGRAM_NAME} view workspace project [section]"
-      stderr.puts "  #{$PROGRAM_NAME} quickadd workspace task_name"
-      stderr.puts
-      stderr.puts "'project' can be set to a project name, or :my_tasks, " \
-                  ":my_tasks_upcoming, :my_tasks_new, or :my_tasks_today"
+    def run
+      workspace = @workspaces.workspace_by_name(workspace_name)
+      @tasks.add_task(task_name,
+                      workspace_gid: workspace.gid)
     end
 
-    def view(workspace_name, project_name, section_name)
-      project_name = project_name[1..-1].to_sym if project_name.start_with? ':'
-      if section_name.nil?
-        run_on_project(workspace_name, project_name)
-      else
-        run_on_section(workspace_name, project_name, section_name)
+    private
+
+    attr_reader :workspace_name, :task_name
+  end
+
+  # Provide ability for CLI to pull Asana items
+  class CheckoffGLIApp
+    extend GLI::App
+
+    program_desc 'Command-line client for Asana (unofficial)'
+
+    subcommand_option_handling :normal
+    arguments :strict
+
+    desc 'Add a short task to Asana'
+    arg 'workspace'
+    arg 'task_name'
+    command :quickadd do |c|
+      c.action do |_global_options, _options, args|
+        workspace_name = args.fetch(0)
+        task_name = args.fetch(1)
+
+        QuickaddSubcommand.new(workspace_name, task_name).run
       end
     end
 
-    def run(args)
-      validate_args!(args)
-      command, subargs = parse_args(args)
-      case command
-      when 'view'
-        view(subargs.workspace, subargs.project, subargs.section)
-      when 'quickadd'
-        quickadd(subargs.workspace, subargs.task_name)
-      else
-        raise
+    desc 'Output representation of Asana tasks'
+    arg 'workspace'
+    arg 'project'
+    arg 'section', :optional
+    arg 'task_name', :optional
+    command :view do |c|
+      c.action do |_global_options, _options, args|
+        workspace_name = args.fetch(0)
+        project_name = args.fetch(1)
+        section_name = args[2]
+        task_name = args[3]
+
+        puts ViewSubcommand.new(workspace_name, project_name, section_name, task_name).run
       end
     end
   end

data/lib/checkoff/config_loader.rb

@@ -4,12 +4,58 @@ require 'yaml'
 require 'active_support/core_ext/hash'
 
 module Checkoff
+  # Use the provided config from a YAML file, and fall back to env
+  # variable if it's not populated for a key'
+  class EnvFallbackConfigLoader
+    def initialize(config, sym, yaml_filename)
+      @config = config
+      @envvar_prefix = sym.upcase
+      @yaml_filename = yaml_filename
+    end
+
+    def [](key)
+      config_value = @config[key]
+      return config_value unless config_value.nil?
+
+      ENV[envvar_name(key)]
+    end
+
+    def fetch(key)
+      out = self[key]
+      return out unless out.nil?
+
+      raise KeyError,
+            "Please configure either the #{key} key in #{@yaml_filename} or set #{envvar_name(key)}"
+    end
+
+    private
+
+    def envvar_name(key)
+      "#{@envvar_prefix}__#{key.upcase}"
+    end
+  end
+
   # Load configuration file
   class ConfigLoader
-    def self.load(sym)
-      file = "#{sym}.yml"
-      YAML.load_file(File.expand_path("~/.#{file}"))
-          .with_indifferent_access
+    class << self
+      def load(sym)
+        yaml_result = load_yaml_file(sym)
+        EnvFallbackConfigLoader.new(yaml_result, sym, yaml_filename(sym))
+      end
+
+      private
+
+      def load_yaml_file(sym)
+        filename = yaml_filename(sym)
+        return {} unless File.exist?(filename)
+
+        YAML.load_file(filename).with_indifferent_access
+      end
+
+      def yaml_filename(sym)
+        file = "#{sym}.yml"
+        File.expand_path("~/.#{file}")
+      end
     end
   end
 end

data/lib/checkoff/projects.rb

@@ -22,8 +22,6 @@ module Checkoff
     LONG_CACHE_TIME = MINUTE * 15
     SHORT_CACHE_TIME = MINUTE * 5
 
-    # XXX: Move low-level functions private
-
     def initialize(config: Checkoff::ConfigLoader.load(:asana),
                    asana_client: Asana::Client,
                    workspaces: Checkoff::Workspaces.new(config: config))
@@ -32,30 +30,12 @@ module Checkoff
       @workspaces = workspaces
     end
 
+    # Returns Asana Ruby API Client object
     def client
       @workspaces.client
     end
 
-    def projects
-      client.projects
-    end
-    cache_method :projects, LONG_CACHE_TIME
-
-    def projects_by_workspace_name(workspace_name)
-      workspace = @workspaces.workspace_by_name(workspace_name)
-      raise "Could not find workspace named #{workspace_name}" unless workspace
-
-      projects.find_by_workspace(workspace: workspace.gid)
-    end
-
-    def my_tasks(workspace_name)
-      my_tasks = @config[:my_tasks]
-      gid = @config[:my_tasks][workspace_name] unless my_tasks.nil?
-      raise "Please define [:my_tasks][#{workspace_name}] in config file" if my_tasks.nil? || gid.nil?
-
-      projects.find_by_id(gid)
-    end
-
+    # pulls an Asana API project class given a name
     def project(workspace_name, project_name)
       if project_name.is_a?(Symbol) && project_name.to_s.start_with?('my_tasks')
         my_tasks(workspace_name)
@@ -68,10 +48,43 @@ module Checkoff
     end
     cache_method :project, LONG_CACHE_TIME
 
+    # find uncompleted tasks in a list
     def active_tasks(tasks)
       tasks.select { |task| task.completed_at.nil? }
     end
 
+    # pull task objects from a named project
+    def tasks_from_project(project, only_uncompleted: true, extra_fields: [])
+      options = task_options
+      options[:completed_since] = '9999-12-01' if only_uncompleted
+      options[:project] = project.gid
+      options[:options][:fields] += extra_fields
+      client.tasks.find_all(**options).to_a
+    end
+    cache_method :tasks_from_project, SHORT_CACHE_TIME
+
+    private
+
+    def projects
+      client.projects
+    end
+    cache_method :projects, LONG_CACHE_TIME
+
+    def projects_by_workspace_name(workspace_name)
+      workspace = @workspaces.workspace_by_name(workspace_name)
+      raise "Could not find workspace named #{workspace_name}" unless workspace
+
+      projects.find_by_workspace(workspace: workspace.gid)
+    end
+
+    def my_tasks(workspace_name)
+      workspace = @workspaces.workspace_by_name(workspace_name)
+      result = client.user_task_lists.get_user_task_list_for_user(user_gid: 'me',
+                                                                  workspace: workspace.gid)
+      gid = result.gid
+      projects.find_by_id(gid)
+    end
+
     def task_options
       {
         per_page: 100,
@@ -81,14 +94,5 @@ module Checkoff
         },
       }
     end
-
-    def tasks_from_project(project, only_uncompleted: true, extra_fields: [])
-      options = task_options
-      options[:completed_since] = '9999-12-01' if only_uncompleted
-      options[:project] = project.gid
-      options[:options][:fields] += extra_fields
-      client.tasks.find_all(**options).to_a
-    end
-    cache_method :tasks_from_project, SHORT_CACHE_TIME
   end
 end

data/lib/checkoff/sections.rb

@@ -4,6 +4,7 @@ require 'forwardable'
 
 module Checkoff
   # Query different sections of Asana projects
+  # rubocop:disable Metrics/ClassLength
   class Sections
     MINUTE = 60
     LONG_CACHE_TIME = MINUTE * 15
@@ -11,15 +12,82 @@ module Checkoff
 
     extend Forwardable
 
-    attr_reader :projects, :time
+    attr_reader :projects, :workspaces, :time
 
     def initialize(config: Checkoff::ConfigLoader.load(:asana),
                    projects: Checkoff::Projects.new(config: config),
+                   workspaces: Checkoff::Workspaces.new(config: config),
                    time: Time)
       @projects = projects
+      @workspaces = workspaces
       @time = time
     end
 
+    # Given a list of tasks, pull a Hash of tasks with section name -> task list
+    def by_section(tasks, project_gid)
+      by_section = {}
+      tasks.each do |task|
+        file_task_by_section(by_section, task, project_gid)
+      end
+      by_section
+    end
+    cache_method :by_section, LONG_CACHE_TIME
+
+    # Given a project object, pull all tasks, then provide a Hash of
+    # tasks with section name -> task list of the uncompleted tasks
+    def tasks_by_section_for_project(project)
+      raw_tasks = projects.tasks_from_project(project)
+      active_tasks = projects.active_tasks(raw_tasks)
+      by_section(active_tasks, project.gid)
+    end
+
+    # Given a workspace name and project name, then provide a Hash of
+    # tasks with section name -> task list of the uncompleted tasks
+    def tasks_by_section(workspace_name, project_name)
+      project = project_or_raise(workspace_name, project_name)
+      case project_name
+      when :my_tasks, :my_tasks_new, :my_tasks_today, :my_tasks_upcoming
+        user_task_list_by_section(workspace_name, project_name)
+      else
+        tasks_by_section_for_project(project)
+      end
+    end
+    cache_method :tasks_by_section, SHORT_CACHE_TIME
+
+    # XXX: Rename to section_tasks
+    #
+    # Pulls task objects from a specified section
+    def tasks(workspace_name, project_name, section_name)
+      tasks_by_section(workspace_name, project_name).fetch(section_name, [])
+    end
+    cache_method :tasks, SHORT_CACHE_TIME
+
+    # Pulls just names of tasks from a given section.
+    def section_task_names(workspace_name, project_name, section_name)
+      tasks = tasks(workspace_name, project_name, section_name)
+      if tasks.nil?
+        by_section = tasks_by_section(workspace_name, project_name)
+        desc = "#{workspace_name} | #{project_name} | #{section_name}"
+        raise "Could not find task names for #{desc}.  " \
+              "Valid sections: #{by_section.keys}"
+      end
+      tasks.map(&:name)
+    end
+    cache_method :section_task_names, SHORT_CACHE_TIME
+
+    # returns if a task's due field is at or before the current date/time
+    def task_due?(task)
+      if task.due_at
+        Time.parse(task.due_at) <= time.now
+      elsif task.due_on
+        Date.parse(task.due_on) <= time.today
+      else
+        true # set a due date if you don't want to do this now
+      end
+    end
+
+    private
+
     def_delegators :@projects, :client
 
     def file_task_by_section(by_section, task, project_gid)
@@ -32,19 +100,10 @@ module Checkoff
       by_section[current_section] << task
     end
 
-    def by_section(tasks, project_gid)
-      by_section = {}
-      tasks.each do |task|
-        file_task_by_section(by_section, task, project_gid)
-      end
-      by_section
-    end
-    cache_method :by_section, LONG_CACHE_TIME
-
-    def tasks_by_section_for_project(project)
+    def legacy_tasks_by_section_for_project(project)
       raw_tasks = projects.tasks_from_project(project)
       active_tasks = projects.active_tasks(raw_tasks)
-      by_section(active_tasks, project.gid)
+      legacy_by_section(active_tasks)
     end
 
     def legacy_file_task_by_section(current_section, by_section, task)
@@ -68,12 +127,12 @@ module Checkoff
       by_section
     end
 
-    def tasks_by_section_for_project_and_assignee_status(project,
-                                                         assignee_status)
+    def legacy_tasks_by_section_for_project_and_assignee_status(project,
+                                                                assignee_status)
       raw_tasks = projects.tasks_from_project(project)
       by_assignee_status =
         projects.active_tasks(raw_tasks)
-                .group_by(&:assignee_status)
+          .group_by(&:assignee_status)
       active_tasks = by_assignee_status[assignee_status]
       legacy_by_section(active_tasks)
     end
@@ -87,49 +146,37 @@ module Checkoff
       project
     end
 
-    def tasks_by_section(workspace_name, project_name)
-      project = project_or_raise(workspace_name, project_name)
-      case project_name
-      when :my_tasks_new
-        tasks_by_section_for_project_and_assignee_status(project, 'inbox')
-      when :my_tasks_today
-        tasks_by_section_for_project_and_assignee_status(project, 'today')
-      when :my_tasks_upcoming
-        tasks_by_section_for_project_and_assignee_status(project, 'upcoming')
-      else
-        tasks_by_section_for_project(project)
-      end
-    end
-    cache_method :tasks_by_section, SHORT_CACHE_TIME
+    def verify_legacy_user_task_list!(workspace_name)
+      return unless user_task_list_migrated_to_real_sections?(workspace_name)
 
-    # XXX: Rename to section_tasks
-    def tasks(workspace_name, project_name, section_name)
-      tasks_by_section(workspace_name, project_name)[section_name]
+      raise NotImplementedError, 'Section-based user task lists not yet supported'
     end
-    cache_method :tasks, SHORT_CACHE_TIME
 
-    def section_task_names(workspace_name, project_name, section_name)
-      tasks = tasks(workspace_name, project_name, section_name)
-      if tasks.nil?
-        by_section = tasks_by_section(workspace_name, project_name)
-        desc = "#{workspace_name} | #{project_name} | #{section_name}"
-        raise "Could not find task names for #{desc}.  " \
-              "Valid sections: #{by_section.keys}"
-      end
-      tasks.map(&:name)
-    end
-    cache_method :section_task_names, SHORT_CACHE_TIME
+    ASSIGNEE_STATUS_BY_PROJECT_NAME = {
+      my_tasks_new: 'inbox',
+      my_tasks_today: 'today',
+      my_tasks_upcoming: 'upcoming',
+    }.freeze
 
-    def task_due?(task)
-      if task.due_at
-        Time.parse(task.due_at) <= time.now
-      elsif task.due_on
-        Date.parse(task.due_on) <= time.today
+    def user_task_list_by_section(workspace_name, project_name)
+      verify_legacy_user_task_list!(workspace_name)
+
+      project = projects.project(workspace_name, project_name)
+      if project_name == :my_tasks
+        legacy_tasks_by_section_for_project(project)
       else
-        true # set a due date if you don't want to do this now
+        legacy_tasks_by_section_for_project_and_assignee_status(project,
+                                                                ASSIGNEE_STATUS_BY_PROJECT_NAME.fetch(project_name))
       end
     end
 
+    def user_task_list_migrated_to_real_sections?(workspace_name)
+      workspace = workspaces.workspace_by_name(workspace_name)
+      result = client.user_task_lists.get_user_task_list_for_user(user_gid: 'me',
+                                                                  workspace: workspace.gid)
+      result.migration_status != 'not_migrated'
+    end
+
     def project_task_names(workspace_name, project_name)
       by_section = tasks_by_section(workspace_name, project_name)
       by_section.flat_map do |section_name, tasks|
@@ -143,4 +190,5 @@ module Checkoff
     end
     cache_method :project_task_names, SHORT_CACHE_TIME
   end
+  # rubocop:enable Metrics/ClassLength
 end