dry-cli 0.4.0

data/lib/dry/cli/command_registry.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'concurrent/hash'
+require 'hanami/utils/callbacks'
+
+module Dry
+  class CLI
+    # Command registry
+    #
+    # @since 0.1.0
+    # @api private
+    class CommandRegistry
+      # @since 0.1.0
+      # @api private
+      def initialize
+        @root = Node.new
+      end
+
+      # @since 0.1.0
+      # @api private
+      def set(name, command, aliases, **options)
+        node = @root
+        command = command_for(name, command, **options)
+        name.split(/[[:space:]]/).each do |token|
+          node = node.put(node, token)
+        end
+
+        node.aliases!(aliases)
+        node.leaf!(command) unless command.nil?
+
+        nil
+      end
+
+      # @since 0.1.0
+      # @api private
+      #
+      def get(arguments)
+        node   = @root
+        args   = []
+        names  = []
+        result = LookupResult.new(node, args, names, node.leaf?)
+
+        arguments.each_with_index do |token, i|
+          tmp = node.lookup(token)
+
+          if tmp.nil?
+            result = LookupResult.new(node, args, names, false)
+            break
+          elsif tmp.leaf?
+            args   = arguments[i + 1..-1]
+            names  = arguments[0..i]
+            node   = tmp
+            result = LookupResult.new(node, args, names, true)
+            break
+          else
+            names  = arguments[0..i]
+            node   = tmp
+            result = LookupResult.new(node, args, names, node.leaf?)
+          end
+        end
+
+        result
+      end
+
+      private
+
+      # @since 0.1.0
+      # @api private
+      def command_for(name, command, **options)
+        if command.nil?
+          command
+        else
+          command.new(command_name: name, **options)
+        end
+      end
+
+      # Node of the registry
+      #
+      # @since 0.1.0
+      # @api private
+      class Node
+        # @since 0.1.0
+        # @api private
+        attr_reader :parent
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :children
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :aliases
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :command
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :before_callbacks
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :after_callbacks
+
+        # @since 0.1.0
+        # @api private
+        def initialize(parent = nil)
+          @parent   = parent
+          @children = Concurrent::Hash.new
+          @aliases  = Concurrent::Hash.new
+          @command  = nil
+
+          @before_callbacks = Hanami::Utils::Callbacks::Chain.new
+          @after_callbacks = Hanami::Utils::Callbacks::Chain.new
+        end
+
+        # @since 0.1.0
+        # @api private
+        def put(parent, key)
+          children[key] ||= self.class.new(parent)
+        end
+
+        # @since 0.1.0
+        # @api private
+        def lookup(token)
+          children[token] || aliases[token]
+        end
+
+        # @since 0.1.0
+        # @api private
+        def leaf!(command)
+          @command = command
+        end
+
+        # @since 0.1.0
+        # @api private
+        def alias!(key, child)
+          @aliases[key] = child
+        end
+
+        # @since 0.1.0
+        # @api private
+        def aliases!(aliases)
+          aliases.each do |a|
+            parent.alias!(a, self)
+          end
+        end
+
+        # @since 0.1.0
+        # @api private
+        def leaf?
+          !command.nil?
+        end
+      end
+
+      # Result of a registry lookup
+      #
+      # @since 0.1.0
+      # @api private
+      class LookupResult
+        # @since 0.1.0
+        # @api private
+        attr_reader :names
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :arguments
+
+        # @since 0.1.0
+        # @api private
+        def initialize(node, arguments, names, found)
+          @node      = node
+          @arguments = arguments
+          @names     = names
+          @found     = found
+        end
+
+        # @since 0.1.0
+        # @api private
+        def found?
+          @found
+        end
+
+        # @since 0.1.0
+        # @api private
+        def children
+          @node.children
+        end
+
+        # @since 0.1.0
+        # @api private
+        def command
+          @node.command
+        end
+
+        # @since 0.2.0
+        # @api private
+        def before_callbacks
+          @node.before_callbacks
+        end
+
+        # @since 0.2.0
+        # @api private
+        def after_callbacks
+          @node.after_callbacks
+        end
+      end
+    end
+  end
+end

data/lib/dry/cli/errors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'hanami/utils/deprecation'
+
+module Dry
+  # General purpose Command Line Interface (CLI) framework for Ruby
+  #
+  # @since 0.1.0
+  class CLI
+    # @since 0.2.0
+    class Error < StandardError
+    end
+
+    # @since 0.2.1
+    class UnknownCommandError < Error
+      # @since 0.2.1
+      # @api private
+      def initialize(command_name)
+        super("unknown command: `#{command_name}'")
+      end
+    end
+
+    # @since 0.2.0
+    class InvalidCallbackError < Error
+      # @since 0.2.0
+      # @api private
+      def initialize(callback)
+        message = case callback
+                  when Class
+                    "expected `#{callback.inspect}' to respond to `#initialize' with arity 0"
+                  else
+                    "expected `#{callback.inspect}' to respond to `#call'"
+                  end
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/dry/cli/option.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'hanami/utils/string'
+
+module Dry
+  class CLI
+    # Command line option
+    #
+    # @since 0.1.0
+    # @api private
+    class Option
+      # @since 0.1.0
+      # @api private
+      attr_reader :name
+
+      # @since 0.1.0
+      # @api private
+      attr_reader :options
+
+      # @since 0.1.0
+      # @api private
+      def initialize(name, options = {})
+        @name = name
+        @options = options
+      end
+
+      # @since 0.1.0
+      # @api private
+      def aliases
+        options[:aliases] || []
+      end
+
+      # @since 0.1.0
+      # @api private
+      def desc
+        desc = options[:desc]
+        values ? "#{desc}: (#{values.join('/')})" : desc
+      end
+
+      # @since 0.1.0
+      # @api private
+      def required?
+        options[:required]
+      end
+
+      # @since 0.1.0
+      # @api private
+      def type
+        options[:type]
+      end
+
+      # @since 0.1.0
+      # @api private
+      def values
+        options[:values]
+      end
+
+      # @since 0.1.0
+      # @api private
+      def boolean?
+        type == :boolean
+      end
+
+      # @since 0.3.0
+      # @api private
+      def array?
+        type == :array
+      end
+
+      # @since 0.1.0
+      # @api private
+      def default
+        options[:default]
+      end
+
+      # @since 0.1.0
+      # @api private
+      def description_name
+        options[:label] || name.upcase
+      end
+
+      # @since 0.1.0
+      # @api private
+      def argument?
+        false
+      end
+
+      # @since 0.1.0
+      # @api private
+      #
+      # rubocop:disable Metrics/AbcSize
+      def parser_options
+        dasherized_name = Hanami::Utils::String.dasherize(name)
+        parser_options  = []
+
+        if boolean?
+          parser_options << "--[no-]#{dasherized_name}"
+        else
+          parser_options << "--#{dasherized_name}=#{name}"
+          parser_options << "--#{dasherized_name} #{name}"
+        end
+
+        parser_options << Array if array?
+        parser_options << values if values
+        parser_options.unshift(alias_name) unless alias_name.nil?
+        parser_options << desc if desc
+        parser_options
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      # @since 0.1.0
+      # @api private
+      def alias_name
+        aliases.join(' ') if aliases.any?
+      end
+    end
+
+    # Command line argument
+    #
+    # @since 0.1.0
+    # @api private
+    class Argument < Option
+      # @since 0.1.0
+      # @api private
+      def argument?
+        true
+      end
+    end
+  end
+end

data/lib/dry/cli/parser.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'dry/cli/program_name'
+
+module Dry
+  class CLI
+    # Parse command line arguments and options
+    #
+    # @since 0.1.0
+    # @api private
+    module Parser
+      # @since 0.1.0
+      # @api private
+      #
+      def self.call(command, arguments, names)
+        original_arguments = arguments.dup
+        parsed_options = {}
+
+        OptionParser.new do |opts|
+          command.options.each do |option|
+            opts.on(*option.parser_options) do |value|
+              parsed_options[option.name.to_sym] = value
+            end
+          end
+
+          opts.on_tail('-h', '--help') do
+            return Result.help
+          end
+        end.parse!(arguments)
+
+        parsed_options = command.default_params.merge(parsed_options)
+        parse_required_params(command, arguments, names, parsed_options)
+      rescue ::OptionParser::ParseError
+        Result.failure("Error: \"#{command.command_name}\" was called with arguments \"#{original_arguments.join(' ')}\"") # rubocop:disable Metrics/LineLength
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.full_command_name(names)
+        ProgramName.call(names)
+      end
+
+      # @since 0.1.0
+      # @api private
+      #
+      # rubocop:disable Metrics/AbcSize
+      def self.parse_required_params(command, arguments, names, parsed_options)
+        parsed_params          = match_arguments(command.arguments, arguments)
+        parsed_required_params = match_arguments(command.required_arguments, arguments)
+        all_required_params_satisfied = command.required_arguments.all? { |param| !parsed_required_params[param.name].nil? } # rubocop:disable Metrics/LineLength
+
+        unused_arguments = arguments.drop(command.required_arguments.length)
+
+        unless all_required_params_satisfied
+          parsed_required_params_values = parsed_required_params.values.compact
+
+          usage = "\nUsage: \"#{full_command_name(names)} #{command.required_arguments.map(&:description_name).join(' ')}\"" # rubocop:disable Metrics/LineLength
+
+          if parsed_required_params_values.empty? # rubocop:disable Style/GuardClause
+            return Result.failure("ERROR: \"#{full_command_name(names)}\" was called with no arguments#{usage}") # rubocop:disable Metrics/LineLength
+          else
+            return Result.failure("ERROR: \"#{full_command_name(names)}\" was called with arguments #{parsed_required_params_values}#{usage}") # rubocop:disable Metrics/LineLength
+          end
+        end
+
+        parsed_params.reject! { |_key, value| value.nil? }
+        parsed_options = parsed_options.merge(parsed_params)
+        parsed_options = parsed_options.merge(args: unused_arguments) if unused_arguments.any?
+        Result.success(parsed_options)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def self.match_arguments(command_arguments, arguments)
+        result = {}
+
+        command_arguments.each_with_index do |cmd_arg, index|
+          if cmd_arg.array?
+            result[cmd_arg.name] = arguments[index..-1]
+            break
+          else
+            result[cmd_arg.name] = arguments.at(index)
+          end
+        end
+
+        result
+      end
+
+      # @since 0.1.0
+      # @api private
+      class Result
+        # @since 0.1.0
+        # @api private
+        def self.help
+          new(help: true)
+        end
+
+        # @since 0.1.0
+        # @api private
+        def self.success(arguments = {})
+          new(arguments: arguments)
+        end
+
+        # @since 0.1.0
+        # @api private
+        def self.failure(error = 'Error: Invalid param provided')
+          new(error: error)
+        end
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :arguments
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :error
+
+        # @since 0.1.0
+        # @api private
+        def initialize(arguments: {}, error: nil, help: false)
+          @arguments = arguments
+          @error     = error
+          @help      = help
+        end
+
+        # @since 0.1.0
+        # @api private
+        def error?
+          !error.nil?
+        end
+
+        # @since 0.1.0
+        # @api private
+        def help?
+          @help
+        end
+      end
+    end
+  end
+end