abt-cli 0.0.17 → 0.0.22

data/lib/abt/cli/global_commands/help.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    module GlobalCommands
+      class Help < Abt::BaseCommand
+        def self.usage
+          "abt help"
+        end
+
+        def self.description
+          "Print abt usage text"
+        end
+
+        attr_reader :cli
+
+        def perform
+          puts(Abt::Docs::Cli.help)
+        end
+      end
+    end
+  end
+end

data/lib/abt/cli/global_commands/readme.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    module GlobalCommands
+      class Readme < Abt::BaseCommand
+        def self.usage
+          "abt readme"
+        end
+
+        def self.description
+          "Print markdown readme"
+        end
+
+        attr_reader :cli
+
+        def perform
+          puts(Abt::Docs::Markdown.readme)
+        end
+      end
+    end
+  end
+end

data/lib/abt/cli/global_commands/share.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    module GlobalCommands
+      class Share < Abt::BaseCommand
+        def self.usage
+          "abt share"
+        end
+
+        def self.description
+          "Prints all project configuration as a single line of ARIs"
+        end
+
+        attr_reader :cli
+
+        def perform
+          warn("Printing project configuration")
+          puts share_string
+        end
+
+        def share_string
+          @share_string ||= begin
+            aris = Abt.schemes.join(" ")
+
+            input = StringIO.new(aris)
+            output = StringIO.new
+            Abt::Cli.new(argv: ["share"], output: output, input: input).perform
+
+            output.string.strip.gsub(/\s+/, " ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abt/cli/global_commands/version.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    module GlobalCommands
+      class Version < Abt::BaseCommand
+        def self.usage
+          "abt version"
+        end
+
+        def self.description
+          "Print abt version"
+        end
+
+        attr_reader :cli
+
+        def perform
+          puts(Abt::VERSION)
+        end
+      end
+    end
+  end
+end

data/lib/abt/cli/prompt.rb

@@ -10,7 +10,7 @@ module Abt
       end
 
       def text(question)
-        output.print "#{question}: "
+        output.print("#{question.strip}: ")
         read_user_input
       end
 
@@ -18,25 +18,24 @@ module Abt
         output.puts text
 
         loop do
-          output.print '(y / n): '
+          output.print("(y / n): ")
 
           case read_user_input
-          when 'y', 'Y' then return true
-          when 'n', 'N' then return false
+          when "y", "Y" then return true
+          when "n", "N" then return false
           else
-            output.puts 'Invalid choice'
-            next
+            output.puts "Invalid choice"
           end
         end
       end
 
-      def choice(text, options, nil_option = false)
-        output.puts "#{text}:"
+      def choice(text, options, nil_option: false)
+        output.puts "#{text.strip}:"
 
         if options.length.zero?
-          raise Abort, 'No available options' unless nil_option
+          raise Abort, "No available options" unless nil_option
 
-          output.puts 'No available options'
+          output.puts "No available options"
           return nil
         end
 
@@ -44,6 +43,15 @@ module Abt
         select_options(options, nil_option)
       end
 
+      def search(text, options)
+        output.puts text
+
+        loop do
+          choice = get_search_result(options)
+          break choice unless choice.nil?
+        end
+      end
+
       private
 
       def print_options(options)
@@ -69,10 +77,11 @@ module Abt
       end
 
       def read_option_number(options_length, nil_option)
-        output.print '('
-        output.print options_length > 1 ? "1-#{options_length}" : '1'
-        output.print nil_option_string(nil_option)
-        output.print '): '
+        str = "("
+        str += options_length > 1 ? "1-#{options_length}" : "1"
+        str += nil_option_string(nil_option)
+        str += "): "
+        output.print(str)
 
         input = read_user_input
 
@@ -80,7 +89,7 @@ module Abt
 
         option_number = input.to_i
         if option_number <= 0 || option_number > options_length
-          output.puts 'Invalid selection'
+          output.puts "Invalid selection"
           return nil
         end
 
@@ -88,19 +97,19 @@ module Abt
       end
 
       def nil_option_string(nil_option)
-        return '' unless nil_option
+        return "" unless nil_option
 
         ", #{nil_option_character(nil_option)}: #{nil_option_description(nil_option)}"
       end
 
       def nil_option_character(nil_option)
-        return 'q' if nil_option == true
+        return "q" if nil_option == true
 
         nil_option[0]
       end
 
       def nil_option_description(nil_option)
-        return 'back' if nil_option == true
+        return "back" if nil_option == true
         return nil_option if nil_option.is_a?(String)
 
         nil_option[1]
@@ -110,11 +119,34 @@ module Abt
         open(tty_path, &:gets).strip # rubocop:disable Security/Open
       end
 
+      def get_search_result(options)
+        matches = matches_for_string(text("Enter search"), options)
+        if matches.empty?
+          output.puts("No matches")
+          return
+        end
+
+        output.puts("Showing the 10 first matches") if matches.size > 10
+        choice("Select a match", matches[0...10], nil_option: true)
+      end
+
+      def matches_for_string(string, options)
+        search_string = sanitize_string(string)
+
+        options.select do |option|
+          sanitize_string(option["name"]).include?(search_string)
+        end
+      end
+
+      def sanitize_string(string)
+        string.downcase.gsub(/[^\w]/, "")
+      end
+
       def tty_path
         @tty_path ||= begin
-          candidates = ['/dev/tty', 'CON:'] # Unix: '/dev/tty', Windows: 'CON:'
+          candidates = ["/dev/tty", "CON:"] # Unix: '/dev/tty', Windows: 'CON:'
           selected = candidates.find { |candidate| File.exist?(candidate) }
-          raise Abort, 'Unable to prompt for user input' if selected.nil?
+          raise Abort, "Unable to prompt for user input" if selected.nil?
 
           selected
         end

data/lib/abt/docs.rb

@@ -9,48 +9,71 @@ module Abt
     class << self
       def basic_examples
         {
-          'Getting started:' => {
-            'abt init asana harvest' => 'Setup asana and harvest project git repo in working dir',
-            'abt pick harvest' => 'Pick harvest tasks, for most projects this will stay the same',
-            'abt pick asana | abt start harvest' => 'Pick asana task and start working',
-            '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'
+          "Getting started:" => {
+            "abt init asana harvest" => "Setup asana and harvest project for local git repo",
+            "abt pick harvest" => "Pick harvest task. This will likely stay the same throughout the project",
+            "abt pick asana | abt start harvest" => "Pick asana task and start tracking time",
+            "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
+      def extended_examples # rubocop:disable Metrics/MethodLength
         {
-          'Tracking meetings (without changing the config):' => {
-            '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'
+          "Tracking meetings (without switching current task setting):" => {
+            "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,
-            'abt tasks asana | grep -i <name of task> | abt start' => nil
+          "Many commands output ARIs that can be piped into other commands:" => {
+            "abt tasks asana | grep -i <name of task>" => nil,
+            "abt tasks asana | grep -i <name of task> | abt start" => nil
           },
-          'Sharing configuration:' => {
-            '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'
+          "Sharing ARIs:" => {
+            'abt share asana harvest | tr "\n" " "' => "Print current asana and harvest ARIs on a single line",
+            'abt share asana harvest | tr "\n" " " | pbcopy' => "Copy ARIs to clipboard (mac only)",
+            "abt start <ARIs from coworker>" => "Work on a task your coworker shared with you",
+            "abt current <ARIs from coworker> | abt start" => "Set task as current, then start it"
           },
-          '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>'
+          "Flags:" => {
+            'abt start harvest -c "comment"' => "Add command flags after ARIs",
+            'abt start harvest -c "comment" -- asana' =>
+              "Use -- to end a list of flags, so that it can be followed by another ARI",
+            'abt pick harvest | abt start -c "comment"' =>
+              "Flags placed directly after a command applies to the piped in ARI"
           }
         }
       end
 
       def providers
-        @providers ||= Abt.schemes.sort.each_with_object({}) do |scheme, definition|
-          definition[scheme] = command_definitions(scheme)
+        @providers ||= begin
+          providers = {}
+
+          providers["Global"] = global_command_definitions
+
+          Abt.schemes.sort.each_with_object(providers) do |scheme, definition|
+            definition[scheme] = command_definitions(scheme)
+          end
+
+          providers
         end
       end
 
       private
 
+      def global_command_definitions
+        global_command_names = Abt::Cli::GlobalCommands.command_names
+        global_command_names.each_with_object({}) do |name, definition|
+          command_class = Abt::Cli::GlobalCommands.command_class(name)
+          full_name = "abt #{name}"
+
+          if command_class.respond_to?(:usage) && command_class.respond_to?(:description)
+            definition[full_name] = [command_class.usage.strip, command_class.description.strip]
+          end
+        end
+      end
+
       def command_definitions(scheme)
         provider = Abt.scheme_provider(scheme)
         provider.command_names.each_with_object({}) do |name, definition|
@@ -58,7 +81,7 @@ module Abt
           full_name = "abt #{name} #{scheme}"
 
           if command_class.respond_to?(:usage) && command_class.respond_to?(:description)
-            definition[full_name] = [command_class.usage, command_class.description]
+            definition[full_name] = [command_class.usage.strip, command_class.description.strip]
           end
         end
       end

data/lib/abt/docs/cli.rb

@@ -8,10 +8,10 @@ module Abt
           <<~TXT
             Usage: #{usage_line}
 
-            <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
+            <command>   Name of command to execute, e.g. start, finalize etc.
+            <ARI>       A URI-like resource identifier with a scheme and an optional path
+                        in the format: <scheme>[:<path>]. E.g., harvest:11111111/22222222
+            <options>   Optional flags for the command and ARI
 
             #{formatted_examples(Docs.basic_examples)}
 
@@ -45,14 +45,14 @@ module Abt
         private
 
         def usage_line
-          'abt <command> [<scheme-argument>] [<options> --] [<scheme-argument>] ...'
+          "abt <command> [<ARI>] [<options> --] [<ARI>] ..."
         end
 
         def formatted_examples(example_groups)
           lines = []
 
           example_groups.each_with_index do |(title, examples), index|
-            lines << '' unless index.zero?
+            lines << "" unless index.zero?
             lines << title
 
             max_length = examples.keys.map(&:length).max
@@ -68,7 +68,7 @@ module Abt
           lines = []
 
           Docs.providers.each_with_index do |(scheme, commands_definition), index|
-            lines << '' unless index.zero?
+            lines << "" unless index.zero?
             lines << "#{inflector.humanize(scheme)}:"
 
             max_length = commands_definition.keys.map(&:length).max

data/lib/abt/docs/markdown.rb

@@ -15,27 +15,28 @@ module Abt
 
             ## How does abt work?
 
-            Abt uses a hybrid approach between having small scripts each doing one thing:
+            Abt is a hybrid of 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:
+            And having a single highly advanced script that does everything with a single command:
             - `start xxxx/yyyy aaaa/bbbb`
 
-            Abt looks like one script, but works like a bunch of light independent scripts:
+            Abt looks like one command, but works like a bunch of light scripts:
             - `abt start asana:xxxx/yyyy harvest:aaaa/bbbb`
 
             ## Usage
-            `abt <command> [<scheme-argument>] [<options> --] [<scheme-argument>] ...`
+            `abt <command> [<ARI>] [<options> --] [<ARI>] ...`
 
             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
+            - `<ARI>`: A URI-like resource identifier with a scheme and an optional path in the format: `<scheme>[:<path>]`. E.g., `harvest:11111111/22222222`
+            - `<options>`: Optional flags for the command and ARI
 
             #{example_commands}
 
-            ## Available commands:
+            ## Commands:
+
             Some commands have `[options]`. Run such a command with `--help` flag to view supported flags, e.g: `abt track harvest -h`
 
             #{provider_commands}
@@ -51,11 +52,11 @@ module Abt
 
           examples = Docs.basic_examples.merge(Docs.extended_examples)
           examples.each_with_index do |(title, commands), index|
-            lines << '' unless index.zero?
+            lines << "" unless index.zero?
             lines << title
 
             commands.each do |(command, description)|
-              formatted_description = description.nil? ? '' : ": #{description}"
+              formatted_description = description.nil? ? "" : ": #{description}"
               lines << "- `#{command}`#{formatted_description}"
             end
           end
@@ -67,10 +68,10 @@ module Abt
           lines = []
 
           Docs.providers.each_with_index do |(scheme, commands), index|
-            lines << '' unless index.zero?
+            lines << "" unless index.zero?
             lines << "### #{inflector.humanize(scheme)}"
-            lines << '| Command | Description |'
-            lines << '| :------ | :---------- |'
+            lines << "| Command | Description |"
+            lines << "| :------ | :---------- |"
 
             max_length = commands.values.map(&:first).map(&:length).max