abt-cli 0.0.11 → 0.0.16

data/lib/abt/docs.rb

@@ -7,7 +7,7 @@ end
 module Abt
   module Docs
     class << self
-      def examples # rubocop:disable Metrics/MethodLength
+      def basic_examples
         {
           'Getting started:' => {
             'abt init asana harvest' => 'Setup asana and harvest project git repo in working dir',
@@ -16,10 +16,15 @@ module Abt
             'abt stop harvest' => 'Stop time tracker',
             'abt start asana harvest' => 'Continue working, e.g. after a break',
             'abt finalize asana' => 'Finalize the selected asana task'
-          },
+          }
+        }
+      end
+
+      def extended_examples
+        {
           'Tracking meetings (without changing the config):' => {
-            'abt tasks asana | grep -i standup | abt track harvest' => 'Track on asana meeting task without changing any configuration',
-            'abt tasks harvest | grep -i comment | abt track harvest' => 'Track on harvest "Comment"-task (will prompt for a comment)'
+            'abt pick asana -d | abt track harvest' => 'Track on asana meeting task',
+            'abt pick harvest -d | abt track harvest -c "Name of meeting"' => 'Track on separate harvest-task'
           },
           'Command output can be piped, e.g.:' => {
             'abt tasks asana | grep -i <name of task>' => nil,
@@ -29,30 +34,31 @@ module Abt
             'abt share asana harvest | tr "\n" " "' => 'Print current configuration',
             'abt share asana harvest | tr "\n" " " | pbcopy' => 'Copy configuration (mac only)',
             'abt start <shared configuration>' => 'Start a shared configuration'
+          },
+          'Flags:' => {
+            'abt start harvest -c "comment"' => 'Add command flags after <scheme>:<path>',
+            'abt start harvest -c "comment" -- asana' => 'Use -- to mark the end of a flag list if it\'s to be followed by a <scheme-argument>',
+            'abt pick harvest | abt start -c "comment"' => 'Flags placed directly after a command applies to piped in <scheme-argument>'
           }
         }
       end
 
       def providers
-        provider_definitions
+        @providers ||= Abt.schemes.sort.each_with_object({}) do |scheme, definition|
+          definition[scheme] = command_definitions(scheme)
+        end
       end
 
       private
 
-      def provider_definitions
-        Abt.provider_names.sort.each_with_object({}) do |name, definition|
-          provider_module = Abt.provider_module(name)
-
-          definition[name] = command_definitions(provider_module)
-        end
-      end
-
-      def command_definitions(provider_module)
-        provider_module.command_names.each_with_object({}) do |name, definition|
-          command_class = provider_module.command_class(name)
+      def command_definitions(scheme)
+        provider = Abt.scheme_provider(scheme)
+        provider.command_names.each_with_object({}) do |name, definition|
+          command_class = provider.command_class(name)
+          full_name = "abt #{name} #{scheme}"
 
-          if command_class.respond_to?(:command) && command_class.respond_to?(:description)
-            definition[command_class.command] = command_class.description
+          if command_class.respond_to?(:usage) && command_class.respond_to?(:description)
+            definition[full_name] = [command_class.usage, command_class.description]
           end
         end
       end

data/lib/abt/docs/cli.rb

@@ -4,23 +4,54 @@ module Abt
   module Docs
     module Cli
       class << self
-        def content
+        def help
           <<~TXT
-            Usage: abt <command> [<provider[:<arguments>]>...]
+            Usage: #{usage_line}
 
-            #{example_commands}
+            <command>           Name of command to execute, e.g. start, finalize etc.
+            <scheme-argument>   A URI-like identifier; scheme:path
+                                Points to a project/task etc. within a system.
+            <options>           Optional flags for the command and scheme argument
 
-            Available commands:
-            #{providers_commands}
+            #{formatted_examples(Docs.basic_examples)}
+
+            For detailed examples/commands try:
+               abt examples
+               abt commands
+          TXT
+        end
+
+        def examples
+          <<~TXT
+            Printing examples
+
+            #{formatted_examples(Docs.basic_examples)}
+
+            #{formatted_examples(Docs.extended_examples)}
+          TXT
+        end
+
+        def commands
+          <<~TXT
+            Printing commands
+
+            Run commands with --help flag to see detailed usage and flags, e.g.:
+               abt track harvest -h
+
+            #{commands_per_provider}
           TXT
         end
 
         private
 
-        def example_commands
+        def usage_line
+          'abt <command> [<scheme-argument>] [<options> --] [<scheme-argument>] ...'
+        end
+
+        def formatted_examples(example_groups)
           lines = []
 
-          Docs.examples.each_with_index do |(title, examples), index|
+          example_groups.each_with_index do |(title, examples), index|
             lines << '' unless index.zero?
             lines << title
 
@@ -33,16 +64,16 @@ module Abt
           lines.join("\n")
         end
 
-        def providers_commands
+        def commands_per_provider
           lines = []
 
-          Docs.providers.each_with_index do |(provider_name, commands_definition), index|
+          Docs.providers.each_with_index do |(scheme, commands_definition), index|
             lines << '' unless index.zero?
-            lines << "#{inflector.humanize(provider_name)}:"
+            lines << "#{inflector.humanize(scheme)}:"
 
             max_length = commands_definition.keys.map(&:length).max
 
-            commands_definition.each do |(command, description)|
+            commands_definition.each do |(command, (_usage, description))|
               lines << "   #{command.ljust(max_length)}   #{description}"
             end
           end

data/lib/abt/docs/markdown.rb

@@ -4,18 +4,43 @@ module Abt
   module Docs
     module Markdown
       class << self
-        def content
+        def readme
           <<~MD
             # Abt
-            This readme was generated with `abt help-md > README.md`
+
+            Abt makes re-occuring tasks easily accessible from the terminal:
+            - Moving asana tasks around
+            - Tracking work/meetings in harvest
+            - Consistently naming branches
+
+            ## How does abt work?
+
+            Abt uses a hybrid approach between having small scripts each doing one thing:
+            - `start-asana --project-gid xxxx --task-gid yyyy`
+            - `start-harvest --project-id aaaa --task-id bbbb`
+
+            And having a single highly advanced script that does everything:
+            - `start xxxx/yyyy aaaa/bbbb`
+
+            Abt looks like one script, but works like a bunch of light independent scripts:
+            - `abt start asana:xxxx/yyyy harvest:aaaa/bbbb`
 
             ## Usage
-            `abt <command> [<provider[:<arguments>]>...]`
+            `abt <command> [<scheme-argument>] [<options> --] [<scheme-argument>] ...`
+
+            Definitions:
+            - `<command>`: Name of command to execute, e.g. `start`, `finalize` etc.
+            - `<scheme-argument>`: A URI-like identifier, `scheme:path`, pointing to a project/task etc. within a system.
+            - `<options>`: Optional flags for the command and scheme argument
 
             #{example_commands}
 
             ## Available commands:
+            Some commands have `[options]`. Run such a command with `--help` flag to view supported flags, e.g: `abt track harvest -h`
+
             #{provider_commands}
+
+            #### This readme was generated with `abt readme > README.md`
           MD
         end
 
@@ -24,7 +49,8 @@ module Abt
         def example_commands
           lines = []
 
-          Docs.examples.each_with_index do |(title, commands), index|
+          examples = Docs.basic_examples.merge(Docs.extended_examples)
+          examples.each_with_index do |(title, commands), index|
             lines << '' unless index.zero?
             lines << title
 
@@ -40,17 +66,17 @@ module Abt
         def provider_commands # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           lines = []
 
-          Docs.providers.each_with_index do |(provider_name, commands), index|
+          Docs.providers.each_with_index do |(scheme, commands), index|
             lines << '' unless index.zero?
-            lines << "### #{inflector.humanize(provider_name)}"
+            lines << "### #{inflector.humanize(scheme)}"
             lines << '| Command | Description |'
             lines << '| :------ | :---------- |'
 
-            max_length = commands.keys.map(&:length).max
+            max_length = commands.values.map(&:first).map(&:length).max
 
-            commands.each do |(command, description)|
-              adjusted_command = "`#{command}`".ljust(max_length + 2)
-              lines << "| #{adjusted_command} | #{description} |"
+            commands.each do |(_command, (usage, description))|
+              adjusted_usage = "`#{usage}`".ljust(max_length + 2)
+              lines << "| #{adjusted_usage} | #{description} |"
             end
           end
 

data/lib/abt/git_config.rb

@@ -4,13 +4,19 @@ module Abt
   class GitConfig
     attr_reader :namespace, :scope
 
+    class UnsafeNamespaceError < StandardError; end
+
+    LOCAL_CONFIG_AVAILABLE_CHECK_COMMAND = 'git config --local -l'
+
     def self.local_available?
-      @local_available ||= begin
-        status = nil
-        Open3.popen3('git config --local -l') do |_i, _o, _e, thread|
-          status = thread.value
+      return @local_available if instance_variables.include?(:@local_available)
+
+      @local_available = begin
+        success = false
+        Open3.popen3(LOCAL_CONFIG_AVAILABLE_CHECK_COMMAND) do |_i, _o, _e, thread|
+          success = thread.value.success?
         end
-        status.success?
+        success
       end
     end
 
@@ -32,19 +38,17 @@ module Abt
       set(key, value)
     end
 
-    def full_keys
-      if scope == 'local' && !self.class.local_available?
-        raise StandardError, 'Local configuration is not available outside a git repository'
-      end
-
-      `git config --#{scope} --get-regexp --name-only ^#{namespace}`.lines.map(&:strip)
-    end
-
     def keys
       offset = namespace.length + 1
       full_keys.map { |key| key[offset..-1] }
     end
 
+    def full_keys
+      ensure_scope_available!
+
+      `git config --#{scope} --get-regexp --name-only ^#{namespace}`.lines.map(&:strip)
+    end
+
     def local
       @local ||= begin
         if scope == 'local'
@@ -65,25 +69,36 @@ module Abt
       end
     end
 
+    def clear(output: nil)
+      raise UnsafeNamespaceError, 'Keys can only be cleared within a namespace' if namespace.empty?
+
+      keys.each do |key|
+        output&.puts "Clearing #{scope}: #{key_with_namespace(key)}"
+        self[key] = nil
+      end
+    end
+
     private
 
+    def ensure_scope_available!
+      return if scope != 'local' || self.class.local_available?
+
+      raise StandardError, 'Local configuration is not available outside a git repository'
+    end
+
     def key_with_namespace(key)
       namespace.empty? ? key : "#{namespace}.#{key}"
     end
 
     def get(key)
-      if scope == 'local' && !self.class.local_available?
-        raise StandardError, 'Local configuration is not available outside a git repository'
-      end
+      ensure_scope_available!
 
       git_value = `git config --#{scope} --get #{key_with_namespace(key).inspect}`.strip
       git_value.empty? ? nil : git_value
     end
 
     def set(key, value)
-      if scope == 'local' && !self.class.local_available?
-        raise StandardError, 'Local configuration is not available outside a git repository'
-      end
+      ensure_scope_available!
 
       if value.nil? || value.empty?
         `git config --#{scope} --unset #{key_with_namespace(key).inspect}`

data/lib/abt/helpers.rb

@@ -3,7 +3,7 @@
 module Abt
   module Helpers
     def self.const_to_command(string)
-      string = string.to_s
+      string = string.to_s.dup
       string[0] = string[0].downcase
       string.gsub(/([A-Z])/, '-\1').downcase
     end

data/lib/abt/providers/asana/base_command.rb

@@ -3,45 +3,56 @@
 module Abt
   module Providers
     module Asana
-      class BaseCommand
-        attr_reader :arg_str, :project_gid, :task_gid, :cli, :config
+      class BaseCommand < Abt::Cli::BaseCommand
+        attr_reader :project_gid, :task_gid, :config
+
+        def initialize(path:, cli:, **)
+          super
 
-        def initialize(arg_str:, cli:)
-          @arg_str = arg_str
           @config = Configuration.new(cli: cli)
 
-          if arg_str.nil?
-            use_current_args
+          if path.nil?
+            use_current_path
           else
-            use_arg_str(arg_str)
+            use_path(path)
           end
-          @cli = cli
         end
 
         private
 
+        def require_project!
+          cli.abort 'No current/specified project. Did you initialize Asana?' if project_gid.nil?
+        end
+
+        def require_task!
+          if project_gid.nil?
+            cli.abort 'No current/specified project. Did you initialize Asana and pick a task?'
+          end
+          cli.abort 'No current/specified task. Did you pick an Asana task?' if task_gid.nil?
+        end
+
         def same_args_as_config?
           project_gid == config.project_gid && task_gid == config.task_gid
         end
 
         def print_project(project)
-          cli.print_provider_command('asana', project['gid'], project['name'])
+          cli.print_scheme_argument('asana', project['gid'], project['name'])
           cli.warn project['permalink_url'] if project.key?('permalink_url') && cli.output.isatty
         end
 
         def print_task(project, task)
           project = { 'gid' => project } if project.is_a?(String)
-          cli.print_provider_command('asana', "#{project['gid']}/#{task['gid']}", task['name'])
+          cli.print_scheme_argument('asana', "#{project['gid']}/#{task['gid']}", task['name'])
           cli.warn task['permalink_url'] if task.key?('permalink_url') && cli.output.isatty
         end
 
-        def use_current_args
+        def use_current_path
           @project_gid = config.project_gid
           @task_gid = config.task_gid
         end
 
-        def use_arg_str(arg_str)
-          args = arg_str.to_s.split('/')
+        def use_path(path)
+          args = path.to_s.split('/')
           @project_gid = args[0].to_s
           @project_gid = nil if project_gid.empty?
 

data/lib/abt/providers/asana/commands/add.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Abt
+  module Providers
+    module Asana
+      module Commands
+        class Add < BaseCommand
+          def self.usage
+            'abt add asana[:<project-gid>]'
+          end
+
+          def self.description
+            'Create a new task for the current/specified Asana project'
+          end
+
+          def perform
+            require_project!
+
+            task
+            print_task(project, task)
+
+            move_task if section
+          end
+
+          private
+
+          def task
+            @task ||= begin
+              body = {
+                data: {
+                  name: name,
+                  notes: notes,
+                  projects: [project_gid]
+                }
+              }
+              cli.warn 'Creating task'
+              api.post('tasks', Oj.dump(body, mode: :json))
+            end
+          end
+
+          def move_task
+            body = { data: { task: task['gid'] } }
+            body_json = Oj.dump(body, mode: :json)
+            api.post("sections/#{section['gid']}/addTask", body_json)
+          end
+
+          def name
+            @name ||= cli.prompt.text 'Enter task description'
+          end
+
+          def notes
+            @notes ||= cli.prompt.text 'Enter task notes'
+          end
+
+          def project
+            @project ||= api.get("projects/#{project_gid}")
+          end
+
+          def section
+            @section ||= cli.prompt.choice 'Add to section?', sections, ['q', 'Don\'t add to section']
+          end
+
+          def sections
+            @sections ||= begin
+              cli.warn 'Fetching sections...'
+              api.get_paged("projects/#{project_gid}/sections", opt_fields: 'name')
+                          rescue Abt::HttpError::HttpError
+                            []
+            end
+          end
+        end
+      end
+    end
+  end
+end