rfix 1.4.1 → 2.0.0

data/vendor/dry-cli/README.md

@@ -0,0 +1,29 @@
+[gem]: https://rubygems.org/gems/dry-cli
+[actions]: https://github.com/dry-rb/dry-cli/actions
+[codacy]: https://www.codacy.com/gh/dry-rb/dry-cli
+[chat]: https://dry-rb.zulipchat.com
+[inchpages]: http://inch-ci.org/github/dry-rb/dry-cli
+
+# dry-cli [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
+
+[![Gem Version](https://badge.fury.io/rb/dry-cli.svg)][gem]
+[![CI Status](https://github.com/dry-rb/dry-cli/workflows/ci/badge.svg)][actions]
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/61dd5d070fc74f0cacf575b19d4930e1)][codacy]
+[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/61dd5d070fc74f0cacf575b19d4930e1)][codacy]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-cli.svg?branch=master)][inchpages]
+
+## Links
+
+* [User documentation](http://dry-rb.org/gems/dry-cli)
+* [API documentation](http://rubydoc.info/gems/dry-cli)
+
+## Supported Ruby versions
+
+This library officially supports the following Ruby versions:
+
+* MRI >= `2.5`
+* jruby >= `9.2`
+
+## License
+
+See `LICENSE` file.

data/vendor/dry-cli/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
+
+require "rspec/core"
+require "rspec/core/rake_task"
+
+task default: :spec
+
+desc "Run all specs in spec directory"
+RSpec::Core::RakeTask.new(:spec)

data/vendor/dry-cli/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "dry/cli"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/vendor/dry-cli/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/vendor/dry-cli/changelog.yml

@@ -0,0 +1,97 @@
+---
+- version: 0.6.0
+  date: '2020-03-06'
+  added:
+    - "[Ivan Shamatov] Ability to pass command along with registry (for a singular command case)"
+    - "[Nikita Shilnikov] [Internal] Backported ability to run gem's CI against ruby 2.3"
+    - "[Ivan Shamatov] Inline syntax for commands"
+    - "[Ivan Shamatov] Introduced stderr to any diagnostic output"
+  fixed:
+    - "[John Ledbetter & Luca Guidi] Fix ruby 2.7 warnings"
+    - "[Ivan Shamatov] Fix banner, when option is a type of Array"
+- version: 0.5.1
+  date: '2020-01-23'
+  added:
+    - "[Ivan Shamatov] Anonymous Registry sintax"
+    - "[Ivan Shamatov] [Internal] Specs refactored, more unit specs added"
+    - "[Luca Guidi] [Internal] removed `dry-inflector` as runtime dependency"
+    - "[Ivan Shamatov] [Internal] Refactored Command class (command_name property removed)"
+    - "[Piotr Solnica, Luca Guidi, Nikita Shilnikov & Christian Georgii] [Internal] Adapt gem to dry-rb style"
+  fixed:
+    - "[Piotr Solnica] Added missing 'set' require"
+- version: 0.5.0
+  date: '2019-12-21'
+  added:
+  - "[Ivan Shamatov, Piotr Solnica, Luca Guidi] [Internal] removed runtime and development
+    dependency against `hanami-utils`"
+- version: 0.4.0
+  date: '2019-12-10'
+  added:
+  - "[Ivan Shamatov, Piotr Solnica, Luca Guidi] `hanami-cli` => `dry-cli`"
+- version: 0.3.1
+  date: '2019-01-18'
+  added:
+  - "[Luca Guidi] Official support for Ruby: MRI 2.6"
+  - "[Luca Guidi] Support `bundler` 2.0+"
+- version: 0.3.0
+  date: '2018-10-24'
+- version: 0.3.0.beta1
+  date: '2018-08-08'
+  added:
+  - "[Anton Davydov & Alfonso Uceda] Introduce array type for arguments (`foo exec
+    test spec/bookshelf/entities spec/bookshelf/repositories`)"
+  - "[Anton Davydov & Alfonso Uceda] Introduce array type for options (`foo generate
+    config --apps=web,api`)"
+  - "[Alfonso Uceda] Introduce variadic arguments (`foo run ruby:latest -- ruby -v`)"
+  - "[Luca Guidi] Official support for JRuby 9.2.0.0"
+  fixed:
+  - '[Anton Davydov] Print informative message when unknown or wrong option is passed
+    (`"test" was called with arguments "--framework=unknown"`)'
+- version: 0.2.0
+  date: '2018-04-11'
+- version: 0.2.0.rc2
+  date: '2018-04-06'
+- version: 0.2.0.rc1
+  date: '2018-03-30'
+- version: 0.2.0.beta2
+  date: '2018-03-23'
+  added:
+  - "[Anton Davydov & Luca Guidi] Support objects as callbacks"
+  fixed:
+  - "[Anton Davydov & Luca Guidi] Ensure callbacks' context of execution (aka `self`)
+    to be the command that is being executed"
+- version: 0.2.0.beta1
+  date: '2018-02-28'
+  added:
+  - "[Anton Davydov] Register `before`/`after` callbacks for commands"
+- version: 0.1.1
+  date: '2018-02-27'
+  added:
+  - "[Luca Guidi] Official support for Ruby: MRI 2.5"
+  fixed:
+  - "[Alfonso Uceda] Ensure default values for arguments to be sent to commands"
+  - "[Alfonso Uceda] Ensure to fail when a missing required argument isn't provider,
+    but an option is provided instead"
+- version: 0.1.0
+  date: '2017-10-25'
+- version: 0.1.0.rc1
+  date: '2017-10-16'
+- version: 0.1.0.beta3
+  date: '2017-10-04'
+- version: 0.1.0.beta2
+  date: '2017-10-03'
+  added:
+  - " [Alfonso Uceda] Allow default value for arguments"
+- version: 0.1.0.beta1
+  date: '2017-08-11'
+  added:
+  - " [Alfonso Uceda, Luca Guidi] Commands banner and usage"
+  - " [Alfonso Uceda] Added support for subcommands"
+  - "[Alfonso Uceda] Validations for arguments and options"
+  - "[Alfonso Uceda] Commands arguments and options"
+  - "[Alfonso Uceda] Commands description"
+  - "[Alfonso Uceda, Oana Sipos] Commands aliases"
+  - "[Luca Guidi] Exit on unknown command"
+  - "[Luca Guidi, Alfonso Uceda, Oana Sipos] Command lookup"
+  - "[Luca Guidi, Tim Riley] Trie based registry to register commands and allow third-parties
+    to override/add commands"

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

@@ -0,0 +1,57 @@
+---
+title: Arguments
+layout: gem-single
+name: dry-cli
+---
+
+An argument is a token passed after the _command name_.
+For instance, given the `foo greet` command, when an user types `foo greet Luca`, then `Luca` is considered an argument.
+A command can accept none or many arguments.
+An argument can be declared as _required_.
+
+```ruby
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "dry/cli"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      class Greet < Dry::CLI::Command
+        argument :name, required: true, desc: "The name of the person to greet"
+        argument :age, desc: "The age of the person to greet"
+
+        def call(name:, age: nil, **)
+          result = "Hello, #{name}."
+          result = "#{result} You are #{age} years old." unless age.nil?
+
+          puts result
+        end
+      end
+
+      register "greet", Greet
+    end
+  end
+end
+
+Dry::CLI.new(Foo::CLI::Commands).call
+```
+
+```sh
+$ foo greet Luca
+Hello, Luca.
+```
+
+```sh
+$ foo greet Luca 35
+Hello, Luca. You are 35 years old.
+```
+
+```sh
+$ foo greet
+ERROR: "foo greet" was called with no arguments
+Usage: "foo greet NAME"
+```
+

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

@@ -0,0 +1,51 @@
+---
+title: Callbacks
+layout: gem-single
+name: dry-cli
+---
+
+Third party gems can register _before_ and _after_ callbacks to enhance a command.
+
+### Example
+
+From the `foo` gem we have a command `hello`.
+
+```ruby
+#!/usr/bin/env ruby
+require "dry/cli"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      class Hello < Dry::CLI::Command
+        argument :name, required: true
+
+        def call(name:, **)
+          puts "hello #{name}"
+        end
+      end
+    end
+  end
+end
+
+Foo::CLI::Commands.register "hello", Foo::CLI::Commands::Hello
+
+cli = Dry::CLI.new(Foo::CLI::Commands)
+cli.call
+```
+
+The `foo-bar` gem enhances `hello` command with callbacks:
+
+```ruby
+Foo::CLI::Commands.before("hello") { |args| puts "debug: #{args.inspect}" } # syntax 1
+Foo::CLI::Commands.after "hello", &->(args) { puts "bye, #{args.fetch(:name)}" } # syntax 2
+```
+
+```sh
+$ foo hello Anton
+debug: {:name=>"Anton"}
+hello Anton
+bye, Anton
+```

data/vendor/dry-cli/docsite/source/commands-with-subcommands-and-params.md

@@ -0,0 +1,86 @@
+---
+title: Commands with subcommands and params
+layout: gem-single
+name: dry-cli
+---
+
+There is a way to register command with arguments, options and subcommands.
+
+This helps to implement complex nested logic.
+
+Arguments and options can be defined for parent both commands and child commands.
+
+^INFO
+If you call a command with an argument equal to the name of the subcommand, it will call the subcommand instead of the parent command.
+^
+```ruby
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "dry/cli"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      class Account < Dry::CLI::Command
+        desc 'Information about account'
+
+        argument :format, default: "short", values: %w[long short], desc: "Output format"
+
+        def call(**options)
+          puts "Information about account in #{options.fetch(:format)} format."
+        end
+
+        class Users < Dry::CLI::Command
+          desc 'Information about account users'
+
+          def call(**_options)
+            puts "Information about account users."
+          end
+        end
+      end
+
+      register "account", Account
+      register "account users", Account::Users
+    end
+  end
+end
+
+Dry::CLI.new(Foo::CLI::Commands).call
+```
+```
+$ foo account -h
+Command:
+  foo account
+
+Usage:
+  foo account [FORMAT] | foo account SUBCOMMAND
+
+Description:
+  Information about account
+
+Subcommands:
+  users                           # Information about account users
+
+Arguments:
+  FORMAT                # Output format: (long/short)
+
+Options:
+  --help, -h                        # Print this help
+```
+```sh
+$ foo account
+# Information about account in short format.
+```
+
+```sh
+$ foo account long
+# Information about account in long format.
+```
+
+```sh
+$ foo account users
+# Information about account users.
+```
+

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

@@ -0,0 +1,41 @@
+---
+title: Commands
+layout: gem-single
+name: dry-cli
+---
+
+A command is a subclass of `Dry::CLI::Command` and it **must** respond to `#call(*)`.
+
+For a given _command name_, you can register a corresponding _command_.
+
+**Please note:** there is **no** convention between the _command name_ and the _command object_ class name.
+The manual _registration_ assigns a _command object_ to a _command name_.
+
+```ruby
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "dry/cli"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      class Hello < Dry::CLI::Command
+        def call(*)
+        end
+      end
+    end
+  end
+end
+
+class Version < Dry::CLI::Command
+  def call(*)
+  end
+end
+
+Foo::CLI::Commands.register "hi", Foo::CLI::Commands::Hello
+Foo::CLI::Commands.register "v",  Version
+
+Dry::CLI.new(Foo::CLI::Commands).call
+```

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

@@ -0,0 +1,302 @@
+---
+title: Introduction
+description: General purpose Command Line Interface (CLI) framework
+layout: gem-single
+type: gem
+name: dry-cli
+sections:
+  - commands
+  - subcommands
+  - arguments
+  - options
+  - variadic-arguments
+  - commands-with-subcommands-and-params
+  - callbacks
+---
+
+`dry-cli` is a general-purpose framework for developing Command Line Interface (CLI) applications. It represents commands as objects that can be registered and offers support for arguments, options and forwarding variadic arguments to a sub-command.
+
+## Usage
+
+The following is an elaborate example showcasing most of the available features.
+
+Imagine you want to build a CLI executable `foo` for your Ruby project. The entire program is defined as below:
+
+```ruby
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "dry/cli"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      class Version < Dry::CLI::Command
+        desc "Print version"
+
+        def call(*)
+          puts "1.0.0"
+        end
+      end
+
+      class Echo < Dry::CLI::Command
+        desc "Print input"
+
+        argument :input, desc: "Input to print"
+
+        example [
+          "             # Prints 'wuh?'",
+          "hello, folks # Prints 'hello, folks'"
+        ]
+
+        def call(input: nil, **)
+          if input.nil?
+            puts "wuh?"
+          else
+            puts input
+          end
+        end
+      end
+
+      class Start < Dry::CLI::Command
+        desc "Start Foo machinery"
+
+        argument :root, required: true, desc: "Root directory"
+
+        example [
+          "path/to/root # Start Foo at root directory"
+        ]
+
+        def call(root:, **)
+          puts "started - root: #{root}"
+        end
+      end
+
+      class Stop < Dry::CLI::Command
+        desc "Stop Foo machinery"
+
+        option :graceful, type: :boolean, default: true, desc: "Graceful stop"
+
+        def call(**options)
+          puts "stopped - graceful: #{options.fetch(:graceful)}"
+        end
+      end
+
+      class Exec < Dry::CLI::Command
+        desc "Execute a task"
+
+        argument :task, type: :string, required: true,  desc: "Task to be executed"
+        argument :dirs, type: :array,  required: false, desc: "Optional directories"
+
+        def call(task:, dirs: [], **)
+          puts "exec - task: #{task}, dirs: #{dirs.inspect}"
+        end
+      end
+
+      module Generate
+        class Configuration < Dry::CLI::Command
+          desc "Generate configuration"
+
+          option :apps, type: :array, default: [], desc: "Generate configuration for specific apps"
+
+          def call(apps:, **)
+            puts "generated configuration for apps: #{apps.inspect}"
+          end
+        end
+
+        class Test < Dry::CLI::Command
+          desc "Generate tests"
+
+          option :framework, default: "minitest", values: %w[minitest rspec]
+
+          def call(framework:, **)
+            puts "generated tests - framework: #{framework}"
+          end
+        end
+      end
+
+      register "version", Version, aliases: ["v", "-v", "--version"]
+      register "echo",    Echo
+      register "start",   Start
+      register "stop",    Stop
+      register "exec",    Exec
+
+      register "generate", aliases: ["g"] do |prefix|
+        prefix.register "config", Generate::Configuration
+        prefix.register "test",   Generate::Test
+      end
+    end
+  end
+end
+
+Dry::CLI.new(Foo::CLI::Commands).call
+```
+
+### Available commands
+
+With this code in place, we can now have a look at the command line usage by issuing the command `foo` without any arguments or options:
+
+```sh
+$ foo
+Commands:
+  foo echo [INPUT]                       # Print input
+  foo exec TASK [DIRS]                   # Execute a task
+  foo generate [SUBCOMMAND]
+  foo start ROOT                         # Start Foo machinery
+  foo stop                               # Stop Foo machinery
+  foo version                            # Print version
+```
+
+### Help
+
+It is also possible to get help for a particular command using the `--help` flag:
+
+```sh
+$ foo echo --help
+Command:
+  foo echo
+
+Usage:
+  foo echo [INPUT]
+
+Description:
+  Print input
+
+Arguments:
+  INPUT                 # Input to print
+
+Options:
+  --help, -h                        # Print this help
+
+Examples:
+  foo echo              # Prints 'wuh?'
+  foo echo hello, folks # Prints 'hello, folks'
+```
+
+### Optional arguments
+
+A command can have optional arguments, which enables a default action in case nothing is provided:
+
+```sh
+$ foo echo
+wuh?
+
+$ foo echo hello
+hello
+```
+
+### Required arguments
+
+On the other hand, required arguments will throw an error if not provided:
+
+```sh
+$ foo start .
+started - root: .
+```
+
+```sh
+$ foo start
+ERROR: "foo start" was called with no arguments
+Usage: "foo start ROOT"
+```
+
+### Array arguments
+
+Captures all the remaining arguments in a single array.
+Please note that `array` argument must be used as the last argument, as it works as a _"catch-all"_.
+
+```sh
+$ foo exec test
+exec - task: test, dirs: []
+```
+
+```sh
+$ foo exec test spec/bookshelf/entities spec/bookshelf/repositories
+exec - task: test, dirs: ["spec/bookshelf/entities", "spec/bookshelf/repositories"]
+```
+
+### Options
+
+An option is a named argument that is passed after the command name and the arguments:
+
+```sh
+$ foo generate test
+generated tests - framework: minitest
+```
+
+```sh
+$ foo generate test --framework=rspec
+generated tests - framework: rspec
+```
+
+```sh
+$ foo generate test --framework=unknown
+ERROR: "foo generate test" was called with arguments "--framework=unknown"
+```
+
+### Boolean options
+
+Boolean options are flags that change the behaviour of a command:
+
+```sh
+$ foo stop
+stopped - graceful: true
+```
+
+```sh
+$ foo stop --no-graceful
+stopped - graceful: false
+```
+
+### Array options
+
+Array options are similar to arguments but must be named:
+
+```sh
+$ foo generate config --apps=web,api
+generated configuration for apps: ["web", "api"]
+```
+
+### Subcommands
+
+Subcommands are simply commands that have been registered under a nested path:
+
+```sh
+$ foo generate
+Commands:
+  foo generate config           # Generate configuration
+  foo generate test             # Generate tests
+```
+
+### Aliases
+
+Aliases are supported:
+
+```sh
+$ foo version
+1.0.0
+```
+
+```sh
+$ foo v
+1.0.0
+```
+
+```sh
+$ foo -v
+1.0.0
+```
+
+```sh
+$ foo --version
+1.0.0
+```
+
+### Subcommand aliases
+
+Work similarly to command aliases
+```sh
+$ foo g config
+generated configuration for apps: []
+```