rfix 1.4.1 → 2.0.0

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

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "dry/cli/option"
+
+module Dry
+  class CLI
+    # Base class for commands
+    #
+    # @since 0.1.0
+    class Command
+      # @since 0.1.0
+      # @api private
+      def self.inherited(base)
+        super
+        base.class_eval do
+          @_mutex       = Mutex.new
+          @description  = nil
+          @examples     = []
+          @subcommands  = []
+          @arguments = base.superclass_arguments || []
+          @options = base.superclass_options || []
+        end
+        base.extend ClassMethods
+      end
+
+      # @since 0.1.0
+      # @api private
+      module ClassMethods
+        # @since 0.1.0
+        # @api private
+        attr_reader :description
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :examples
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :arguments
+
+        # @since 0.1.0
+        # @api private
+        attr_reader :options
+
+        # @since x.x.x
+        # @api private
+        attr_accessor :subcommands
+
+        # @since x.x.x
+        # @api private
+      end
+
+      # Set the description of the command
+      #
+      # @param description [String] the description
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require "dry/cli"
+      #
+      #   class Echo < Dry::CLI::Command
+      #     desc "Prints given input"
+      #
+      #     def call(*)
+      #       # ...
+      #     end
+      #   end
+      def self.desc(description)
+        @description = description
+      end
+
+      # Describe the usage of the command
+      #
+      # @param examples [Array<String>] one or more examples
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require "dry/cli"
+      #
+      #   class Server < Dry::CLI::Command
+      #     example [
+      #       "                    # Basic usage (it uses the bundled server engine)",
+      #       "--server=webrick    # Force `webrick` server engine",
+      #       "--host=0.0.0.0      # Bind to a host",
+      #       "--port=2306         # Bind to a port",
+      #       "--no-code-reloading # Disable code reloading"
+      #     ]
+      #
+      #     def call(*)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # $ foo server --help
+      #   #   # ...
+      #   #
+      #   #   Examples:
+      #   #     foo server                     # Basic usage (it uses the bundled server engine)
+      #   #     foo server --server=webrick    # Force `webrick` server engine
+      #   #     foo server --host=0.0.0.0      # Bind to a host
+      #   #     foo server --port=2306         # Bind to a port
+      #   #     foo server --no-code-reloading # Disable code reloading
+      def self.example(*examples)
+        @examples += examples.flatten(1)
+      end
+
+      # Specify an argument
+      #
+      # @param name [Symbol] the argument name
+      # @param options [Hash] a set of options
+      #
+      # @since 0.1.0
+      #
+      # @example Optional argument
+      #   require "dry/cli"
+      #
+      #   class Hello < Dry::CLI::Command
+      #     argument :name
+      #
+      #     def call(name: nil, **)
+      #       if name.nil?
+      #         puts "Hello, stranger"
+      #       else
+      #         puts "Hello, #{name}"
+      #       end
+      #     end
+      #   end
+      #
+      #   # $ foo hello
+      #   #   Hello, stranger
+      #
+      #   # $ foo hello Luca
+      #   #   Hello, Luca
+      #
+      # @example Required argument
+      #   require "dry/cli"
+      #
+      #   class Hello < Dry::CLI::Command
+      #     argument :name, required: true
+      #
+      #     def call(name:, **)
+      #       puts "Hello, #{name}"
+      #     end
+      #   end
+      #
+      #   # $ foo hello Luca
+      #   #   Hello, Luca
+      #
+      #   # $ foo hello
+      #   #   ERROR: "foo hello" was called with no arguments
+      #   #   Usage: "foo hello NAME"
+      #
+      # @example Multiple arguments
+      #   require "dry/cli"
+      #
+      #   module Generate
+      #     class Action < Dry::CLI::Command
+      #       argument :app,    required: true
+      #       argument :action, required: true
+      #
+      #       def call(app:, action:, **)
+      #         puts "Generating action: #{action} for app: #{app}"
+      #       end
+      #     end
+      #   end
+      #
+      #   # $ foo generate action web home
+      #   #   Generating action: home for app: web
+      #
+      #   # $ foo generate action
+      #   #   ERROR: "foo generate action" was called with no arguments
+      #   #   Usage: "foo generate action APP ACTION"
+      #
+      # @example Description
+      #   require "dry/cli"
+      #
+      #   class Hello < Dry::CLI::Command
+      #     argument :name, desc: "The name of the person to greet"
+      #
+      #     def call(name: nil, **)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # $ foo hello --help
+      #   #   Command:
+      #   #     foo hello
+      #   #
+      #   #   Usage:
+      #   #     foo hello [NAME]
+      #   #
+      #   #   Arguments:
+      #   #     NAME                # The name of the person to greet
+      #   #
+      #   #   Options:
+      #   #     --help, -h          # Print this help
+      def self.argument(name, options = {})
+        @arguments << Argument.new(name, options)
+      end
+
+      # Command line option (aka optional argument)
+      #
+      # @param name [Symbol] the param name
+      # @param options [Hash] a set of options
+      #
+      # @since 0.1.0
+      #
+      # @example Basic usage
+      #   require "dry/cli"
+      #
+      #   class Console < Dry::CLI::Command
+      #     param :engine
+      #
+      #     def call(engine: nil, **)
+      #       puts "starting console (engine: #{engine || :irb})"
+      #     end
+      #   end
+      #
+      #   # $ foo console
+      #   # starting console (engine: irb)
+      #
+      #   # $ foo console --engine=pry
+      #   # starting console (engine: pry)
+      #
+      # @example List values
+      #   require "dry/cli"
+      #
+      #   class Console < Dry::CLI::Command
+      #     param :engine, values: %w(irb pry ripl)
+      #
+      #     def call(engine: nil, **)
+      #       puts "starting console (engine: #{engine || :irb})"
+      #     end
+      #   end
+      #
+      #   # $ foo console
+      #   # starting console (engine: irb)
+      #
+      #   # $ foo console --engine=pry
+      #   # starting console (engine: pry)
+      #
+      #   # $ foo console --engine=foo
+      #   # ERROR: Invalid param provided
+      #
+      # @example Description
+      #   require "dry/cli"
+      #
+      #   class Console < Dry::CLI::Command
+      #     param :engine, desc: "Force a console engine"
+      #
+      #     def call(engine: nil, **)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # $ foo console --help
+      #   # # ...
+      #   #
+      #   # Options:
+      #   #   --engine=VALUE                  # Force a console engine: (irb/pry/ripl)
+      #   #   --help, -h                      # Print this help
+      #
+      # @example Boolean
+      #   require "dry/cli"
+      #
+      #   class Server < Dry::CLI::Command
+      #     param :code_reloading, type: :boolean, default: true
+      #
+      #     def call(code_reloading:, **)
+      #       puts "staring server (code reloading: #{code_reloading})"
+      #     end
+      #   end
+      #
+      #   # $ foo server
+      #   # starting server (code reloading: true)
+      #
+      #   # $ foo server --no-code-reloading
+      #   # starting server (code reloading: false)
+      #
+      #   # $ foo server --help
+      #   # # ...
+      #   #
+      #   # Options:
+      #   #   --[no]-code-reloading
+      #
+      # @example Aliases
+      #   require "dry/cli"
+      #
+      #   class Server < Dry::CLI::Command
+      #     param :port, aliases: ["-p"]
+      #
+      #     def call(options)
+      #       puts "staring server (port: #{options.fetch(:port, 2300)})"
+      #     end
+      #   end
+      #
+      #   # $ foo server
+      #   # starting server (port: 2300)
+      #
+      #   # $ foo server --port=2306
+      #   # starting server (port: 2306)
+      #
+      #   # $ foo server -p 2306
+      #   # starting server (port: 2306)
+      #
+      #   # $ foo server --help
+      #   # # ...
+      #   #
+      #   # Options:
+      #   #   --port=VALUE, -p VALUE
+      def self.option(name, options = {})
+        @options << Option.new(name, options)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.params
+        @_mutex.synchronize do
+          (@arguments + @options).uniq
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.default_params
+        params.each_with_object({}) do |param, result|
+          result[param.name] = param.default unless param.default.nil?
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.required_arguments
+        arguments.select(&:required?)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.optional_arguments
+        arguments.reject(&:required?)
+      end
+
+      # @since x.x.x
+      # @api private
+      def self.subcommands
+        subcommands
+      end
+
+      # @since 0.7.0
+      # @api private
+      def self.superclass_variable_dup(var)
+        if superclass.instance_variable_defined?(var)
+          superclass.instance_variable_get(var).dup
+        end
+      end
+
+      # @since 0.7.0
+      # @api private
+      def self.superclass_arguments
+        superclass_variable_dup(:@arguments)
+      end
+
+      # @since 0.7.0
+      # @api private
+      def self.superclass_options
+        superclass_variable_dup(:@options)
+      end
+
+      extend Forwardable
+
+      delegate %i[
+        description
+        examples
+        arguments
+        options
+        params
+        default_params
+        required_arguments
+        optional_arguments
+        subcommands
+      ] => "self.class"
+    end
+  end
+end

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

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Dry
+  class CLI
+    # Command registry
+    #
+    # @since 0.1.0
+    # @api private
+    class CommandRegistry
+      # @since 0.1.0
+      # @api private
+      def initialize
+        @_mutex = Mutex.new
+        @root = Node.new
+      end
+
+      # @since 0.1.0
+      # @api private
+      def set(name, command, aliases)
+        @_mutex.synchronize do
+          node = @root
+          name.split(/[[:space:]]/).each do |token|
+            node = node.put(node, token)
+          end
+
+          node.aliases!(aliases)
+          if command
+            node.leaf!(command)
+            node.subcommands!(command)
+          end
+
+          nil
+        end
+      end
+
+      # @since 0.1.0
+      # @api private
+      #
+      def get(arguments)
+        @_mutex.synchronize do
+          node   = @root
+          args   = []
+          names  = []
+          valid_leaf = nil
+          result = LookupResult.new(node, args, names, node.leaf?)
+
+          arguments.each_with_index do |token, i|
+            tmp = node.lookup(token)
+
+            if tmp.nil? && valid_leaf
+              result = valid_leaf
+              break
+            elsif 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)
+              valid_leaf = result
+              break unless tmp.children?
+            else
+              names  = arguments[0..i]
+              node   = tmp
+              result = LookupResult.new(node, args, names, node.leaf?)
+            end
+          end
+
+          result
+        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 = {}
+          @aliases  = {}
+          @command  = nil
+
+          @before_callbacks = Chain.new
+          @after_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 x.x.x
+        # @api private
+        def subcommands!(command)
+          command_class = command.is_a?(Class) ? command : command.class
+          command_class.subcommands = children
+        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
+
+        # @since x.x.x
+        # @api private
+        def children?
+          children.any?
+        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
+
+      # Callbacks chain
+      #
+      # @since 0.4.0
+      # @api private
+      class Chain
+        # @since 0.4.0
+        # @api private
+        attr_reader :chain
+
+        # @since 0.4.0
+        # @api private
+        def initialize
+          @chain = Set.new
+        end
+
+        # @since 0.4.0
+        # @api private
+        def append(&callback)
+          chain.add(callback)
+        end
+
+        # @since 0.4.0
+        # @api private
+        def run(context, *args)
+          chain.each do |callback|
+            context.instance_exec(*args, &callback)
+          end
+        end
+      end
+    end
+  end
+end