abt-cli 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f176b71200cc6fcc13ab56507e4d48234785e2307ab350afca7be13193ef2a5e
-  data.tar.gz: '093172885ed64949153cd73457748f446e012887f78d092f2483164f005fbfd0'
+  metadata.gz: '09c4dedacc59650be8d22ae65041e78913fc4405bbb61109ef93217801bafcff'
+  data.tar.gz: 91f205c4db85e2686b8461c6c2b029a45e6e430c418041aa3ffae725d1ecd16b
 SHA512:
-  metadata.gz: 6350132f05617d7e7222f0b7e07255091119ad0edac59277795c891668a6de4fb3ea9e376cdc93ab2672e130b5222d6ff310d80da8979dfaf060ff0e2479e447
-  data.tar.gz: 14eea7d7cb849f39d1aef4643df214541178d4f8702cecc962ffcff099b0c9143be68b8562aac0fdbc75b2bb2424872bd34661136104ac233df2097031d49394
+  metadata.gz: 42f9d332099fdcecdbdf538bd44119b75d643db6399d06fe578d15e5dff664af9dfec59a5ffa1f1235a1b922fa5727d52c20ed0b6a8c4fa795e1750b51f0943d
+  data.tar.gz: a88ffec46e7331823de6dc89fde11e442ac3c7bd577495a89dd2af20b879675de7fdafada270d1614556d193bb909892fd9622b8b3cd87f2836fab0aa94b1483

data/bin/abt

@@ -5,7 +5,7 @@ require_relative '../lib/abt.rb'
 
 begin
   Abt::Cli.new.perform
-rescue Abt::Cli::AbortError => e
+rescue Abt::Cli::Abort => e
   abort e.message
 rescue Interrupt
   abort 'Aborted'

data/lib/abt.rb

@@ -5,6 +5,7 @@ require 'faraday'
 require 'oj'
 require 'open3'
 require 'stringio'
+require 'optparse'
 
 Dir.glob("#{File.dirname(File.absolute_path(__FILE__))}/abt/*.rb").sort.each do |file|
   require file
@@ -13,12 +14,12 @@ end
 module Abt
   module Providers; end
 
-  def self.provider_names
+  def self.schemes
     Providers.constants.sort.map { |constant_name| Helpers.const_to_command(constant_name) }
   end
 
-  def self.provider_module(name)
-    const_name = Helpers.command_to_const(name)
+  def self.scheme_provider(scheme)
+    const_name = Helpers.command_to_const(scheme)
     Providers.const_get(const_name) if Providers.const_defined?(const_name)
   end
 end

data/lib/abt/cli.rb

@@ -6,31 +6,31 @@ end
 
 module Abt
   class Cli
-    class AbortError < StandardError; end
+    class Abort < StandardError; end
+    class Exit < StandardError; end
 
-    attr_reader :command, :args, :input, :output, :err_output, :prompt
+    attr_reader :command, :scheme_arguments, :input, :output, :err_output, :prompt
 
     def initialize(argv: ARGV, input: STDIN, output: STDOUT, err_output: STDERR)
-      (@command, *@args) = argv
-
+      (@command, *remaining_args) = argv
       @input = input
       @output = output
       @err_output = err_output
       @prompt = Abt::Cli::Prompt.new(output: err_output)
 
-      @args += args_from_input unless input.isatty # Add piped arguments
+      @scheme_arguments = ArgumentsParser.new(sanitized_piped_args + remaining_args).parse
     end
 
     def perform
       return if handle_global_commands!
 
-      abort('No provider arguments') if args.empty?
+      abort('No scheme arguments') if scheme_arguments.empty?
 
-      process_providers
+      process_scheme_arguments
     end
 
-    def print_provider_command(provider, arg_str, description = nil)
-      command = "#{provider}:#{arg_str}"
+    def print_scheme_argument(scheme, path, description = nil)
+      command = "#{scheme}:#{path}"
       command += " # #{description}" unless description.nil?
       output.puts command
     end
@@ -48,77 +48,99 @@ module Abt
     end
 
     def abort(message)
-      raise AbortError, message
+      raise Abort, message
+    end
+
+    def exit_with_message(message)
+      raise Exit, message
     end
 
     private
 
-    def handle_global_commands! # rubocop:disable Metrics/MethodLength
+    def handle_global_commands!
       case command
       when nil
         warn("No command specified\n\n")
-        puts(Abt::Docs::Cli.content)
-        true
-      when '--help', '-h', 'help', 'commands'
-        puts(Abt::Docs::Cli.content)
-        true
-      when 'help-md'
-        puts(Abt::Docs::Markdown.content)
+        puts(Abt::Docs::Cli.help)
         true
       when '--version', '-v', 'version'
         puts(Abt::VERSION)
         true
+      when '--help', '-h', 'help'
+        puts(Abt::Docs::Cli.help)
+        true
+      when 'commands'
+        puts(Abt::Docs::Cli.commands)
+        true
+      when 'examples'
+        puts(Abt::Docs::Cli.examples)
+        true
+      when 'readme'
+        puts(Abt::Docs::Markdown.readme)
+        true
       else
         false
       end
     end
 
-    def args_from_input
-      input_string = input.read.strip
+    def sanitized_piped_args
+      return [] if input.isatty
 
-      abort 'No input from pipe' if input_string.nil? || input_string.empty?
+      @sanitized_piped_args ||= begin
+        input_string = input.read.strip
 
-      # Exclude comment part of piped input lines
-      lines_without_comments = input_string.lines.map do |line|
-        line.split(' # ').first
-      end
+        abort 'No input from pipe' if input_string.nil? || input_string.empty?
 
-      # Allow multiple provider arguments on a single piped input line
-      joined_lines = lines_without_comments.join(' ').strip
-      joined_lines.split(/\s+/)
+        # Exclude comment part of piped input lines
+        lines_without_comments = input_string.lines.map do |line|
+          line.split(' # ').first
+        end
+
+        # Allow multiple scheme arguments on a single piped input line
+        # TODO: Force the user to pick a single scheme argument
+        joined_lines = lines_without_comments.join(' ').strip
+        joined_lines.split(/\s+/)
+      end
     end
 
-    def process_providers
-      used_providers = []
-      args.each do |provider_args|
-        (provider, arg_str) = provider_args.split(':')
+    def process_scheme_arguments
+      used_schemes = []
+      scheme_arguments.each do |scheme_argument|
+        scheme = scheme_argument.scheme
+        path = scheme_argument.path
 
-        if used_providers.include?(provider)
-          warn "Dropping command for already used provider: #{provider_args}"
+        if used_schemes.include?(scheme)
+          warn "Dropping command for already used scheme: #{scheme_argument}"
           next
         end
 
-        used_providers << provider if process_provider_command(provider, command, arg_str)
-      end
+        command_class = get_command_class(scheme)
+        next if command_class.nil?
 
-      abort 'No matching providers found for command' if used_providers.empty? && output.isatty
-    end
+        print_command(command, scheme_argument) if output.isatty
+        begin
+          command_class.new(path: path, cli: self, flags: scheme_argument.flags).perform
+        rescue Exit => e
+          puts e.message
+        end
+
+        used_schemes << scheme
+      end
 
-    def process_provider_command(provider_name, command_name, arg_str)
-      provider = Abt.provider_module(provider_name)
-      return false if provider.nil?
+      return unless used_schemes.empty? && output.isatty
 
-      command = provider.command_class(command_name)
-      return false if command.nil?
+      abort 'No providers found for command and scheme argument(s)'
+    end
 
-      print_command(command_name, provider_name, arg_str) if output.isatty
+    def get_command_class(scheme)
+      provider = Abt.scheme_provider(scheme)
+      return nil if provider.nil?
 
-      command.new(arg_str: arg_str, cli: self).call
-      true
+      provider.command_class(command)
     end
 
-    def print_command(name, provider, arg_str)
-      warn "===== #{name} #{provider}#{arg_str.nil? ? '' : ":#{arg_str}"} =====".upcase
+    def print_command(name, scheme_argument)
+      warn "===== #{name} #{scheme_argument} =====".upcase
     end
   end
 end

data/lib/abt/cli/arguments_parser.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    class ArgumentsParser
+      class SchemeArgument
+        attr_reader :scheme, :path, :flags
+
+        def initialize(scheme:, path:, flags:)
+          @scheme = scheme
+          @path = path
+          @flags = flags
+        end
+
+        def to_s
+          str = scheme
+          str += ":#{path}" if path
+
+          [str, *flags].join(' ')
+        end
+      end
+      class SchemeArguments < Array
+        def to_s
+          map(&:to_s).join(' -- ')
+        end
+      end
+
+      attr_reader :arguments
+
+      def initialize(arguments)
+        @arguments = arguments
+      end
+
+      def parse
+        result = SchemeArguments.new
+        rest = arguments.dup
+
+        until rest.empty?
+          (scheme, path) = rest.shift.split(':')
+          flags = take_flags(rest)
+
+          result << SchemeArgument.new(scheme: scheme, path: path, flags: flags)
+        end
+
+        result
+      end
+
+      private
+
+      def take_flags(rest)
+        flags = []
+
+        if flag?(rest.first)
+          flags << rest.shift until rest.empty? || delimiter?(rest.first)
+          rest.shift if delimiter?(rest.first)
+        end
+
+        flags
+      end
+
+      def flag?(part)
+        part && part[0] == '-'
+      end
+
+      def delimiter?(part)
+        part == '--'
+      end
+    end
+  end
+end

data/lib/abt/cli/base_command.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    class BaseCommand
+      def self.usage
+        raise NotImplementedError, 'Command classes must implement .command'
+      end
+
+      def self.description
+        raise NotImplementedError, 'Command classes must implement .description'
+      end
+
+      def self.flags
+        []
+      end
+
+      attr_reader :path, :flags, :cli
+
+      def initialize(path:, flags:, cli:)
+        @cli = cli
+        @path = path
+        @flags = parse_flags(flags)
+      end
+
+      def perform
+        raise NotImplementedError, 'Command classes must implement #perform'
+      end
+
+      private
+
+      def parse_flags(flags)
+        result = {}
+
+        flag_parser.parse!(flags.dup, into: result)
+
+        cli.exit_with_message(flag_parser.help) if result[:help]
+
+        result
+      rescue OptionParser::InvalidOption => e
+        cli.abort e.message
+      end
+
+      def flag_parser
+        @flag_parser ||= OptionParser.new do |opts|
+          opts.banner = <<~TXT
+            #{self.class.description}
+
+            Usage: #{self.class.usage}
+          TXT
+
+          opts.on('-h', '--help')
+
+          self.class.flags.each do |(*flag)|
+            opts.on(*flag)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abt/cli/prompt.rb

@@ -34,7 +34,7 @@ module Abt
         output.puts "#{text}:"
 
         if options.length.zero?
-          raise AbortError, 'No available options' unless nil_option
+          raise Abort, 'No available options' unless nil_option
 
           output.puts 'No available options'
           return nil
@@ -114,7 +114,7 @@ module Abt
         @tty_path ||= begin
           candidates = ['/dev/tty', 'CON:'] # Unix: '/dev/tty', Windows: 'CON:'
           selected = candidates.find { |candidate| File.exist?(candidate) }
-          raise AbortError, '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

@@ -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