rfix 1.4.0.pre.201 → 2.0.2

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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/vendor/dry-cli/lib/dry/cli/inflector.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Dry
+  class CLI
+    # @api private
+    # @since 0.5.0
+    module Inflector
+      # @api private
+      # @since 0.5.0
+      def self.dasherize(input)
+        return nil unless input
+
+        input.to_s.downcase.gsub(/[[[:space:]]_]/, "-")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "backports/2.5.0/module/define_method" if RUBY_VERSION < "2.5"
+
+module Dry
+  class CLI
+    require "dry/cli"
+    # Inline Syntax (aka DSL) to implement one-file applications
+    #
+    # `dry/cli/inline` is not required by default
+    # and explicit requirement of this file means that
+    # it is expected of abusing global namespace with
+    # methods below
+    #
+    # DSL consists of 5 methods:
+    # `desc`, `example`, `argument`, `option` 
+    # — are similar to methods from Command class
+    #
+    # `run` accepts a block to execute
+    #
+    # @example
+    #   require 'bundler/inline'
+    #   gemfile { gem 'dry/cli', require: 'dry/cli/inline' }
+    #
+    #   desc 'List files in a directory'
+    #   argument :path, required: false, desc: '[DIR]'
+    #   option :all, aliases: ['a'], type: :boolean
+    #
+    #   run do |path: '.', **options|
+    #     puts options.key?(:all) ? Dir.entries(path) : Dir.children(path)
+    #   end
+    #
+    #   # $ ls -a
+    #   # $ ls somepath
+    #   # $ ls somepath --all
+    # @since 0.6.0
+    module Inline
+      extend Forwardable
+
+      # AnonymousCommand
+      #
+      # @since 0.6.0
+      AnonymousCommand = Class.new(Dry::CLI::Command)
+
+      # @since 0.6.0
+      delegate %i[desc example argument option] => AnonymousCommand
+
+      # The rule of thumb for implementation of run block
+      # is that for every argument from your CLI
+      # you need to specify that as an mandatory argument for a block.
+      # Optional arguments have to have default value as ruby syntax expect them
+      #
+      # @example
+      #   argument :one
+      #   argument :two, required: false
+      #   option :three
+      #
+      #   run do |one:, two: 'default', **options|
+      #     puts one, two, options.inspect
+      #   end
+      #
+      # @since 0.6.0
+      def run(arguments: ARGV, out: $stdout)
+        command = AnonymousCommand
+        command.define_method(:call) do |**args|
+          yield(**args)
+        end
+
+        Dry.CLI(command).call(arguments: arguments, out: out)
+      end
+    end
+  end
+end
+
+include Dry::CLI::Inline # rubocop:disable Style/MixinUsage

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+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
+      #
+      def parser_options
+        dasherized_name = Inflector.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_names) if aliases.any?
+        parser_options << desc if desc
+        parser_options
+      end
+
+      # @since 0.1.0
+      # @api private
+      def alias_names
+        aliases
+          .map { |name| name.gsub(/^-{1,2}/, "") }
+          .compact
+          .uniq
+          .map { |name| name.size == 1 ? "-#{name}" : "--#{name}" }
+          .map { |name| boolean? ? name : "#{name} VALUE" }
+      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/vendor/dry-cli/lib/dry/cli/parser.rb

@@ -0,0 +1,138 @@
+# 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, prog_name)
+        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, prog_name, parsed_options)
+      rescue ::OptionParser::ParseError
+        Result.failure("ERROR: \"#{prog_name}\" was called with arguments \"#{original_arguments.join(" ")}\"") # rubocop:disable Metrics/LineLength
+      end
+
+      # @since 0.1.0
+      # @api private
+      #
+      # rubocop:disable Metrics/AbcSize
+      def self.parse_required_params(command, arguments, prog_name, 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: \"#{prog_name} #{command.required_arguments.map(&:description_name).join(" ")}" # rubocop:disable Metrics/LineLength
+
+          usage += " | #{prog_name} SUBCOMMAND" if command.subcommands.any?
+
+          usage += '"'
+
+          if parsed_required_params_values.empty?
+            return Result.failure("ERROR: \"#{prog_name}\" was called with no arguments#{usage}")
+          else
+            return Result.failure("ERROR: \"#{prog_name}\" 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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Dry
+  class CLI
+    # Program name
+    #
+    # @since 0.1.0
+    # @api private
+    module ProgramName
+      # @since 0.1.0
+      # @api private
+      SEPARATOR = " "
+
+      # @since 0.1.0
+      # @api private
+      def self.call(names = [], program_name: $PROGRAM_NAME)
+        [File.basename(program_name), names].flatten.join(SEPARATOR)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require "dry/cli/command_registry"
+
+module Dry
+  class CLI
+    # Registry mixin
+    #
+    # @since 0.1.0
+    module Registry
+      # @since 0.1.0
+      # @api private
+      def self.extended(base)
+        base.class_eval do
+          @_mutex = Mutex.new
+          @commands = CommandRegistry.new
+        end
+      end
+
+      # Register a command
+      #
+      # @param name [String] the command name
+      # @param command [NilClass,Dry::CLI::Command] the optional command
+      # @param aliases [Array<String>] an optional list of aliases
+      # @param options [Hash] a set of options
+      #
+      # @since 0.1.0
+      #
+      # @example Register a command
+      #   require "dry/cli"
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       class Hello < Dry::CLI::Command
+      #       end
+      #
+      #       register "hi", Hello
+      #     end
+      #   end
+      #
+      # @example Register a command with aliases
+      #   require "dry/cli"
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       class Hello < Dry::CLI::Command
+      #       end
+      #
+      #       register "hello", Hello, aliases: ["hi", "ciao"]
+      #     end
+      #   end
+      #
+      # @example Register a group of commands
+      #   require "dry/cli"
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       module Generate
+      #         class App < Dry::CLI::Command
+      #         end
+      #
+      #         class Action < Dry::CLI::Command
+      #         end
+      #       end
+      #
+      #       register "generate", aliases: ["g"] do |prefix|
+      #         prefix.register "app",    Generate::App
+      #         prefix.register "action", Generate::Action
+      #       end
+      #     end
+      #   end
+      def register(name, command = nil, aliases: [], &block)
+        @commands.set(name, command, aliases)
+
+        if block_given?
+          prefix = Prefix.new(@commands, name, aliases)
+          if block.arity.zero?
+            prefix.instance_eval(&block)
+          else
+            yield(prefix)
+          end
+        end
+      end
+
+      # Register a before callback.
+      #
+      # @param command_name [String] the name used for command registration
+      # @param callback [Class, #call] the callback object. If a class is given,
+      #   it MUST respond to `#call`.
+      # @param blk [Proc] the callback espressed as a block
+      #
+      # @raise [Dry::CLI::UnknownCommandError] if the command isn't registered
+      # @raise [Dry::CLI::InvalidCallbackError] if the given callback doesn't
+      #   implement the required interface
+      #
+      # @since 0.2.0
+      #
+      # @example
+      #   require "dry/cli"
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       class Hello < Dry::CLI::Command
+      #         def call(*)
+      #           puts "hello"
+      #         end
+      #       end
+      #
+      #       register "hello", Hello
+      #       before "hello", -> { puts "I'm about to say.." }
+      #     end
+      #   end
+      #
+      # @example Register an object as callback
+      #   require "dry/cli"
+      #
+      #   module Callbacks
+      #     class Hello
+      #       def call(*)
+      #         puts "world"
+      #       end
+      #     end
+      #   end
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       class Hello < Dry::CLI::Command
+      #         def call(*)
+      #           puts "I'm about to say.."
+      #         end
+      #       end
+      #
+      #       register "hello", Hello
+      #       before "hello", Callbacks::Hello.new
+      #     end
+      #   end
+      #
+      # @example Register a class as callback
+      #   require "dry/cli"
+      #
+      #   module Callbacks
+      #     class Hello
+      #       def call(*)
+      #         puts "world"
+      #       end
+      #     end
+      #   end
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       class Hello < Dry::CLI::Command
+      #         def call(*)
+      #           puts "I'm about to say.."
+      #         end
+      #       end
+      #
+      #       register "hello", Hello
+      #       before "hello", Callbacks::Hello
+      #     end
+      #   end
+      def before(command_name, callback = nil, &blk)
+        @_mutex.synchronize do
+          command(command_name).before_callbacks.append(&_callback(callback, blk))
+        end
+      end
+
+      # Register an after callback.
+      #
+      # @param command_name [String] the name used for command registration
+      # @param callback [Class, #call] the callback object. If a class is given,
+      #   it MUST respond to `#call`.
+      # @param blk [Proc] the callback espressed as a block
+      #
+      # @raise [Dry::CLI::UnknownCommandError] if the command isn't registered
+      # @raise [Dry::CLI::InvalidCallbackError] if the given callback doesn't
+      #   implement the required interface
+      #
+      # @since 0.2.0
+      #
+      # @example
+      #   require "dry/cli"
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       class Hello < Dry::CLI::Command
+      #         def call(*)
+      #           puts "hello"
+      #         end
+      #       end
+      #
+      #       register "hello", Hello
+      #       after "hello", -> { puts "world" }
+      #     end
+      #   end
+      #
+      # @example Register an object as callback
+      #   require "dry/cli"
+      #
+      #   module Callbacks
+      #     class World
+      #       def call(*)
+      #         puts "world"
+      #       end
+      #     end
+      #   end
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       class Hello < Dry::CLI::Command
+      #         def call(*)
+      #           puts "hello"
+      #         end
+      #       end
+      #
+      #       register "hello", Hello
+      #       after "hello", Callbacks::World.new
+      #     end
+      #   end
+      #
+      # @example Register a class as callback
+      #   require "dry/cli"
+      #
+      #   module Callbacks
+      #     class World
+      #       def call(*)
+      #         puts "world"
+      #       end
+      #     end
+      #   end
+      #
+      #   module Foo
+      #     module Commands
+      #       extend Dry::CLI::Registry
+      #
+      #       class Hello < Dry::CLI::Command
+      #         def call(*)
+      #           puts "hello"
+      #         end
+      #       end
+      #
+      #       register "hello", Hello
+      #       after "hello", Callbacks::World
+      #     end
+      #   end
+      def after(command_name, callback = nil, &blk)
+        @_mutex.synchronize do
+          command(command_name).after_callbacks.append(&_callback(callback, blk))
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def get(arguments)
+        @commands.get(arguments)
+      end
+
+      private
+
+      COMMAND_NAME_SEPARATOR = " "
+
+      # @since 0.2.0
+      # @api private
+      def command(command_name)
+        get(command_name.split(COMMAND_NAME_SEPARATOR)).tap do |result|
+          raise UnknownCommandError, command_name unless result.found?
+        end
+      end
+
+      # @since 0.2.0
+      # @api private
+      #
+      def _callback(callback, blk)
+        return blk if blk.respond_to?(:to_proc)
+
+        case callback
+        when ->(c) { c.respond_to?(:call) }
+          callback.method(:call)
+        when Class
+          begin
+            _callback(callback.new, blk)
+          rescue ArgumentError
+            raise InvalidCallbackError, callback
+          end
+        else
+          raise InvalidCallbackError, callback
+        end
+      end
+
+      # Command name prefix
+      #
+      # @since 0.1.0
+      class Prefix
+        # @since 0.1.0
+        # @api private
+        def initialize(registry, prefix, aliases)
+          @registry = registry
+          @prefix   = prefix
+
+          registry.set(prefix, nil, aliases)
+        end
+
+        # @since 0.1.0
+        #
+        # @see Dry::CLI::Registry#register
+        def register(name, command, aliases: [])
+          command_name = "#{prefix} #{name}"
+          registry.set(command_name, command, aliases)
+        end
+
+        private
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :registry
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :prefix
+      end
+    end
+  end
+end