abt-cli 0.0.20 → 0.0.25

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,38 +10,47 @@ module Abt
       end
 
       def text(question)
-        output.print "#{question}: "
-        read_user_input
+        output.print("#{question.strip}: ")
+        Abt::Helpers.read_user_input
       end
 
-      def boolean(text)
-        output.puts text
+      def boolean(text, default: nil)
+        choices = [default == true ? "Y" : "y",
+                   default == false ? "N" : "n"].join("/")
 
-        loop do
-          output.print '(y / n): '
-
-          case read_user_input
-          when 'y', 'Y' then return true
-          when 'n', 'N' then return false
-          else
-            output.puts 'Invalid choice'
-            next
-          end
-        end
+        output.print("#{text} (#{choices}): ")
+
+        input = Abt::Helpers.read_user_input.downcase
+
+        return true if input == "y"
+        return false if input == "n"
+        return default if input.empty? && !default.nil?
+
+        output.puts "Invalid choice"
+        boolean(text, default: default)
       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
 
         print_options(options)
-        select_options(options, nil_option)
+        select_option(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
@@ -52,74 +61,80 @@ module Abt
         end
       end
 
-      def select_options(options, nil_option)
-        loop do
-          number = read_option_number(options.length, nil_option)
-          if number.nil?
-            return nil if nil_option
-
-            next
-          end
+      def select_option(options, nil_option)
+        number = prompt_valid_option_number(options, nil_option)
 
-          option = options[number - 1]
+        return nil if number.nil?
 
-          output.puts "Selected: (#{number}) #{option['name']}"
-          return option
-        end
+        option = options[number - 1]
+        output.puts "Selected: (#{number}) #{option['name']}"
+        option
       end
 
-      def read_option_number(options_length, nil_option)
-        str = '('
-        str += options_length > 1 ? "1-#{options_length}" : '1'
-        str += nil_option_string(nil_option)
-        str += '): '
-        output.print str
-
-        input = read_user_input
+      def prompt_valid_option_number(options, nil_option)
+        output.print(options_info(options, nil_option))
+        input = Abt::Helpers.read_user_input
 
         return nil if nil_option && input == nil_option_character(nil_option)
 
         option_number = input.to_i
-        if option_number <= 0 || option_number > options_length
-          output.puts 'Invalid selection'
-          return nil
-        end
+        return option_number if (1..options.length).cover?(option_number)
+
+        output.puts "Invalid selection"
 
-        option_number
+        # Prompt again if the selection was invalid
+        prompt_valid_option_number(options, nil_option)
+      end
+
+      def options_info(options, nil_option)
+        str = "("
+        str += options.length > 1 ? "1-#{options.length}" : "1"
+        str += nil_option_string(nil_option)
+        str += "): "
+        str
       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]
       end
 
-      def read_user_input
-        open(tty_path, &:gets).strip # rubocop:disable Security/Open
+      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 tty_path
-        @tty_path ||= begin
-          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?
+      def matches_for_string(string, options)
+        search_string = sanitize_string(string)
 
-          selected
+        options.select do |option|
+          sanitize_string(option["name"]).include?(search_string)
         end
       end
+
+      def sanitize_string(string)
+        string.downcase.gsub(/[^\w]/, "")
+      end
     end
   end
 end

data/lib/abt/docs.rb

@@ -9,49 +9,71 @@ module Abt
     class << self
       def basic_examples
         {
-          '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'
+          "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 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'
+          "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"
           },
-          '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
+          "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 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'
+          "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 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'
+          "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|
@@ -59,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

@@ -45,14 +45,14 @@ module Abt
         private
 
         def usage_line
-          'abt <command> [<ARI>] [<options> --] [<ARI>] ...'
+          "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

@@ -50,13 +50,12 @@ module Abt
         def example_commands
           lines = []
 
-          examples = Docs.basic_examples.merge(Docs.extended_examples)
-          examples.each_with_index do |(title, commands), index|
-            lines << '' unless index.zero?
+          complete_examples.each_with_index do |(title, commands), index|
+            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
@@ -68,10 +67,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
 
@@ -84,6 +83,10 @@ module Abt
           lines.join("\n")
         end
 
+        def complete_examples
+          Docs.basic_examples.merge(Docs.extended_examples)
+        end
+
         def inflector
           Dry::Inflector.new
         end

data/lib/abt/git_config.rb

@@ -6,12 +6,10 @@ module Abt
 
     class UnsafeNamespaceError < StandardError; end
 
-    def initialize(scope = 'local', namespace = '')
+    def initialize(scope = "local", namespace = "")
       @namespace = namespace
 
-      unless %w[local global].include? scope
-        raise ArgumentError, 'scope must be "local" or "global"'
-      end
+      raise ArgumentError, 'scope must be "local" or "global"' unless %w[local global].include?(scope)
 
       @scope = scope
     end
@@ -50,7 +48,7 @@ module Abt
     end
 
     def clear(output: nil)
-      raise UnsafeNamespaceError, 'Keys can only be cleared within a namespace' if namespace.empty?
+      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)}"
@@ -67,7 +65,7 @@ module Abt
     def ensure_scope_available!
       return if available?
 
-      raise StandardError, 'Local configuration is not available outside a git repository'
+      raise StandardError, "Local configuration is not available outside a git repository"
     end
 
     def key_with_namespace(key)

data/lib/abt/helpers.rb

@@ -2,15 +2,33 @@
 
 module Abt
   module Helpers
-    def self.const_to_command(string)
-      string = string.to_s.dup
-      string[0] = string[0].downcase
-      string.gsub(/([A-Z])/, '-\1').downcase
-    end
+    class << self
+      def const_to_command(string)
+        string = string.to_s.dup
+        string[0] = string[0].downcase
+        string.gsub(/([A-Z])/, '-\1').downcase
+      end
+
+      def command_to_const(string)
+        inflector = Dry::Inflector.new
+        inflector.camelize(inflector.underscore(string))
+      end
+
+      def read_user_input
+        open(tty_path, &:gets).strip # rubocop:disable Security/Open
+      end
+
+      private
+
+      def tty_path
+        @tty_path ||= begin
+          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?
 
-    def self.command_to_const(string)
-      inflector = Dry::Inflector.new
-      inflector.camelize(inflector.underscore(string))
+          selected
+        end
+      end
     end
   end
 end