abt-cli 0.0.14 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6355433a65cf9e49738ab971a8886e657cefff8d3a8322e44d140a18fa7a6be
-  data.tar.gz: f71c9909c3c8063f24365d80db1ae91223876be98cda4e6681a5f37e017af2ca
+  metadata.gz: 295db35510e60a5b46ea7f20caa01aaad247bb30cb60e61b912cab5f754637ac
+  data.tar.gz: e686eb40fc1ac88315c138eac56b96500c29c3f012b4bdb1d97f993a507f80b7
 SHA512:
-  metadata.gz: 809f27b09f6bbf41eefca395f95621b9bd7c48cb3f78cd5e7bf62c48a87895669fa74aebad4ea31fdee6ed484bf8944bb6216059b93066db2cfe118bc65c6e34
-  data.tar.gz: '032284e3f7e465618c2c039dbafa84855548bcee41d56725606fd2b48e58c008ba89010be8c25e78f714f3c1e16cc8a30f3e8021a0a5a531617dc0d54393ce1e'
+  metadata.gz: f18aa2b4f33bb6b51689522bca357ddb0fbe7a2d2e968bcc6754959f01bf6d54b9f93c387e8a050d165063cad26e6b360f245d2e7fa317bc1fbad8c0fa0d3379
+  data.tar.gz: ab46d17a29d4e447472c8c4d9242aa2e96bd5195bad4083d0476054f312d358ad5555526b44edacdf2512713e646435200689f82e8a097c1dfa306ff2ae1c4df

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/ari.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Abt
+  class Ari
+    attr_reader :scheme, :path, :flags
+
+    def initialize(scheme:, path: nil, flags: [])
+      @scheme = scheme
+      @path = path
+      @flags = flags
+    end
+
+    def to_s
+      str = scheme
+      str += ":#{path}" if path
+
+      [str, *flags].join(' ')
+    end
+  end
+end

data/lib/abt/ari_list.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Abt
+  class AriList < Array
+    def to_s
+      map(&:to_s).join(' -- ')
+    end
+
+    def -(other)
+      AriList.new(to_a - other)
+    end
+  end
+end

data/lib/abt/base_command.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Abt
+  class BaseCommand
+    extend Forwardable
+
+    def self.usage
+      raise NotImplementedError, 'Command classes must implement .usage'
+    end
+
+    def self.description
+      raise NotImplementedError, 'Command classes must implement .description'
+    end
+
+    def self.flags
+      []
+    end
+
+    attr_reader :ari, :cli, :flags
+
+    def_delegators(:@cli, :warn, :puts, :print, :abort, :exit_with_message)
+
+    def initialize(ari:, cli:)
+      @cli = cli
+      @ari = ari
+      @flags = parse_flags(ari.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)
+
+      exit_with_message(flag_parser.help) if result[:help]
+
+      result
+    rescue OptionParser::InvalidOption => e
+      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

data/lib/abt/cli.rb

@@ -6,103 +6,138 @@ end
 
 module Abt
   class Cli
-    class AbortError < StandardError; end
+    class Abort < StandardError; end
+    class Exit < StandardError; end
 
-    include Dialogs
-    include Io
-
-    attr_reader :command, :args, :input, :output, :err_output
+    attr_reader :command, :aris, :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
-
-      @args += args_from_input unless input.isatty # Add piped arguments
+      @prompt = Abt::Cli::Prompt.new(output: err_output)
+      @aris = ArgumentsParser.new(sanitized_piped_args + remaining_args).parse
     end
 
     def perform
-      handle_global_commands!
+      return if handle_global_commands!
 
-      abort('No provider arguments') if args.empty?
+      abort('No ARIs') if aris.empty?
 
-      process_providers
+      process_aris
     end
 
-    def print_provider_command(provider, arg_str, description = nil)
-      command = "#{provider}:#{arg_str}"
+    def print_ari(scheme, path, description = nil)
+      command = "#{scheme}:#{path}"
       command += " # #{description}" unless description.nil?
       output.puts command
     end
 
+    def warn(*args)
+      err_output.puts(*args)
+    end
+
+    def puts(*args)
+      output.puts(*args)
+    end
+
+    def print(*args)
+      output.print(*args)
+    end
+
+    def abort(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)
-        exit
-      when '--help', '-h', 'help', 'commands'
-        puts(Abt::Docs::Cli.content)
-        exit
-      when 'help-md'
-        puts(Abt::Docs::Markdown.content)
-        exit
+        puts(Abt::Docs::Cli.help)
+        true
       when '--version', '-v', 'version'
         puts(Abt::VERSION)
-        exit
+        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
+    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?
+
+        # Exclude comment part of piped input lines
+        lines_without_comments = input_string.lines.map do |line|
+          line.split(' # ').first
+        end
 
-      # Allow multiple provider arguments on a single piped input line
-      joined_lines = lines_without_comments.join(' ').strip
-      joined_lines.split(/\s+/)
+        # Allow multiple ARIs on a single piped input line
+        # TODO: Force the user to pick a single ARI
+        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_aris
+      used_schemes = []
 
-        if used_providers.include?(provider)
-          warn "Dropping command for already used provider: #{provider_args}"
+      aris.each do |ari|
+        if used_schemes.include?(ari.scheme)
+          warn "Dropping command for already used scheme: #{ari}"
           next
         end
 
-        used_providers << provider if process_provider_command(provider, command, arg_str)
-      end
+        command_class = get_command_class(ari.scheme)
+        next if command_class.nil?
 
-      warn 'No matching providers found for command' if used_providers.empty? && output.isatty
-    end
+        print_command(command, ari) if output.isatty
+        begin
+          command_class.new(ari: ari, cli: self).perform
+        rescue Exit => e
+          puts e.message
+        end
 
-    def process_provider_command(provider_name, command_name, arg_str)
-      provider = Abt.provider_module(provider_name)
-      return false if provider.nil?
+        used_schemes << ari.scheme
+      end
 
-      command = provider.command_class(command_name)
-      return false if command.nil?
+      return unless used_schemes.empty? && output.isatty
+
+      abort 'No providers found for command and ARI(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, ari)
+      warn "===== #{name.upcase} #{ari} ====="
     end
   end
 end

data/lib/abt/cli/arguments_parser.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    class ArgumentsParser
+      attr_reader :arguments
+
+      def initialize(arguments)
+        @arguments = arguments
+      end
+
+      def parse
+        result = AriList.new
+        rest = arguments.dup
+
+        until rest.empty?
+          (scheme, path) = rest.shift.split(':')
+          flags = take_flags(rest)
+
+          result << Ari.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/{dialogs.rb → prompt.rb}

@@ -2,35 +2,41 @@
 
 module Abt
   class Cli
-    module Dialogs
-      def prompt(question)
-        err_output.print "#{question}: "
-        read_user_input.strip
+    class Prompt
+      attr_reader :output
+
+      def initialize(output:)
+        @output = output
+      end
+
+      def text(question)
+        output.print "#{question}: "
+        read_user_input
       end
 
-      def prompt_boolean(text)
-        warn text
+      def boolean(text)
+        output.puts text
 
         loop do
-          err_output.print '(y / n): '
+          output.print '(y / n): '
 
-          case read_user_input.strip
+          case read_user_input
           when 'y', 'Y' then return true
           when 'n', 'N' then return false
           else
-            warn 'Invalid choice'
+            output.puts 'Invalid choice'
             next
           end
         end
       end
 
-      def prompt_choice(text, options, nil_option = false)
-        warn "#{text}:"
+      def choice(text, options, nil_option = false)
+        output.puts "#{text}:"
 
         if options.length.zero?
-          abort 'No available options' unless nil_option
+          raise Abort, 'No available options' unless nil_option
 
-          warn 'No available options'
+          output.puts 'No available options'
           return nil
         end
 
@@ -42,7 +48,7 @@ module Abt
 
       def print_options(options)
         options.each_with_index do |option, index|
-          warn "(#{index + 1}) #{option['name']}"
+          output.puts "(#{index + 1}) #{option['name']}"
         end
       end
 
@@ -57,13 +63,17 @@ module Abt
 
           option = options[number - 1]
 
-          warn "Selected: (#{number}) #{option['name']}"
+          output.puts "Selected: (#{number}) #{option['name']}"
           return option
         end
       end
 
       def read_option_number(options_length, nil_option)
-        err_output.print "(1-#{options_length}#{nil_option_string(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
 
@@ -71,7 +81,7 @@ module Abt
 
         option_number = input.to_i
         if option_number <= 0 || option_number > options_length
-          warn 'Invalid selection'
+          output.puts 'Invalid selection'
           return nil
         end
 
@@ -98,7 +108,17 @@ module Abt
       end
 
       def read_user_input
-        open('/dev/tty', &:gets).strip
+        open(tty_path, &:gets).strip # rubocop:disable Security/Open
+      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?
+
+          selected
+        end
       end
     end
   end