abt-cli 0.0.13 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f61e3ba3cf1e1f6b5b69502861814a80b763849a7a9e8d654a593b55bf53b1bb
-  data.tar.gz: 497d18071f5a32cc4df92d2075a097452ffa2ffbf7f97ab98916678e6c92fa31
+  metadata.gz: df400d04c979d979ab2ead353d68374b8266c0fff678103991cc6443512b703b
+  data.tar.gz: 0345141c38eae6904d11f40a3045fccd048d8009b70fe9714f5e0986f1779861
 SHA512:
-  metadata.gz: fa028736b67c70cd694a6e75665136e7829865d7afe66828262eae903aa553d5dc92478957e9e36526669f96fde1aa42ccab0036e2c1319f6db6cc47cfd033e4
-  data.tar.gz: 01af79206699568177e2548cd2662012f63ea996c6289a7dc49795fb99f06ff157692a51df444505336c3851a1f562a63fef659ca046e03579e11123b1e8a7ba
+  metadata.gz: 1979110cbd58f0bc71b83ad7211b86e17c5b078e842d4f99ca839c88a88d627ab92506736cd83b6e414cbea2ec2a82592f6e8b3f1effdbd2b57df7decd63793e
+  data.tar.gz: 6af0e9bb436b304cda9d3acf6c86733050c9a7acffb691017d968e89e3f4e8e51b9fa4cdf5e3a85373ff2f684fa61e41afce0c1b9011d2e6b5551935b40530ea

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,18 +5,21 @@ 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
 end
 
 module Abt
-  def self.provider_names
+  module Providers; end
+
+  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,103 +6,141 @@ 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
+      @prompt = Abt::Cli::Prompt.new(output: err_output)
 
-      @args += args_from_input unless input.isatty # Add piped arguments
+      @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 = []
+      aris.each do |ari|
+        scheme = ari.scheme
+        path = ari.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: #{ari}"
           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?
 
-      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(path: path, cli: self, flags: ari.flags).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 << 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} #{ari} =====".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 Ari
+        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 Aris < Array
+        def to_s
+          map(&:to_s).join(' -- ')
+        end
+      end
+
+      attr_reader :arguments
+
+      def initialize(arguments)
+        @arguments = arguments
+      end
+
+      def parse
+        result = Aris.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/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/{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,16 @@ 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)}): "
+        output.print '('
+        output.print options_length > 1 ? "1-#{options_length}" : '1'
+        output.print nil_option_string(nil_option)
+        output.print '): '
 
         input = read_user_input
 
@@ -71,7 +80,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 +107,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