checkoff 0.9.0 → 0.12.0

data/lib/checkoff/config_loader.rb

@@ -13,10 +13,6 @@ module Checkoff
       @yaml_filename = yaml_filename
     end
 
-    def envvar_name(key)
-      "#{@envvar_prefix}__#{key.upcase}"
-    end
-
     def [](key)
       config_value = @config[key]
       return config_value unless config_value.nil?
@@ -31,25 +27,35 @@ module Checkoff
       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.yaml_filename(sym)
-      file = "#{sym}.yml"
-      File.expand_path("~/.#{file}")
-    end
+    class << self
+      def load(sym)
+        yaml_result = load_yaml_file(sym)
+        EnvFallbackConfigLoader.new(yaml_result, sym, yaml_filename(sym))
+      end
 
-    def self.load_yaml_file(sym)
-      filename = yaml_filename(sym)
-      return {} unless File.exist?(filename)
+      private
 
-      YAML.load_file(filename).with_indifferent_access
-    end
+      def load_yaml_file(sym)
+        filename = yaml_filename(sym)
+        return {} unless File.exist?(filename)
+
+        YAML.load_file(filename).with_indifferent_access
+      end
 
-    def self.load(sym)
-      yaml_result = load_yaml_file(sym)
-      EnvFallbackConfigLoader.new(yaml_result, sym, yaml_filename(sym))
+      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,23 @@ 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)
-      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)
+    # Default options used in Asana API to pull taskso
+    def task_options
+      {
+        per_page: 100,
+        options: {
+          fields: %w[name completed_at due_at due_on tags
+                     memberships.project.gid memberships.section.name dependencies],
+        },
+      }
     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,20 +59,12 @@ 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
 
-    def task_options
-      {
-        per_page: 100,
-        options: {
-          fields: %w[name completed_at due_at due_on assignee_status tags
-                     memberships.project.gid memberships.section.name dependencies],
-        },
-      }
-    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
@@ -90,5 +73,27 @@ module Checkoff
       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
   end
 end

data/lib/checkoff/sections.rb

@@ -4,7 +4,6 @@ require 'forwardable'
 
 module Checkoff
   # Query different sections of Asana projects
-  # rubocop:disable Metrics/ClassLength
   class Sections
     MINUTE = 60
     LONG_CACHE_TIME = MINUTE * 15
@@ -23,68 +22,74 @@ module Checkoff
       @time = time
     end
 
-    def_delegators :@projects, :client
-
-    def file_task_by_section(by_section, task, project_gid)
-      membership = task.memberships.find { |m| m['project']['gid'] == project_gid }
-      raise "Could not find task in project_gid #{project_gid}: #{task}" if membership.nil?
+    # Returns a list of Asana API section objects for a given project
+    def sections_or_raise(workspace_name, project_name)
+      project = project_or_raise(workspace_name, project_name)
+      client.sections.get_sections_for_project(project_gid: project.gid)
+    end
 
-      current_section = membership['section']['name']
-      current_section = nil if current_section == '(no section)'
-      by_section[current_section] ||= []
-      by_section[current_section] << task
+    # 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)
+      tasks_by_section_for_project(project)
     end
+    cache_method :tasks_by_section, SHORT_CACHE_TIME
 
-    def by_section(tasks, project_gid)
-      by_section = {}
-      tasks.each do |task|
-        file_task_by_section(by_section, task, project_gid)
-      end
-      by_section
+    # XXX: Rename to section_tasks
+    #
+    # Pulls task objects from a specified section
+    def tasks(workspace_name, project_name, section_name,
+              only_uncompleted: true,
+              extra_fields: [])
+      section = section_or_raise(workspace_name, project_name, section_name)
+      options = projects.task_options
+      # asana-0.10.3 gem doesn't support per_page - not sure if API
+      # itself does
+      options.delete(:per_page)
+      options[:options][:fields] += extra_fields
+      client.tasks.get_tasks_for_section(section_gid: section.gid,
+                                         **options).to_a
     end
-    cache_method :by_section, LONG_CACHE_TIME
+    cache_method :tasks, SHORT_CACHE_TIME
 
-    def legacy_tasks_by_section_for_project(project)
-      raw_tasks = projects.tasks_from_project(project)
-      active_tasks = projects.active_tasks(raw_tasks)
-      legacy_by_section(active_tasks)
+    # 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)
+      tasks.map(&:name)
     end
+    cache_method :section_task_names, SHORT_CACHE_TIME
+
+    private
 
+    # 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
 
-    def legacy_file_task_by_section(current_section, by_section, task)
-      if task.name =~ /:$/
-        current_section = task.name
-        by_section[current_section] = []
-      else
-        by_section[current_section] ||= []
-        by_section[current_section] << task
-      end
-      [current_section, by_section]
-    end
+    def_delegators :@projects, :client
 
-    def legacy_by_section(tasks)
-      current_section = nil
+    # 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|
-        current_section, by_section =
-          legacy_file_task_by_section(current_section, by_section, task)
+        file_task_by_section(by_section, task, project_gid)
       end
       by_section
     end
+    cache_method :by_section, LONG_CACHE_TIME
 
-    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)
-      active_tasks = by_assignee_status[assignee_status]
-      legacy_by_section(active_tasks)
+    def file_task_by_section(by_section, task, project_gid)
+      membership = task.memberships.find { |m| m['project']['gid'] == project_gid }
+      raise "Could not find task in project_gid #{project_gid}: #{task}" if membership.nil?
+
+      current_section = membership['section']['name']
+      current_section = nil if current_section == '(no section)'
+      by_section[current_section] ||= []
+      by_section[current_section] << task
     end
 
     def project_or_raise(workspace_name, project_name)
@@ -96,96 +101,20 @@ module Checkoff
       project
     end
 
-    def verify_legacy_user_task_list!(workspace_name)
-      return unless user_task_list_migrated_to_real_sections?(workspace_name)
-
-      raise NotImplementedError, 'Section-based user task lists not yet supported'
-    end
-
-    ASSIGNEE_STATUS_BY_PROJECT_NAME = {
-      my_tasks_new: 'inbox',
-      my_tasks_today: 'today',
-      my_tasks_upcoming: 'upcoming',
-    }.freeze
-
-    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
-        legacy_tasks_by_section_for_project_and_assignee_status(project,
-                                                                ASSIGNEE_STATUS_BY_PROJECT_NAME.fetch(project_name))
-      end
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def tasks_by_section(workspace_name, project_name)
-      project = project_or_raise(workspace_name, project_name)
-      case project_name
-      when :my_tasks
-        user_task_list_by_section(workspace_name, project_name)
-      when :my_tasks_new
-        user_task_list_by_section(workspace_name, project_name)
-      when :my_tasks_today
-        user_task_list_by_section(workspace_name, project_name)
-      when :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
-    # rubocop:enable Metrics/MethodLength
-
-    # XXX: Rename to section_tasks
-    def tasks(workspace_name, project_name, section_name)
-      tasks_by_section(workspace_name, project_name)[section_name]
-    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
-
-    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'
+    def section(workspace_name, project_name, section_name)
+      sections = sections_or_raise(workspace_name, project_name)
+      sections.find { |section| section.name.chomp(':') == section_name.chomp(':') }
     end
 
-    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
+    def section_or_raise(workspace_name, project_name, section_name)
+      section = section(workspace_name, project_name, section_name)
+      if section.nil?
+        valid_sections = sections_or_raise(workspace_name, project_name).map(&:name)
 
-    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|
-        task_names = tasks.map(&:name)
-        if section_name.nil?
-          task_names
-        else
-          [section_name, task_names]
-        end
+        raise "Could not find section #{section_name} under project #{project_name} " \
+              "under workspace #{workspace_name}.  Valid sections: #{valid_sections}"
       end
+      section
     end
-    cache_method :project_task_names, SHORT_CACHE_TIME
   end
-  # rubocop:enable Metrics/ClassLength
 end

data/lib/checkoff/subtasks.rb

@@ -11,17 +11,7 @@ module Checkoff
 
     extend Forwardable
 
-    def file_task_by_section(current_section, by_section, task)
-      if task.name =~ /:$/
-        current_section = task.name
-        by_section[current_section] = []
-      else
-        by_section[current_section] ||= []
-        by_section[current_section] << task
-      end
-      [current_section, by_section]
-    end
-
+    # pulls a Hash of subtasks broken out by section
     def by_section(tasks)
       current_section = nil
       by_section = {}
@@ -37,5 +27,18 @@ module Checkoff
       task.subtasks(projects.task_options)
     end
     cache_method :raw_subtasks, LONG_CACHE_TIME
+
+    private
+
+    def file_task_by_section(current_section, by_section, task)
+      if task.name =~ /:$/
+        current_section = task.name
+        by_section[current_section] = []
+      else
+        by_section[current_section] ||= []
+        by_section[current_section] << task
+      end
+      [current_section, by_section]
+    end
   end
 end

data/lib/checkoff/tasks.rb

@@ -5,7 +5,7 @@
 require_relative 'sections'
 
 module Checkoff
-  # Pull things from 'my tasks' in Asana
+  # Pull tasks from Asana
   class Tasks
     MINUTE = 60
     HOUR = MINUTE * 60
@@ -22,25 +22,20 @@ module Checkoff
       @asana_task = asana_task
     end
 
-    def client
-      @sections.client
-    end
-
-    def projects
-      @projects ||= @sections.projects
-    end
-
-    def task(workspace_name, project_name, task_name, only_uncompleted: true)
+    # Pull a specific task by name
+    def task(workspace_name, project_name, task_name,
+             section_name: :unspecified,
+             only_uncompleted: true)
       project = projects.project(workspace_name, project_name)
-      tasks = projects.tasks_from_project(project,
-                                          only_uncompleted: only_uncompleted)
+      tasks = if section_name == :unspecified
+                projects.tasks_from_project(project,
+                                            only_uncompleted: only_uncompleted)
+              else
+                @sections.tasks(workspace_name, project_name, section_name)
+              end
       tasks.find { |task| task.name == task_name }
     end
 
-    def tasks_minus_sections(tasks)
-      @sections.by_section(tasks).values.flatten
-    end
-
     def add_task(name,
                  workspace_gid: default_workspace_gid,
                  assignee_gid: default_assignee_gid)
@@ -49,6 +44,16 @@ module Checkoff
                          workspace: workspace_gid, name: name)
     end
 
+    private
+
+    def client
+      @sections.client
+    end
+
+    def projects
+      @projects ||= @sections.projects
+    end
+
     def default_assignee_gid
       @config.fetch(:default_assignee_gid)
     end