rfix 1.4.1 → 2.0.0

data/vendor/dry-cli/docsite/source/options.html.md

@@ -0,0 +1,51 @@
+---
+title: Options
+layout: gem-single
+name: dry-cli
+---
+
+An option is a named argument that is passed after the _command name_ **and** the arguments.
+
+For instance, given the `foo request` command, when an user types `foo request --mode=http2`, then `--mode=http2` is considered an option.
+A command can accept none or many options.
+
+```ruby
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "dry/cli"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      class Request < Dry::CLI::Command
+        option :mode, default: "http", values: %w[http http2], desc: "The request mode"
+
+        def call(**options)
+          puts "Performing a request (mode: #{options.fetch(:mode)})"
+        end
+      end
+
+      register "request", Request
+    end
+  end
+end
+
+Dry::CLI.new(Foo::CLI::Commands).call
+```
+
+```sh
+$ foo request
+Performing a request (mode: http)
+```
+
+```sh
+$ foo request --mode=http2
+Performing a request (mode: http2)
+```
+
+```sh
+$ foo request --mode=unknown
+ERROR: "foo request" was called with arguments "--mode=unknown"
+```

data/vendor/dry-cli/docsite/source/subcommands.html.md

@@ -0,0 +1,38 @@
+---
+title: Subcommands
+layout: gem-single
+name: dry-cli
+---
+
+There is nothing special about subcommands, they are simply _command objects_ registered under a **nested** _command name_:
+
+```ruby
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "dry/cli"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      module Generate
+        class Configuration < Dry::CLI::Command
+          def call(*)
+          end
+        end
+      end
+    end
+  end
+end
+
+Foo::CLI::Commands.register "generate configuration", Foo::CLI::Commands::Generate::Configuration
+
+Dry::CLI.new(Foo::CLI::Commands).call
+```
+
+```sh
+$ foo generate
+Commands:
+  foo generate config           # Generate configuration
+```

data/vendor/dry-cli/docsite/source/variadic-arguments.html.md

@@ -0,0 +1,45 @@
+---
+title: Variadic arguments
+layout: gem-single
+name: dry-cli
+---
+
+Sometimes we need extra arguments because those will be forwarded to a sub-command like `ssh`, `docker` or `cat`.
+
+By using `--` (double dash, aka hypen), the user indicates the end of the arguments and options belonging to the main command, and the beginning of the variadic arguments that can be forwarded to the sub-command.
+These extra arguments are included as `:args` in the keyword arguments available for each command.
+
+```ruby
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "dry/cli"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      class Runner < Dry::CLI::Command
+        argument :image, required: true, desc: "Docker image"
+
+        def call(image:, args: [], **)
+          puts `docker run -it --rm #{image} #{args.join(" ")}`
+        end
+      end
+
+      register "run", Runner
+    end
+  end
+end
+
+Dry::CLI.new(Foo::CLI::Commands).call
+```
+
+```sh
+$ foo run ruby:latest -- ruby -v
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux]
+```
+
+The user separates via `--` the arguments for `foo` and the command has to be run by the Docker container.
+In this specific case, `ruby:latest` corresponds to the `image` mandatory argument for `foo`, whereas `ruby -v` is the variadic argument that is passed to Docker via `args`.
+

data/vendor/dry-cli/dry-cli.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# this file is managed by dry-rb/devtools project
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dry/cli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dry-cli'
+  spec.authors       = ["Luca Guidi"]
+  spec.email         = ["me@lucaguidi.com"]
+  spec.license       = 'MIT'
+  spec.version       = Dry::CLI::VERSION.dup
+
+  spec.summary       = "Common framework to build command line interfaces with Ruby"
+  spec.description   = spec.summary
+  spec.homepage      = 'https://dry-rb.org/gems/dry-cli'
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "dry-cli.gemspec", "lib/**/*"]
+  spec.bindir        = 'bin'
+  spec.executables   = []
+  spec.require_paths = ['lib']
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['changelog_uri']     = 'https://github.com/dry-rb/dry-cli/blob/master/CHANGELOG.md'
+  spec.metadata['source_code_uri']   = 'https://github.com/dry-rb/dry-cli'
+  spec.metadata['bug_tracker_uri']   = 'https://github.com/dry-rb/dry-cli/issues'
+
+  spec.required_ruby_version = ">= 2.4.0"
+
+  # to update dependencies edit project.yml
+  spec.add_development_dependency "bundler", ">= 1.6", "< 3"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.7"
+  spec.add_development_dependency "rubocop", "~> 0.82"
+  spec.add_development_dependency "simplecov", "~> 0.17.1"
+end

data/vendor/dry-cli/lib/dry/cli.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+# Dry
+#
+# @since 0.1.0
+module Dry
+  # General purpose Command Line Interface (CLI) framework for Ruby
+  #
+  # @since 0.1.0
+  class CLI
+    require "dry/cli/version"
+    require "dry/cli/errors"
+    require "dry/cli/command"
+    require "dry/cli/registry"
+    require "dry/cli/parser"
+    require "dry/cli/usage"
+    require "dry/cli/banner"
+    require "dry/cli/inflector"
+
+    # Check if command
+    #
+    # @param command [Object] the command to check
+    #
+    # @return [TrueClass,FalseClass] true if instance of `Dry::CLI::Command`
+    #
+    # @since 0.1.0
+    # @api private
+    def self.command?(command)
+      case command
+      when Class
+        command.ancestors.include?(Command)
+      else
+        command.is_a?(Command)
+      end
+    end
+
+    # Create a new instance
+    #
+    # @param command_or_registry [Dry::CLI::Registry, Dry::CLI::Command]
+    #   a registry or singular command
+    # @param &block [Block] a configuration block for registry
+    #
+    # @return [Dry::CLI] the new instance
+    # @since 0.1.0
+    def initialize(command_or_registry = nil, &block)
+      @kommand = command_or_registry if command?(command_or_registry)
+
+      @registry =
+        if block_given?
+          anonymous_registry(&block)
+        else
+          command_or_registry
+        end
+    end
+
+    # Invoke the CLI
+    #
+    # @param arguments [Array<string>] the command line arguments (defaults to `ARGV`)
+    # @param out [IO] the standard output (defaults to `$stdout`)
+    # @param err [IO] the error output (defaults to `$stderr`)
+    #
+    # @since 0.1.0
+    def call(arguments: ARGV, out: $stdout, err: $stderr)
+      @out, @err = out, err
+      kommand ? perform_command(arguments) : perform_registry(arguments)
+    rescue SignalException => e
+      signal_exception(e)
+    rescue Errno::EPIPE
+      # no op
+    end
+
+    private
+
+    # @since 0.6.0
+    # @api private
+    attr_reader :registry
+
+    # @since 0.6.0
+    # @api private
+    attr_reader :kommand
+
+    # @since 0.6.0
+    # @api private
+    attr_reader :out
+
+    # @since 0.6.0
+    # @api private
+    attr_reader :err
+
+    # Invoke the CLI if singular command passed
+    #
+    # @param arguments [Array<string>] the command line arguments
+    # @param out [IO] the standard output (defaults to `$stdout`)
+    #
+    # @since 0.6.0
+    # @api private
+    def perform_command(arguments)
+      command, args = parse(kommand, arguments, [])
+      command.call(**args)
+    end
+
+    # Invoke the CLI if registry passed
+    #
+    # @param arguments [Array<string>] the command line arguments
+    # @param out [IO] the standard output (defaults to `$stdout`)
+    #
+    # @since 0.6.0
+    # @api private
+    def perform_registry(arguments)
+      result = registry.get(arguments)
+      return usage(result) unless result.found?
+
+      command, args = parse(result.command, result.arguments, result.names)
+
+      result.before_callbacks.run(command, args)
+      command.call(**args)
+      result.after_callbacks.run(command, args)
+    end
+
+    # Parse arguments for a command.
+    #
+    # It may exit in case of error, or in case of help.
+    #
+    # @param result [Dry::CLI::CommandRegistry::LookupResult]
+    # @param out [IO] sta output
+    #
+    # @return [Array<Dry:CLI::Command, Array>] returns an array where the
+    #   first element is a command and the second one is the list of arguments
+    #
+    # @since 0.6.0
+    # @api private
+    def parse(command, arguments, names)
+      prog_name = ProgramName.call(names)
+
+      result = Parser.call(command, arguments, prog_name)
+
+      return help(command, prog_name) if result.help?
+
+      return error(result) if result.error?
+
+      [build_command(command), result.arguments]
+    end
+
+    # @since 0.6.0
+    # @api private
+    def build_command(command)
+      command.is_a?(Class) ? command.new : command
+    end
+
+    # @since 0.6.0
+    # @api private
+    def help(command, prog_name)
+      out.puts Banner.call(command, prog_name)
+      exit(0) # Successful exit
+    end
+
+    # @since 0.6.0
+    # @api private
+    def error(result)
+      err.puts(result.error)
+      exit(1)
+    end
+
+    # @since 0.1.0
+    # @api private
+    def usage(result)
+      err.puts Usage.call(result)
+      exit(1)
+    end
+
+    # Handles Exit codes for signals
+    # Fatal error signal "n". Say 130 = 128 + 2 (SIGINT) or 137 = 128 + 9 (SIGKILL)
+    #
+    # @since 0.7.0
+    # @api private
+    def signal_exception(exception)
+      exit(128 + exception.signo)
+    end
+
+    # Check if command
+    #
+    # @param command [Object] the command to check
+    #
+    # @return [TrueClass,FalseClass] true if instance of `Dry::CLI::Command`
+    #
+    # @since 0.1.0
+    # @api private
+    #
+    # @see .command?
+    def command?(command)
+      CLI.command?(command)
+    end
+
+    # Generates registry in runtime
+    #
+    # @param &block [Block] configuration for the registry
+    #
+    # @return [Module] module extended with registry abilities and configured with a block
+    #
+    # @since 0.4.0
+    # @api private
+    def anonymous_registry(&block)
+      registry = Module.new { extend(Dry::CLI::Registry) }
+      if block.arity.zero?
+        registry.instance_eval(&block)
+      else
+        yield(registry)
+      end
+      registry
+    end
+  end
+
+  # Create a new instance
+  #
+  # @param registry_or_command [Dry::CLI::Registry, Dry::CLI::Command]
+  #   a registry or singular command
+  # @param &block [Block] a configuration block for registry
+  #
+  # @return [Dry::CLI] the new instance
+  # @since 0.4.0
+  def self.CLI(registry_or_command = nil, &block)
+    CLI.new(registry_or_command, &block)
+  end
+end

data/vendor/dry-cli/lib/dry/cli/banner.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "dry/cli/program_name"
+
+module Dry
+  class CLI
+    # Command banner
+    #
+    # @since 0.1.0
+    # @api private
+    module Banner
+      # Prints command banner
+      #
+      # @param command [Dry::CLI::Command] the command
+      # @param out [IO] standard output
+      #
+      # @since 0.1.0
+      # @api private
+      def self.call(command, name)
+        [
+          command_name(name),
+          command_name_and_arguments(command, name),
+          command_description(command),
+          command_subcommands(command),
+          command_arguments(command),
+          command_options(command),
+          command_examples(command, name)
+        ].compact.join("\n")
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.command_name(name)
+        "Command:\n  #{name}"
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.command_name_and_arguments(command, name)
+        usage = "\nUsage:\n  #{name}#{arguments(command)}"
+
+        return usage + " | #{name} SUBCOMMAND" if command.subcommands.any?
+
+        usage
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.command_examples(command, name)
+        return if command.examples.empty?
+
+        "\nExamples:\n#{command.examples.map { |example| "  #{name} #{example}" }.join("\n")}"
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.command_description(command)
+        return if command.description.nil?
+
+        "\nDescription:\n  #{command.description}"
+      end
+
+      def self.command_subcommands(command)
+        return if command.subcommands.empty?
+
+        "\nSubcommands:\n#{build_subcommands_list(command.subcommands)}"
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.command_arguments(command)
+        return if command.arguments.empty?
+
+        "\nArguments:\n#{extended_command_arguments(command)}"
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.command_options(command)
+        "\nOptions:\n#{extended_command_options(command)}"
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.arguments(command)
+        required_arguments = command.required_arguments
+        optional_arguments = command.optional_arguments
+
+        required = required_arguments.map { |arg| arg.name.upcase }.join(" ") if required_arguments.any? # rubocop:disable Metrics/LineLength
+        optional = optional_arguments.map { |arg| "[#{arg.name.upcase}]" }.join(" ") if optional_arguments.any? # rubocop:disable Metrics/LineLength
+        result = [required, optional].compact
+
+        " #{result.join(" ")}" unless result.empty?
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.extended_command_arguments(command)
+        command.arguments.map do |argument|
+          "  #{argument.name.to_s.upcase.ljust(32)}  # #{"REQUIRED " if argument.required?}#{argument.desc}" # rubocop:disable Metrics/LineLength
+        end.join("\n")
+      end
+
+      # @since 0.1.0
+      # @api private
+      #
+      def self.extended_command_options(command)
+        result = command.options.map do |option|
+          name = Inflector.dasherize(option.name)
+          name = if option.boolean?
+                   "[no-]#{name}"
+                 elsif option.array?
+                   "#{name}=VALUE1,VALUE2,.."
+                 else
+                   "#{name}=VALUE"
+                 end
+          name = "#{name}, #{option.alias_names.join(", ")}" if option.aliases.any?
+          name = "  --#{name.ljust(30)}"
+          name = "#{name}  # #{option.desc}"
+          name = "#{name}, default: #{option.default.inspect}" unless option.default.nil?
+          name
+        end
+
+        result << "  --#{"help, -h".ljust(30)}  # Print this help"
+        result.join("\n")
+      end
+
+      def self.build_subcommands_list(subcommands)
+        subcommands.map do |subcommand_name, subcommand|
+          "  #{subcommand_name.ljust(32)}  # #{subcommand.command.description}"
+        end.join("\n")
+      end
+    end
+  end
+end