rfix 1.4.1 → 2.0.0

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "dry/cli/program_name"
+
+module Dry
+  class CLI
+    # Command(s) usage
+    #
+    # @since 0.1.0
+    # @api private
+    module Usage
+      # @since 0.1.0
+      # @api private
+      SUBCOMMAND_BANNER = " [SUBCOMMAND]"
+      ROOT_COMMAND_WITH_SUBCOMMANDS_BANNER = " [ARGUMENT|SUBCOMMAND]"
+
+      # @since 0.1.0
+      # @api private
+      def self.call(result)
+        header = "Commands:"
+        max_length, commands = commands_and_arguments(result)
+
+        commands.map do |banner, node|
+          usage = description(node.command) if node.leaf?
+          "#{justify(banner, max_length, usage)}#{usage}"
+        end.unshift(header).join("\n")
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.commands_and_arguments(result)
+        max_length = 0
+        ret        = commands(result).each_with_object({}) do |(name, node), memo|
+          args = if node.command && node.leaf? && node.children?
+                   ROOT_COMMAND_WITH_SUBCOMMANDS_BANNER
+                 elsif node.leaf?
+                   arguments(node.command)
+                 else
+                   SUBCOMMAND_BANNER
+                 end
+
+          partial       = "  #{command_name(result, name)}#{args}"
+          max_length    = partial.bytesize if max_length < partial.bytesize
+          memo[partial] = node
+        end
+
+        [max_length, ret]
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.arguments(command)
+        return unless CLI.command?(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.description(command)
+        return unless CLI.command?(command)
+
+        " # #{command.description}" unless command.description.nil?
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.justify(string, padding, usage)
+        return string.chomp(" ") if usage.nil?
+
+        string.ljust(padding + padding / 2)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.commands(result)
+        result.children.sort_by { |name, _| name }
+      end
+
+      # @since 0.1.0
+      # @api private
+      def self.command_name(result, name)
+        ProgramName.call([result.names, name])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Dry
+  class CLI
+    # @since 0.1.0
+    VERSION = "0.6.0"
+  end
+end

data/vendor/dry-cli/project.yml

@@ -0,0 +1,13 @@
+name: dry-cli
+codacy_id: 61dd5d070fc74f0cacf575b19d4930e1
+gemspec:
+  authors: ["Luca Guidi"]
+  email: ["me@lucaguidi.com"]
+  summary: "Common framework to build command line interfaces with Ruby"
+  required_ruby_version: ">= 2.4.0"
+  development_dependencies:
+    - [bundler, ">= 1.6", "< 3"]
+    - [rake, "~> 13.0"]
+    - [rspec, "~> 3.7"]
+    - [simplecov, "~> 0.17.1"]
+    - [rubocop, "~> 0.82"]

data/vendor/dry-cli/spec/integration/commands_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe "Commands" do
+  context "with extra params" do
+    context "when there is a required argument" do
+      context "and there are options" do
+        it "parses both separately" do
+          output = `foo variadic with-mandatory-and-options uno -- due tre --blah`
+          expect(output).to eq("first: uno\nurl: \nmethod: \nUnused Arguments: due, tre, --blah\n")
+        end
+      end
+    end
+  end
+end

data/vendor/dry-cli/spec/integration/inherited_commands_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe "Inherited commands" do
+  context "when --help flag" do
+    it "subclass do not" do
+      output = `based --help 2>&1`
+      expected = <<~OUT
+        Commands:
+          based addons APP                # Lists your add-ons and attachments
+          based logs APP                  # Display recent log output
+          based run APP CMD               # Run a one-off process inside your app
+          based subrun APP CMD
+      OUT
+      expect(output).to eq(expected)
+    end
+  end
+
+  it "works for subclasses" do
+    output = `based subrun application_name command_to_run`
+    expect(output).to eq(
+      "Run - App: application_name - Command: command_to_run - Options: {:verbosity=>\"INFO\"}\n"
+    )
+  end
+end

data/vendor/dry-cli/spec/integration/inline_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "open3"
+
+RSpec.describe "Inline" do
+  context "with command" do
+    let(:cmd) { "inline" }
+
+    it "shows help" do
+      output = `inline -h`
+      expected_output = <<~OUTPUT
+        Command:
+          inline
+
+        Usage:
+          inline MANDATORY_ARG [OPTIONAL_ARG]
+
+        Description:
+          Baz command line interface
+
+        Arguments:
+          MANDATORY_ARG                     # REQUIRED Mandatory argument
+          OPTIONAL_ARG                      # Optional argument (has to have default value in call method)
+
+        Options:
+          --option-one=VALUE, -1 VALUE      # Option one
+          --[no-]boolean-option, -b         # Option boolean
+          --option-with-default=VALUE, -d VALUE  # Option default, default: "test"
+          --help, -h                        # Print this help
+      OUTPUT
+      expect(output).to eq(expected_output)
+    end
+
+    it "with underscored option_one" do
+      output = `inline first_arg -1 test2 -bd test3`
+      expect(output).to eq(
+        "mandatory_arg: first_arg. optional_arg: optional_arg. " \
+        'Options: {:option_with_default=>"test3", :option_one=>"test2", :boolean_option=>true}' \
+        "\n"
+      )
+    end
+  end
+end

data/vendor/dry-cli/spec/integration/processes_errors_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.describe "Processes Errors" do
+  context "when SignalException" do
+    it "returns correct statuscode" do
+      pid1, pid2, pid15 = Array.new(3).map { Process.spawn("foo generate app SomeAppName") }
+      sleep 0.5 # time to start app
+
+      Process.kill("HUP", pid1)
+      Process.kill("INT", pid2)
+      Process.kill("TERM", pid15)
+
+      _, status1 = Process.wait2(pid1)
+      _, status2 = Process.wait2(pid2)
+      _, status15 = Process.wait2(pid15)
+
+      expect(status1.exitstatus).to eq(129)
+      expect(status2.exitstatus).to eq(130)
+      expect(status15.exitstatus).to eq(143)
+    end
+  end
+
+  context "when Pipe Exception" do
+    it "handles EPIPE without stacktrace" do
+      output = `infinites writer | head -n 3`
+      expect(output).to eq("0\n1\n2\n")
+    end
+  end
+end

data/vendor/dry-cli/spec/integration/rendering_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "open3"
+
+RSpec.describe "Rendering" do
+  it "prints available commands for unknown command" do
+    _, stderr, = Open3.capture3("foo unknown")
+
+    expected = <<~DESC
+      Commands:
+        foo assets [SUBCOMMAND]
+        foo callbacks DIR                                          # Command with callbacks
+        foo console                                                # Starts Foo console
+        foo db [SUBCOMMAND]
+        foo destroy [SUBCOMMAND]
+        foo exec TASK [DIRS]                                       # Execute a task
+        foo generate [SUBCOMMAND]
+        foo greeting [RESPONSE]
+        foo hello                                                  # Print a greeting
+        foo new PROJECT                                            # Generate a new Foo project
+        foo root-command [ARGUMENT|SUBCOMMAND]                     # Root command with arguments and subcommands
+        foo routes                                                 # Print routes
+        foo server                                                 # Start Foo server (only for development)
+        foo sub [SUBCOMMAND]
+        foo variadic [SUBCOMMAND]
+        foo version                                                # Print Foo version
+    DESC
+
+    expect(stderr).to eq(expected)
+  end
+end

data/vendor/dry-cli/spec/integration/single_command_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "open3"
+
+RSpec.describe "Single command" do
+  context "with command" do
+    let(:cmd) { "baz" }
+
+    it "shows usage" do
+      _, stderr, = Open3.capture3("baz")
+      expect(stderr).to eq(
+        "ERROR: \"#{cmd}\" was called with no arguments\nUsage: \"#{cmd} MANDATORY_ARG\"\n"
+      )
+    end
+
+    it "shows help" do
+      output = `baz -h`
+      expected_output = <<~OUTPUT
+        Command:
+          #{cmd}
+
+        Usage:
+          #{cmd} MANDATORY_ARG [OPTIONAL_ARG]
+
+        Description:
+          Baz command line interface
+
+        Arguments:
+          MANDATORY_ARG                     # REQUIRED Mandatory argument
+          OPTIONAL_ARG                      # Optional argument (has to have default value in call method)
+
+        Options:
+          --option-one=VALUE, -1 VALUE      # Option one
+          --[no-]boolean-option, -b         # Option boolean
+          --option-with-default=VALUE, -d VALUE  # Option default, default: "test"
+          --help, -h                        # Print this help
+      OUTPUT
+      expect(output).to eq(expected_output)
+    end
+
+    it "with option_one" do
+      output = `baz first_arg --option-one=test2`
+      expect(output).to eq(
+        "mandatory_arg: first_arg. optional_arg: optional_arg. " \
+        "Options: {:option_with_default=>\"test\", :option_one=>\"test2\"}\n"
+      )
+    end
+
+    it "with combination of aliases" do
+      output = `baz first_arg -bd test3`
+      expect(output).to eq(
+        "mandatory_arg: first_arg. optional_arg: optional_arg. " \
+        "Options: {:option_with_default=>\"test3\", :boolean_option=>true}\n"
+      )
+    end
+  end
+
+  context "root command with arguments and subcommands" do
+    it "with arguments" do
+      output = `foo root-command "hello world"`
+
+      expected = <<~DESC
+        I'm a root-command argument:hello world
+        I'm a root-command option:
+      DESC
+
+      expect(output).to eq(expected)
+    end
+
+    it "with options" do
+      output = `foo root-command "hello world" --root-command-option="bye world"`
+
+      expected = <<~DESC
+        I'm a root-command argument:hello world
+        I'm a root-command option:bye world
+      DESC
+
+      expect(output).to eq(expected)
+    end
+  end
+end

data/vendor/dry-cli/spec/integration/subcommands_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "open3"
+
+RSpec.describe "Subcommands" do
+  context "works with params" do
+    it "with help param" do
+      output = `foo generate model --help`
+
+      expected = <<~DESC
+        Command:
+          foo generate model
+
+        Usage:
+          foo generate model MODEL
+
+        Description:
+          Generate a model
+
+        Arguments:
+          MODEL                             # REQUIRED Model name (eg. `user`)
+
+        Options:
+          --[no-]skip-migration             # Skip migration, default: false
+          --help, -h                        # Print this help
+
+        Examples:
+          foo generate model user                  # Generate `User` entity, `UserRepository` repository, and the migration
+          foo generate model user --skip-migration # Generate `User` entity and `UserRepository` repository
+      DESC
+
+      expect(output).to eq(expected)
+    end
+  end
+
+  context "works with root command subcommands" do
+    it "with params" do
+      output = `foo root-command sub-command "hello world"`
+
+      expected = <<~DESC
+        I'm a root-command sub-command argument:hello world
+        I'm a root-command sub-command option:
+      DESC
+
+      expect(output).to eq(expected)
+    end
+
+    it "with options" do
+      option = '--root-command-sub-command-option="bye world"'
+      output = `foo root-command sub-command "hello world" #{option}`
+
+      expected = <<~DESC
+        I'm a root-command sub-command argument:hello world
+        I'm a root-command sub-command option:bye world
+      DESC
+
+      expect(output).to eq(expected)
+    end
+  end
+end

data/vendor/dry-cli/spec/integration/third_party_gems_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.describe "Third-party gems" do
+  it "allows to add callbacks as a block" do
+    output = `foo callbacks . --url=https://hanamirb.test`
+
+    expected = <<~OUTPUT
+      before command callback Foo::Webpack::CLI::CallbacksCommand {:url=>"https://hanamirb.test", :dir=>"."}
+      before callback (class), 2 arg(s): {:url=>"https://hanamirb.test", :dir=>"."}
+      before callback (object), 2 arg(s): {:url=>"https://hanamirb.test", :dir=>"."}
+      dir: ., url: "https://hanamirb.test"
+      after command callback Foo::Webpack::CLI::CallbacksCommand {:url=>"https://hanamirb.test", :dir=>"."}
+      after callback (class), 2 arg(s): {:url=>"https://hanamirb.test", :dir=>"."}
+      after callback (object), 2 arg(s): {:url=>"https://hanamirb.test", :dir=>"."}
+    OUTPUT
+    expect(output).to eq(expected)
+  end
+end

data/vendor/dry-cli/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "support/coverage"
+
+$LOAD_PATH.unshift "lib"
+require "dry/cli"
+require_relative "./support/rspec"
+
+%w[support].each do |dir|
+  Dir[File.join(Dir.pwd, "spec", dir, "**", "*.rb")].each do |file|
+    unless file["support/warnings.rb"]
+      require_relative file
+    end
+  end
+end