rfix 1.4.1 → 2.0.0

data/vendor/dry-cli/spec/support/fixtures/with_block.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift __dir__ + "/../../lib"
+require "dry/cli"
+require_relative "shared_commands"
+
+WithBlock = Dry::CLI.new do |cli|
+  cli.register "assets precompile", Commands::Assets::Precompile
+  cli.register "console",           Commands::Console
+
+  cli.register "new",     Commands::New
+  cli.register "routes",  Commands::Routes
+  cli.register "server",  Commands::Server,  aliases: ["s"]
+  cli.register "version", Commands::Version, aliases: ["v", "-v", "--version"]
+  cli.register "exec",    Commands::Exec
+
+  cli.register "hello",       Commands::Hello
+  cli.register "greeting",    Commands::Greeting
+  cli.register "sub command", Commands::Sub::Command
+  cli.register "with-initializer", Commands::InitializedCommand.new(prop: "prop_val")
+  cli.register "root-command", Commands::RootCommand do |prefix|
+    prefix.register "sub-command", Commands::RootCommands::SubCommand
+  end
+
+  cli.register "options-with-aliases",                Commands::OptionsWithAliases
+  cli.register "variadic default",                    Commands::VariadicArguments
+  cli.register "variadic with-mandatory",             Commands::MandatoryAndVariadicArguments
+  cli.register "variadic with-mandatory-and-options", Commands::MandatoryOptionsAndVariadicArguments
+
+  cli.register "generate webpack", Webpack::CLI::Generate
+  cli.register "hello",            Webpack::CLI::Hello
+  cli.register "sub command",      Webpack::CLI::SubCommand
+  cli.register "callbacks",        Webpack::CLI::CallbacksCommand
+
+  cli.register "db" do |prefix|
+    prefix.register "apply",   Commands::DB::Apply
+    prefix.register "console", Commands::DB::Console
+    prefix.register "create",  Commands::DB::Create
+    prefix.register "drop",    Commands::DB::Drop
+    prefix.register "migrate", Commands::DB::Migrate
+    prefix.register "prepare", Commands::DB::Prepare
+    prefix.register "version", Commands::DB::Version
+    prefix.register "rollback", Commands::DB::Rollback
+  end
+
+  cli.register "destroy", aliases: ["d"] do |prefix|
+    prefix.register "action",    Commands::Destroy::Action
+    prefix.register "app",       Commands::Destroy::App
+    prefix.register "mailer",    Commands::Destroy::Mailer
+    prefix.register "migration", Commands::Destroy::Migration
+    prefix.register "model",     Commands::Destroy::Model
+  end
+
+  cli.register "generate", aliases: ["g"] do |prefix|
+    prefix.register "action",    Commands::Generate::Action
+    prefix.register "app",       Commands::Generate::App
+    prefix.register "mailer",    Commands::Generate::Mailer
+    prefix.register "migration", Commands::Generate::Migration
+    prefix.register "model",     Commands::Generate::Model
+    prefix.register "secret",    Commands::Generate::Secret
+  end
+
+  # we need to be sure that command will not override with nil command
+  cli.register "generate webpack", nil
+
+  cli.before("callbacks") do |args|
+    puts "before command callback #{self.class.name} #{args.inspect}"
+  end
+
+  cli.after("callbacks") do |args|
+    puts "after command callback #{self.class.name} #{args.inspect}"
+  end
+
+  cli.register "inherited", aliases: ["i"] do |prefix|
+    prefix.register "run",    InheritedCommands::Run
+    prefix.register "subrun", InheritedCommands::SubRun
+    prefix.register "logs",   InheritedCommands::Logs
+    prefix.register "addons", InheritedCommands::Addons
+  end
+
+  cli.before "callbacks", Callbacks::BeforeClass
+  cli.after "callbacks",  Callbacks::AfterClass
+  cli.before "callbacks", Callbacks::Before.new
+  cli.after "callbacks",  Callbacks::After.new
+end

data/vendor/dry-cli/spec/support/fixtures/with_registry.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift __dir__ + "/../../lib"
+require "dry/cli"
+require_relative "shared_commands"
+
+module Foo
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      register "assets precompile", ::Commands::Assets::Precompile
+      register "console",           ::Commands::Console
+      register "db" do |prefix|
+        prefix.register "apply",   ::Commands::DB::Apply
+        prefix.register "console", ::Commands::DB::Console
+        prefix.register "create",  ::Commands::DB::Create
+        prefix.register "drop",    ::Commands::DB::Drop
+        prefix.register "migrate", ::Commands::DB::Migrate
+        prefix.register "prepare", ::Commands::DB::Prepare
+        prefix.register "version", ::Commands::DB::Version
+        prefix.register "rollback", ::Commands::DB::Rollback
+      end
+
+      register "destroy", aliases: ["d"] do |prefix|
+        prefix.register "action",    ::Commands::Destroy::Action
+        prefix.register "app",       ::Commands::Destroy::App
+        prefix.register "mailer",    ::Commands::Destroy::Mailer
+        prefix.register "migration", ::Commands::Destroy::Migration
+        prefix.register "model",     ::Commands::Destroy::Model
+      end
+
+      register "generate", aliases: ["g"] do |prefix|
+        prefix.register "action",    ::Commands::Generate::Action
+        prefix.register "app",       ::Commands::Generate::App
+        prefix.register "mailer",    ::Commands::Generate::Mailer
+        prefix.register "migration", ::Commands::Generate::Migration
+        prefix.register "model",     ::Commands::Generate::Model
+        prefix.register "secret",    ::Commands::Generate::Secret
+      end
+
+      register "inherited", aliases: ["i"] do |prefix|
+        prefix.register "run",    ::InheritedCommands::Run
+        prefix.register "subrun", ::InheritedCommands::SubRun
+        prefix.register "logs",   ::InheritedCommands::Logs
+        prefix.register "addons", ::InheritedCommands::Addons
+      end
+
+      register "new",     ::Commands::New
+      register "routes",  ::Commands::Routes
+      register "server",  ::Commands::Server,  aliases: ["s"]
+      register "version", ::Commands::Version, aliases: ["v", "-v", "--version"]
+      register "exec",    ::Commands::Exec
+
+      register "hello",       ::Commands::Hello
+      register "greeting",    ::Commands::Greeting
+      register "sub command", ::Commands::Sub::Command
+      register "with-initializer", ::Commands::InitializedCommand.new(prop: "prop_val")
+      register "root-command", ::Commands::RootCommand
+      register "root-command sub-command", ::Commands::RootCommands::SubCommand
+
+      register "options-with-aliases",                ::Commands::OptionsWithAliases
+      register "variadic default",                    ::Commands::VariadicArguments
+      register "variadic with-mandatory",             ::Commands::MandatoryAndVariadicArguments
+      register "variadic with-mandatory-and-options", ::Commands::MandatoryOptionsAndVariadicArguments # rubocop:disable Metrics/LineLength
+
+      register "generate webpack", ::Webpack::CLI::Generate
+      register "hello",            ::Webpack::CLI::Hello
+      register "sub command",      ::Webpack::CLI::SubCommand
+      register "callbacks",        ::Webpack::CLI::CallbacksCommand
+
+      register "generate webpack", nil
+
+      before("callbacks") do |args|
+        puts "before command callback #{self.class.name} #{args.inspect}"
+      end
+
+      after("callbacks") do |args|
+        puts "after command callback #{self.class.name} #{args.inspect}"
+      end
+
+      before("callbacks", ::Callbacks::BeforeClass)
+      after("callbacks",  ::Callbacks::AfterClass)
+      before("callbacks", ::Callbacks::Before.new)
+      after("callbacks",  ::Callbacks::After.new)
+    end
+  end
+end
+
+WithRegistry = Dry::CLI.new(Foo::CLI::Commands)

data/vendor/dry-cli/spec/support/fixtures/with_zero_arity_block.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift __dir__ + "/../../lib"
+require "dry/cli"
+require_relative "shared_commands"
+
+WithZeroArityBlock = Dry.CLI do
+  register "assets precompile", Commands::Assets::Precompile
+  register "console",           Commands::Console
+
+  register "new",     Commands::New
+  register "routes",  Commands::Routes
+  register "server",  Commands::Server,  aliases: ["s"]
+  register "version", Commands::Version, aliases: ["v", "-v", "--version"]
+  register "exec",    Commands::Exec
+
+  register "hello",       Commands::Hello
+  register "greeting",    Commands::Greeting
+  register "sub command", Commands::Sub::Command
+  register "with-initializer", Commands::InitializedCommand.new(prop: "prop_val")
+  register "root-command", Commands::RootCommand
+  register "root-command" do
+    register "sub-command", Commands::RootCommands::SubCommand
+  end
+
+  register "options-with-aliases",                Commands::OptionsWithAliases
+  register "variadic default",                    Commands::VariadicArguments
+  register "variadic with-mandatory",             Commands::MandatoryAndVariadicArguments
+  register "variadic with-mandatory-and-options", Commands::MandatoryOptionsAndVariadicArguments
+
+  register "generate webpack", Webpack::CLI::Generate
+  register "hello",            Webpack::CLI::Hello
+  register "sub command",      Webpack::CLI::SubCommand
+  register "callbacks",        Webpack::CLI::CallbacksCommand
+
+  register "db" do
+    register "apply",   Commands::DB::Apply
+    register "console", Commands::DB::Console
+    register "create",  Commands::DB::Create
+    register "drop",    Commands::DB::Drop
+    register "migrate", Commands::DB::Migrate
+    register "prepare", Commands::DB::Prepare
+    register "version", Commands::DB::Version
+    register "rollback", Commands::DB::Rollback
+  end
+
+  register "destroy", aliases: ["d"] do
+    register "action",    Commands::Destroy::Action
+    register "app",       Commands::Destroy::App
+    register "mailer",    Commands::Destroy::Mailer
+    register "migration", Commands::Destroy::Migration
+    register "model",     Commands::Destroy::Model
+  end
+
+  register "generate", aliases: ["g"] do
+    register "action",    Commands::Generate::Action
+    register "app",       Commands::Generate::App
+    register "mailer",    Commands::Generate::Mailer
+    register "migration", Commands::Generate::Migration
+    register "model",     Commands::Generate::Model
+    register "secret",    Commands::Generate::Secret
+  end
+
+  register "inherited", aliases: ["i"] do
+    register "run",    InheritedCommands::Run
+    register "subrun", InheritedCommands::SubRun
+    register "logs",   InheritedCommands::Logs
+    register "addons", InheritedCommands::Addons
+  end
+
+  # we need to be sure that command will not override with nil command
+  register "generate webpack", nil
+
+  before("callbacks") do |args|
+    puts "before command callback #{self.class.name} #{args.inspect}"
+  end
+
+  after("callbacks") do |args|
+    puts "after command callback #{self.class.name} #{args.inspect}"
+  end
+
+  before "callbacks", Callbacks::BeforeClass
+  after "callbacks",  Callbacks::AfterClass
+  before "callbacks", Callbacks::Before.new
+  after "callbacks",  Callbacks::After.new
+end

data/vendor/dry-cli/spec/support/helpers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Support
+    module Helpers
+      def capture_output
+        require "stringio"
+        output = StringIO.new
+        original_stdout = $stdout
+        $stdout = output
+        yield
+        output.string
+      rescue SystemExit
+        output.string
+      ensure
+        $stdout = original_stdout
+      end
+
+      def capture_error
+        require "stringio"
+        error = StringIO.new
+        original_stderr = $stderr
+        $stderr = error
+        yield
+        error.string
+      rescue SystemExit
+        error.string
+      ensure
+        $stderr = original_stderr
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(RSpec::Support::Helpers)
+end

data/vendor/dry-cli/spec/support/path.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Support
+    module Path
+      def self.included(base)
+        base.class_eval do
+          before do
+            @original_path = ENV["PATH"]
+            ENV["PATH"] = __dir__ + "/fixtures:" + ENV["PATH"]
+          end
+
+          after do
+            ENV["PATH"] = @original_path
+          end
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(RSpec::Support::Path)
+end

data/vendor/dry-cli/spec/support/rspec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  config.filter_run_when_matching :focus
+
+  config.disable_monkey_patching!
+
+  config.warnings = true
+
+  config.default_formatter = "doc" if config.files_to_run.one?
+  config.profile_examples = 10
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/vendor/dry-cli/spec/support/rspec_options.rb

@@ -0,0 +1,16 @@
+RSpec.configure do |config|
+  # When no filter given, search and run focused tests
+  config.filter_run_when_matching :focus
+
+  # Disables rspec monkey patches (no reason for their existence tbh)
+  config.disable_monkey_patching!
+
+  # Run ruby in verbose mode
+  config.warnings = true
+
+  # Collect all failing expectations automatically,
+  # without calling aggregate_failures everywhere
+  config.define_derived_metadata do |meta|
+    meta[:aggregate_failures] = true
+  end
+end

data/vendor/dry-cli/spec/support/shared_examples/commands.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/LineLength
+RSpec.shared_examples "Commands" do |cli|
+  let(:cli) { cli }
+
+  let(:cmd) { File.basename($PROGRAM_NAME, File.extname($PROGRAM_NAME)) }
+
+  it "calls basic command" do
+    output = capture_output { cli.call(arguments: ["version"]) }
+    expect(output).to eq("v1.0.0\n")
+  end
+
+  it "calls basic command with alias" do
+    output = capture_output { cli.call(arguments: ["v"]) }
+    expect(output).to eq("v1.0.0\n")
+
+    output = capture_output { cli.call(arguments: ["-v"]) }
+    expect(output).to eq("v1.0.0\n")
+
+    output = capture_output { cli.call(arguments: ["--version"]) }
+    expect(output).to eq("v1.0.0\n")
+  end
+
+  it "calls subcommand via intermediate alias" do
+    output = capture_output { cli.call(arguments: %w[g secret web]) }
+    expect(output).to eq("generate secret - app: web\n")
+  end
+
+  context "works with params" do
+    it "without params" do
+      output = capture_output { cli.call(arguments: ["server"]) }
+      expect(output).to eq("server - {:code_reloading=>true, :deps=>[\"dep1\", \"dep2\"]}\n")
+    end
+
+    it "a param using space" do
+      output = capture_output { cli.call(arguments: %w[server --server thin]) }
+      expect(output).to eq("server - {:code_reloading=>true, :deps=>[\"dep1\", \"dep2\"], :server=>\"thin\"}\n")
+    end
+
+    it "a param using equal sign" do
+      output = capture_output { cli.call(arguments: %w[server --host=localhost]) }
+      expect(output).to eq("server - {:code_reloading=>true, :deps=>[\"dep1\", \"dep2\"], :host=>\"localhost\"}\n")
+    end
+
+    it "a param using alias" do
+      output = capture_output { cli.call(arguments: %w[options-with-aliases -u test]) }
+      expect(output).to eq("options with aliases - {:opt=>false, :url=>\"test\"}\n")
+
+      output = capture_output { cli.call(arguments: %w[options-with-aliases -utest]) }
+      expect(output).to eq("options with aliases - {:opt=>false, :url=>\"test\"}\n")
+
+      output = capture_output { cli.call(arguments: %w[options-with-aliases -f -u test]) }
+      expect(output).to eq("options with aliases - {:opt=>false, :flag=>true, :url=>\"test\"}\n")
+
+      output = capture_output { cli.call(arguments: %w[options-with-aliases -o]) }
+      expect(output).to eq("options with aliases - {:opt=>true}\n")
+
+      output = capture_output { cli.call(arguments: %w[options-with-aliases -of]) }
+      expect(output).to eq("options with aliases - {:opt=>true, :flag=>true}\n")
+    end
+
+    it "a param with unknown param" do
+      error = capture_error { cli.call(arguments: %w[server --unknown 1234]) }
+      expect(error).to eq("ERROR: \"rspec server\" was called with arguments \"--unknown 1234\"\n")
+    end
+
+    it "with boolean param" do
+      output = capture_output { cli.call(arguments: ["server"]) }
+      expect(output).to eq("server - {:code_reloading=>true, :deps=>[\"dep1\", \"dep2\"]}\n")
+
+      output = capture_output { cli.call(arguments: %w[server --no-code-reloading]) }
+      expect(output).to eq("server - {:code_reloading=>false, :deps=>[\"dep1\", \"dep2\"]}\n")
+    end
+
+    context "with array param" do
+      it "allows to omit optional array argument" do
+        output = capture_output { cli.call(arguments: %w[exec test]) }
+        expect(output).to eq("exec - Task: test - Directories: []\n")
+      end
+
+      it "capture all the remaining arguments" do
+        output = capture_output { cli.call(arguments: %w[exec test api admin]) }
+        expect(output).to eq("exec - Task: test - Directories: [\"api\", \"admin\"]\n")
+      end
+    end
+
+    context "with supported values" do
+      context "and with supported value passed" do
+        it "call the command with the option" do
+          output = capture_output { cli.call(arguments: %w[console --engine=pry]) }
+          expect(output).to eq("console - engine: pry\n")
+        end
+      end
+
+      context "and with an unknown value passed" do
+        it "prints error" do
+          error = capture_error { cli.call(arguments: %w[console --engine=unknown]) }
+          expect(error).to eq("ERROR: \"rspec console\" was called with arguments \"--engine=unknown\"\n") # rubocop:disable Metrics/LineLength
+        end
+      end
+    end
+
+    it "with help param" do
+      output = capture_output { cli.call(arguments: %w[server --help]) }
+
+      expected = <<~DESC
+        Command:
+          #{cmd} server
+
+        Usage:
+          #{cmd} server
+
+        Description:
+          Start Foo server (only for development)
+
+        Options:
+          --server=VALUE                    # Force a server engine (eg, webrick, puma, thin, etc..)
+          --host=VALUE                      # The host address to bind to
+          --port=VALUE, -p VALUE            # The port to run the server on
+          --debug=VALUE                     # Turn on debug output
+          --warn=VALUE                      # Turn on warnings
+          --daemonize=VALUE                 # Daemonize the server
+          --pid=VALUE                       # Path to write a pid file after daemonize
+          --[no-]code-reloading             # Code reloading, default: true
+          --deps=VALUE1,VALUE2,..           # List of extra dependencies, default: ["dep1", "dep2"]
+          --help, -h                        # Print this help
+
+        Examples:
+          #{cmd} server                     # Basic usage (it uses the bundled server engine)
+          #{cmd} server --server=webrick    # Force `webrick` server engine
+          #{cmd} server --host=0.0.0.0      # Bind to a host
+          #{cmd} server --port=2306         # Bind to a port
+          #{cmd} server --no-code-reloading # Disable code reloading
+      DESC
+
+      expect(output).to eq(expected)
+    end
+
+    context "with required params" do
+      it "can be used" do
+        output = capture_output { cli.call(arguments: %w[new bookshelf]) }
+        expect(output).to eq("new - project: bookshelf\n")
+      end
+
+      it "with unknown param" do
+        error = capture_error { cli.call(arguments: %w[new bookshelf --unknown 1234]) }
+        expect(error).to eq("ERROR: \"rspec new\" was called with arguments \"bookshelf --unknown 1234\"\n") # rubocop:disable Metrics/LineLength
+      end
+
+      it "no required" do
+        output = capture_output { cli.call(arguments: %w[generate secret web]) }
+        expect(output).to eq("generate secret - app: web\n")
+
+        output = capture_output { cli.call(arguments: %w[generate secret]) }
+        expect(output).to eq("generate secret - app: \n")
+      end
+
+      it "an error is displayed if there aren't required params" do
+        error = capture_error { cli.call(arguments: ["new"]) }
+        expected_error = <<~DESC
+          ERROR: "#{cmd} new" was called with no arguments
+          Usage: "#{cmd} new PROJECT"
+        DESC
+        expect(error).to eq(expected_error)
+      end
+
+      it "with default value and using options" do
+        output = capture_output { cli.call(arguments: %w[greeting --person=Alfonso]) }
+        expect(output).to eq("response: Hello World, person: Alfonso\n")
+
+        output = capture_output { cli.call(arguments: %w[greeting bye --person=Alfonso]) }
+        expect(output).to eq("response: bye, person: Alfonso\n")
+      end
+    end
+
+    context "with extra params" do
+      it "is accessible via options[:args]" do
+        output = capture_output { cli.call(arguments: %w[variadic default bar baz]) }
+        expect(output).to eq("Unused Arguments: bar, baz\n")
+      end
+
+      context "when there is a required argument" do
+        it "parses both separately" do
+          output = capture_output { cli.call(arguments: ["variadic", "with-mandatory", cmd, "bar", "baz"]) }
+          expect(output).to eq("first: #{cmd}\nUnused Arguments: bar, baz\n")
+        end
+
+        context "and there are options" do
+          it "parses both separately" do
+            output = capture_output { cli.call(arguments: ["variadic", "with-mandatory-and-options", cmd, "bar", "baz"]) }
+            expect(output).to eq("first: #{cmd}\nurl: \nmethod: \nUnused Arguments: bar, baz\n")
+
+            output = capture_output { cli.call(arguments: ["variadic", "with-mandatory-and-options", "--url=root", "--method=index", cmd, "bar", "baz"]) }
+            expect(output).to eq("first: #{cmd}\nurl: root\nmethod: index\nUnused Arguments: bar, baz\n")
+
+            output = capture_output { cli.call(arguments: %w[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
+
+  context "works with command with arguments and subcommands" do
+    it "shows help" do
+      output = capture_output { cli.call(arguments: %w[root-command -h]) }
+      expected = <<~DESC
+        Command:
+          #{cmd} root-command
+
+        Usage:
+          #{cmd} root-command ROOT_COMMAND_ARGUMENT | #{cmd} root-command SUBCOMMAND
+
+        Description:
+          Root command with arguments and subcommands
+
+        Subcommands:
+          sub-command                       # Root command sub command
+
+        Arguments:
+          ROOT_COMMAND_ARGUMENT             # REQUIRED Root command argument
+
+        Options:
+          --root-command-option=VALUE       # Root command option
+          --help, -h                        # Print this help
+      DESC
+
+      expect(output).to eq(expected)
+
+      output = capture_output { cli.call(arguments: %w[root-command --help]) }
+      expect(output).to eq(expected)
+    end
+
+    context "works with params" do
+      it "without params" do
+        error = capture_error { cli.call(arguments: %w[root-command]) }
+        expected = <<~DESC
+          ERROR: "rspec root-command" was called with no arguments
+          Usage: "rspec root-command ROOT_COMMAND_ARGUMENT | rspec root-command SUBCOMMAND"
+        DESC
+
+        expect(error).to eq(expected)
+      end
+
+      it "with params" do
+        output = capture_output {
+          cli.call(arguments: ["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 option using space" do
+        output = capture_output {
+          cli.call(arguments: [
+            "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
+
+      it "with option using equal sign" do
+        output = capture_output {
+          cli.call(arguments: [
+            "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
+
+  context "works with instances of commands" do
+    it "executes instance" do
+      output = capture_output { cli.call(arguments: %w[with-initializer]) }
+      expect(output).to eq("The value of prop is prop_val\n")
+    end
+  end
+end
+# rubocop:enable Metrics/LineLength