rfix 1.4.1 → 2.0.4

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Inherited commands" do |cli|
+  let(:cli) { cli }
+
+  let(:cmd) { File.basename($PROGRAM_NAME, File.extname($PROGRAM_NAME)) }
+
+  context "with help flag" do
+    it "shows subcommands " do
+      error = capture_error { cli.call(arguments: %w[i]) }
+      expected = <<~DESC
+        Commands:
+          rspec i addons APP                 # Lists your add-ons and attachments
+          rspec i logs APP                   # Display recent log output
+          rspec i run APP CMD                # Run a one-off process inside your app
+          rspec i subrun APP CMD
+      DESC
+      expect(error).to eq(expected)
+    end
+
+    it "shows run's help" do
+      output = capture_output { cli.call(arguments: %w[i run --help]) }
+      expected = <<~DESC
+        Command:
+          #{cmd} i run
+
+        Usage:
+          #{cmd} i run APP CMD
+
+        Description:
+          Run a one-off process inside your app
+
+        Arguments:
+          APP                               # REQUIRED Application name
+          CMD                               # REQUIRED Command to execute
+
+        Options:
+          --verbosity=VALUE                 # Verbosity level, default: "INFO"
+          --help, -h                        # Print this help
+      DESC
+      expect(output).to eq(expected)
+    end
+
+    it "shows subrun's help" do
+      output = capture_output { cli.call(arguments: %w[i subrun --help]) }
+      expected = <<~DESC
+        Command:
+          #{cmd} i subrun
+
+        Usage:
+          #{cmd} i subrun APP CMD
+
+        Arguments:
+          APP                               # REQUIRED Application name
+          CMD                               # REQUIRED Command to execute
+
+        Options:
+          --verbosity=VALUE                 # Verbosity level, default: "INFO"
+          --help, -h                        # Print this help
+      DESC
+      expect(output).to eq(expected)
+    end
+
+    it "shows addon's help" do
+      output = capture_output { cli.call(arguments: %w[i addons --help]) }
+      expected = <<~DESC
+        Command:
+          #{cmd} i addons
+
+        Usage:
+          #{cmd} i addons APP
+
+        Description:
+          Lists your add-ons and attachments
+
+        Arguments:
+          APP                               # REQUIRED Application name
+
+        Options:
+          --verbosity=VALUE                 # Verbosity level, default: "INFO"
+          --[no-]json                       # return add-ons in json format, default: false
+          --help, -h                        # Print this help
+
+        Examples:
+          #{cmd} i addons APP_NAME
+          #{cmd} i addons APP_NAME --json
+      DESC
+      expect(output).to eq(expected)
+    end
+
+    it "shows log's help" do
+      output = capture_output { cli.call(arguments: %w[i logs --help]) }
+      expected = <<~DESC
+        Command:
+          #{cmd} i logs
+
+        Usage:
+          #{cmd} i logs APP
+
+        Description:
+          Display recent log output
+
+        Arguments:
+          APP                               # REQUIRED Application name
+
+        Options:
+          --verbosity=VALUE                 # Verbosity level, default: "INFO"
+          --num=VALUE                       # number of lines to display
+          --[no-]tail                       # continually stream log
+          --help, -h                        # Print this help
+
+        Examples:
+          #{cmd} i logs APP_NAME
+          #{cmd} i logs APP_NAME --num=50
+          #{cmd} i logs APP_NAME --tail
+      DESC
+      expect(output).to eq(expected)
+    end
+  end
+
+  context "with inherited arguments" do
+    it "run expects APP_NAME and CMD_NAME" do
+      output = capture_output { cli.call(arguments: %w[i run application_name command_name]) }
+      expect(output).to include("App: application_name - Command: command_name")
+    end
+
+    it "subrun expects APP_NAME and CMD_NAME" do
+      output = capture_output { cli.call(arguments: %w[i subrun application_name command_name]) }
+      expect(output).to include("App: application_name - Command: command_name")
+    end
+
+    it "addons expects APP_NAME" do
+      output = capture_output { cli.call(arguments: %w[i addons application_name]) }
+      expect(output).to include("App: application_name")
+    end
+
+    it "logs expects APP_NAME" do
+      output = capture_output { cli.call(arguments: %w[i logs application_name]) }
+      expect(output).to include("App: application_name")
+    end
+  end
+
+  context "with inherited options" do
+    it "run has default verbosity_level" do
+      output = capture_output { cli.call(arguments: %w[i run application_name command_name]) }
+      expect(output).to include('Options: {:verbosity=>"INFO"}')
+    end
+
+    it "subrun has default verbosity_level too" do
+      output = capture_output { cli.call(arguments: %w[i subrun application_name command_name]) }
+      expect(output).to include('Options: {:verbosity=>"INFO"}')
+    end
+
+    it "addons has verbosity_level set to debug" do
+      output = capture_output do
+        cli.call(arguments: %w[i addons application_name --verbosity=DEBUG])
+      end
+      expect(output).to include("Options: {:verbosity=>\"DEBUG\", :json=>false}")
+    end
+
+    it "logs has verbosity_level set to WARNING" do
+      output = capture_output do
+        cli.call(arguments: %w[i logs application_name --verbosity=WARNING])
+      end
+      expect(output).to include("Options: {:verbosity=>\"WARNING\"}")
+    end
+  end
+
+  context "with description" do
+    it "subclass does not inherit it" do
+      output = capture_output { cli.call(arguments: %w[i run --help]) }
+      expect(output).not_to include("Base description")
+    end
+
+    it "subclasses subclass does not inherit it" do
+      output = capture_output { cli.call(arguments: %w[i subrun --help]) }
+      expect(output).not_to include("Run a one-off process inside your app")
+    end
+  end
+
+  context "with example" do
+    it "subclass does not inherit it" do
+      output = capture_output { cli.call(arguments: %w[i logs --help]) }
+      expect(output).not_to include("Base example")
+    end
+  end
+
+  context "with multible subclasses of Dry::CLI::Command" do
+    it "subclasses do nod share options" do
+      output = capture_output { cli.call(arguments: %w[i logs application_name --tail --num=50]) }
+      expect(output).not_to include(":json=>false}")
+
+      output = capture_output { cli.call(arguments: %w[i addons application_name]) }
+      expect(output).not_to include(":tail=>false}")
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Rendering" do |cli|
+  let(:cli) { cli }
+
+  let(:cmd) { File.basename($PROGRAM_NAME, File.extname($PROGRAM_NAME)) }
+
+  it "prints required params" do
+    error = capture_error { cli.call }
+    expected = <<~DESC
+      Commands:
+        #{cmd} assets [SUBCOMMAND]
+        #{cmd} callbacks DIR                                           # Command with callbacks
+        #{cmd} console                                                 # Starts Foo console
+        #{cmd} db [SUBCOMMAND]
+        #{cmd} destroy [SUBCOMMAND]
+        #{cmd} exec TASK [DIRS]                                        # Execute a task
+        #{cmd} generate [SUBCOMMAND]
+        #{cmd} greeting [RESPONSE]
+        #{cmd} hello                                                   # Print a greeting
+        #{cmd} inherited [SUBCOMMAND]
+        #{cmd} new PROJECT                                             # Generate a new Foo project
+        #{cmd} options-with-aliases                                    # Accepts options with aliases
+        #{cmd} root-command [ARGUMENT|SUBCOMMAND]                      # Root command with arguments and subcommands
+        #{cmd} routes                                                  # Print routes
+        #{cmd} server                                                  # Start Foo server (only for development)
+        #{cmd} sub [SUBCOMMAND]
+        #{cmd} variadic [SUBCOMMAND]
+        #{cmd} version                                                 # Print Foo version
+        #{cmd} with-initializer
+    DESC
+
+    expect(error).to eq(expected)
+  end
+
+  it "prints required params with labels" do
+    error = capture_error { cli.call(arguments: ["destroy"]) }
+
+    expected = <<~DESC
+      Commands:
+        #{cmd} destroy action APP ACTION                    # Destroy an action from app
+        #{cmd} destroy app APP                              # Destroy an app
+        #{cmd} destroy mailer MAILER                        # Destroy a mailer
+        #{cmd} destroy migration MIGRATION                  # Destroy a migration
+        #{cmd} destroy model MODEL                          # Destroy a model
+    DESC
+
+    expect(error).to eq(expected)
+  end
+
+  it "prints available commands for unknown subcommand" do
+    error = capture_error { cli.call(arguments: %w[generate unknown]) }
+
+    expected = <<~DESC
+      Commands:
+        #{cmd} generate action APP ACTION                     # Generate an action for app
+        #{cmd} generate app APP                               # Generate an app
+        #{cmd} generate mailer MAILER                         # Generate a mailer
+        #{cmd} generate migration MIGRATION                   # Generate a migration
+        #{cmd} generate model MODEL                           # Generate a model
+        #{cmd} generate secret [APP]                          # Generate session secret
+        #{cmd} generate webpack                               # Generate webpack configuration
+    DESC
+
+    expect(error).to eq(expected)
+  end
+
+  it "prints available commands for unknown command" do
+    error = capture_error { cli.call(arguments: ["unknown"]) }
+
+    expected = <<~DESC
+      Commands:
+        #{cmd} assets [SUBCOMMAND]
+        #{cmd} callbacks DIR                                           # Command with callbacks
+        #{cmd} console                                                 # Starts Foo console
+        #{cmd} db [SUBCOMMAND]
+        #{cmd} destroy [SUBCOMMAND]
+        #{cmd} exec TASK [DIRS]                                        # Execute a task
+        #{cmd} generate [SUBCOMMAND]
+        #{cmd} greeting [RESPONSE]
+        #{cmd} hello                                                   # Print a greeting
+        #{cmd} inherited [SUBCOMMAND]
+        #{cmd} new PROJECT                                             # Generate a new Foo project
+        #{cmd} options-with-aliases                                    # Accepts options with aliases
+        #{cmd} root-command [ARGUMENT|SUBCOMMAND]                      # Root command with arguments and subcommands
+        #{cmd} routes                                                  # Print routes
+        #{cmd} server                                                  # Start Foo server (only for development)
+        #{cmd} sub [SUBCOMMAND]
+        #{cmd} variadic [SUBCOMMAND]
+        #{cmd} version                                                 # Print Foo version
+        #{cmd} with-initializer
+    DESC
+
+    expect(error).to eq(expected)
+  end
+
+  it "prints first level" do
+    error = capture_error { cli.call }
+
+    expected = <<~DESC
+      Commands:
+        #{cmd} assets [SUBCOMMAND]
+        #{cmd} callbacks DIR                                           # Command with callbacks
+        #{cmd} console                                                 # Starts Foo console
+        #{cmd} db [SUBCOMMAND]
+        #{cmd} destroy [SUBCOMMAND]
+        #{cmd} exec TASK [DIRS]                                        # Execute a task
+        #{cmd} generate [SUBCOMMAND]
+        #{cmd} greeting [RESPONSE]
+        #{cmd} hello                                                   # Print a greeting
+        #{cmd} inherited [SUBCOMMAND]
+        #{cmd} new PROJECT                                             # Generate a new Foo project
+        #{cmd} options-with-aliases                                    # Accepts options with aliases
+        #{cmd} root-command [ARGUMENT|SUBCOMMAND]                      # Root command with arguments and subcommands
+        #{cmd} routes                                                  # Print routes
+        #{cmd} server                                                  # Start Foo server (only for development)
+        #{cmd} sub [SUBCOMMAND]
+        #{cmd} variadic [SUBCOMMAND]
+        #{cmd} version                                                 # Print Foo version
+        #{cmd} with-initializer
+    DESC
+
+    expect(error).to eq(expected)
+  end
+
+  it "prints subcommand's commands" do
+    error = capture_error { cli.call(arguments: ["generate"]) }
+
+    expected = <<~DESC
+      Commands:
+        #{cmd} generate action APP ACTION                     # Generate an action for app
+        #{cmd} generate app APP                               # Generate an app
+        #{cmd} generate mailer MAILER                         # Generate a mailer
+        #{cmd} generate migration MIGRATION                   # Generate a migration
+        #{cmd} generate model MODEL                           # Generate a model
+        #{cmd} generate secret [APP]                          # Generate session secret
+        #{cmd} generate webpack                               # Generate webpack configuration
+    DESC
+
+    expect(error).to eq(expected)
+  end
+
+  it "prints subcommand's subcommand" do
+    error = capture_error { cli.call(arguments: %w[generate application]) }
+
+    expected = <<~DESC
+      Commands:
+        #{cmd} generate action APP ACTION                     # Generate an action for app
+        #{cmd} generate app APP                               # Generate an app
+        #{cmd} generate mailer MAILER                         # Generate a mailer
+        #{cmd} generate migration MIGRATION                   # Generate a migration
+        #{cmd} generate model MODEL                           # Generate a model
+        #{cmd} generate secret [APP]                          # Generate session secret
+        #{cmd} generate webpack                               # Generate webpack configuration
+    DESC
+    expect(error).to eq(expected)
+  end
+
+  it "prints list options when calling help" do
+    output = capture_output { cli.call(arguments: %w[options-with-aliases --help]) }
+
+    expected = <<~DESC
+      Command:
+        #{cmd} options-with-aliases
+
+      Usage:
+        #{cmd} options-with-aliases
+
+      Description:
+        Accepts options with aliases
+
+      Options:
+        --url=VALUE, -u VALUE             # The action URL
+        --[no-]flag, -f                   # The flag
+        --[no-]opt, -o                    # The opt, default: false
+        --help, -h                        # Print this help
+    DESC
+
+    expect(output).to eq(expected)
+  end
+end

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

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Subcommands" do |cli|
+  let(:cli) { cli }
+
+  let(:cmd) { File.basename($PROGRAM_NAME, File.extname($PROGRAM_NAME)) }
+
+  it "calls subcommand" do
+    error = capture_error { cli.call(arguments: %w[generate model]) }
+    expected = <<~DESC
+      ERROR: "#{cmd} generate model" was called with no arguments
+      Usage: "#{cmd} generate model MODEL"
+    DESC
+
+    expect(error).to eq(expected)
+  end
+
+  context "works with params" do
+    it "without params" do
+      error = capture_error { cli.call(arguments: %w[generate model]) }
+      expected = <<~DESC
+        ERROR: "#{cmd} generate model" was called with no arguments
+        Usage: "#{cmd} generate model MODEL"
+      DESC
+
+      expect(error).to eq(expected)
+    end
+
+    it "a param using space" do
+      output = capture_output { cli.call(arguments: %w[server --port 2306]) }
+      expect(output).to eq(
+        "server - {:code_reloading=>true, :deps=>[\"dep1\", \"dep2\"], :port=>\"2306\"}\n"
+      )
+    end
+
+    it "a param using equal sign" do
+      output = capture_output { cli.call(arguments: %w[server --port=2306]) }
+      expect(output).to eq(
+        "server - {:code_reloading=>true, :deps=>[\"dep1\", \"dep2\"], :port=>\"2306\"}\n"
+      )
+    end
+
+    it "a param using alias" do
+      output = capture_output { cli.call(arguments: %w[server -p 2306]) }
+      expect(output).to eq(
+        "server - {:code_reloading=>true, :deps=>[\"dep1\", \"dep2\"], :port=>\"2306\"}\n"
+      )
+    end
+
+    it "with help param" do
+      output = capture_output { cli.call(arguments: %w[generate model --help]) }
+
+      expected = <<~DESC
+        Command:
+          #{cmd} generate model
+
+        Usage:
+          #{cmd} 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:
+          #{cmd} generate model user                  # Generate `User` entity, `UserRepository` repository, and the migration
+          #{cmd} generate model user --skip-migration # Generate `User` entity and `UserRepository` repository
+      DESC
+
+      expect(output).to eq(expected)
+    end
+
+    context "with required params" do
+      it "only one param" do
+        output = capture_output { cli.call(arguments: %w[generate model user]) }
+        expect(output).to eq("generate model - model: user\n")
+      end
+
+      it "more than one param" do
+        output = capture_output { cli.call(arguments: %w[destroy action web users#index]) }
+        expect(output).to eq("destroy action - app: web, action: users#index\n")
+      end
+
+      it "more than one param and with optional params" do
+        output = capture_output { cli.call(arguments: %w[generate action web users#index --url=/signin]) } # rubocop:disable Metrics/LineLength
+        expect(output).to eq("generate action - app: web, action: users#index, options: {:skip_view=>false, :url=>\"/signin\"}\n") # rubocop:disable Metrics/LineLength
+      end
+
+      it "more than one param and with boolean params" do
+        output = capture_output { cli.call(arguments: %w[generate action web users#index --skip-view --url=/signin]) } # rubocop:disable Metrics/LineLength
+        expect(output).to eq("generate action - app: web, action: users#index, options: {:skip_view=>true, :url=>\"/signin\"}\n") # rubocop:disable Metrics/LineLength
+      end
+
+      it "more than required params" do
+        output = capture_output { cli.call(arguments: %w[destroy action web users#index unexpected_param]) } # rubocop:disable Metrics/LineLength
+        expect(output).to eq("destroy action - app: web, action: users#index\n")
+      end
+
+      it "an error is displayed if there aren't required params" do
+        error = capture_error { cli.call(arguments: %w[destroy action]) }
+        expected = <<~DESC
+          ERROR: "#{cmd} destroy action" was called with no arguments
+          Usage: "#{cmd} destroy action APP ACTION"
+        DESC
+
+        expect(error).to eq(expected)
+      end
+
+      it "an error is displayed if there are some required params" do
+        error = capture_error { cli.call(arguments: %w[destroy action web]) }
+        expected = <<~DESC
+          ERROR: "#{cmd} destroy action" was called with arguments [\"web\"]
+          Usage: "#{cmd} destroy action APP ACTION"
+        DESC
+
+        expect(error).to eq(expected)
+      end
+
+      context "and a default value" do
+        it "returns the default value if nothing is passed" do
+          output = capture_output { cli.call(arguments: %w[db rollback]) }
+
+          expect(output).to eq("1\n")
+        end
+
+        it "returns the passed value" do
+          output = capture_output { cli.call(arguments: %w[db rollback 3]) }
+
+          expect(output).to eq("3\n")
+        end
+      end
+    end
+  end
+
+  context "works with root command" do
+    it "shows help" do
+      output = capture_output { cli.call(arguments: %w[root-command sub-command -h]) }
+      expected = <<~DESC
+        Command:
+          rspec root-command sub-command
+
+        Usage:
+          rspec root-command sub-command ROOT_COMMAND_SUB_COMMAND_ARGUMENT
+
+        Description:
+          Root command sub command
+
+        Arguments:
+          ROOT_COMMAND_SUB_COMMAND_ARGUMENT  # REQUIRED Root command sub command argument
+
+        Options:
+          --root-command-sub-command-option=VALUE  # Root command sub command option
+          --help, -h                        # Print this help
+      DESC
+
+      expect(output).to eq(expected)
+
+      output = capture_output { cli.call(arguments: %w[root-command sub-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 sub-command]) }
+        expected = <<~DESC
+          ERROR: "rspec root-command sub-command" was called with no arguments
+          Usage: "rspec root-command sub-command ROOT_COMMAND_SUB_COMMAND_ARGUMENT"
+        DESC
+
+        expect(error).to eq(expected)
+      end
+
+      it "with params" do
+        output = capture_output {
+          cli.call(arguments: ["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 option using space" do
+        output = capture_output {
+          cli.call(arguments: [
+            "root-command",
+            "sub-command",
+            '"hello world"',
+            "--root-command-sub-command-option",
+            '"bye world"'
+          ])
+        }
+        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
+
+      it "with option using equal sign" do
+        output = capture_output {
+          cli.call(arguments: [
+            "root-command",
+            "sub-command",
+            '"hello world"',
+            '--root-command-sub-command-option="bye world"'
+          ])
+        }
+        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
+end