abt-cli 0.0.11 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cc34f7579a887a49ae83db56c8b3808a0e00b09c55631f9b4224228477a0762
-  data.tar.gz: 9c26a06c3af53ebe55ca5e53f93b5d6d73854962daebef31d131000657be1c63
+  metadata.gz: '09c4dedacc59650be8d22ae65041e78913fc4405bbb61109ef93217801bafcff'
+  data.tar.gz: 91f205c4db85e2686b8461c6c2b029a45e6e430c418041aa3ffae725d1ecd16b
 SHA512:
-  metadata.gz: 4fe10297a130b747d93dc1398bdf404996d5c07987680deac59a5365d6893ab3d0466ebd764ef087f5eb2409b99a7733dc55a869432d81286f3460ec510d247d
-  data.tar.gz: 3684a1d3113f9df06637a6c7294f334b48e2c8cd5e54d4334c1ec1884571519f6e5aedeec327d8292f5364d1251453d6a7a8131074f91b2f94935b7a3586ddb9
+  metadata.gz: 42f9d332099fdcecdbdf538bd44119b75d643db6399d06fe578d15e5dff664af9dfec59a5ffa1f1235a1b922fa5727d52c20ed0b6a8c4fa795e1750b51f0943d
+  data.tar.gz: a88ffec46e7331823de6dc89fde11e442ac3c7bd577495a89dd2af20b879675de7fdafada270d1614556d193bb909892fd9622b8b3cd87f2836fab0aa94b1483

data/bin/abt

@@ -1,17 +1,11 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'dry-inflector'
-require 'faraday'
-require 'oj'
-require 'open3'
-require 'stringio'
-
 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

@@ -1,16 +1,25 @@
 # frozen_string_literal: true
 
+require 'dry-inflector'
+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, :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
-      handle_global_commands!
+      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
 
+    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 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?
 
-      warn '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
 
-    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 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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Abt
+  class Cli
+    class Prompt
+      attr_reader :output
+
+      def initialize(output:)
+        @output = output
+      end
+
+      def text(question)
+        output.print "#{question}: "
+        read_user_input
+      end
+
+      def boolean(text)
+        output.puts text
+
+        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
+      end
+
+      def choice(text, options, nil_option = false)
+        output.puts "#{text}:"
+
+        if options.length.zero?
+          raise Abort, 'No available options' unless nil_option
+
+          output.puts 'No available options'
+          return nil
+        end
+
+        print_options(options)
+        select_options(options, nil_option)
+      end
+
+      private
+
+      def print_options(options)
+        options.each_with_index do |option, index|
+          output.puts "(#{index + 1}) #{option['name']}"
+        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
+
+          option = options[number - 1]
+
+          output.puts "Selected: (#{number}) #{option['name']}"
+          return option
+        end
+      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 '): '
+
+        input = 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
+
+        option_number
+      end
+
+      def nil_option_string(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
+
+        nil_option[0]
+      end
+
+      def nil_option_description(nil_option)
+        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
+      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
+end