railties 7.0.8 → 7.1.0.beta1

data/lib/rails/commands/runner/USAGE

@@ -1,20 +1,22 @@
-Examples:
+Description:
+    The Rails `runner` allows running Ruby code in the context of your application.
 
-Run `puts Rails.env` after loading the app:
+Examples:
+    Run `puts Rails.env` after loading the app:
 
-  <%= executable %> 'puts Rails.env'
+        <%= executable %> 'puts Rails.env'
 
-Run the Ruby file located at `path/to/filename.rb` after loading the app:
+    Run the Ruby file located at `path/to/filename.rb` after loading the app:
 
-  <%= executable %> path/to/filename.rb
+        <%= executable %> path/to/filename.rb
 
-Run the Ruby script read from stdin after loading the app:
-  <%= executable %> -
+    Run the Ruby script read from stdin after loading the app:
 
-<% unless Gem.win_platform? %>
-You can also use the runner command as a shebang line for your executables:
+        <%= executable %> -
+<% unless Gem.win_platform? -%>
 
-  #!/usr/bin/env <%= File.expand_path(executable) %>
+    You can also use the runner command as a shebang line for your executables:
 
-  Product.all.each { |p| p.price *= 2 ; p.save! }
-<% end %>
+        #!/usr/bin/env <%= File.expand_path(executable) %>
+        Product.all.each { |p| p.price *= 2 ; p.save! }
+<% end -%>

data/lib/rails/commands/runner/runner_command.rb

@@ -7,52 +7,64 @@ module Rails
     class RunnerCommand < Base # :nodoc:
       include EnvironmentArgument
 
-      self.environment_desc = "The environment for the runner to operate under (test/development/production)"
-
       no_commands do
-        def help
+        def help(command_name = nil, *)
           super
-          say self.class.desc
+          if command_name == "runner"
+            say ""
+            say self.class.class_usage
+          end
         end
       end
 
-      def self.banner(*)
-        "#{super} [<'Some.ruby(code)'> | <filename.rb> | -]"
-      end
-
+      desc "runner [<'Some.ruby(code)'> | <filename.rb> | -]",
+        "Run Ruby code in the context of your application"
       def perform(code_or_file = nil, *command_argv)
-        extract_environment_option_from_argument
-
         unless code_or_file
           help
           exit 1
         end
 
-        ENV["RAILS_ENV"] = options[:environment]
-
-        require_application_and_environment!
+        boot_application!
         Rails.application.load_runner
 
         ARGV.replace(command_argv)
 
         if code_or_file == "-"
-          eval($stdin.read, TOPLEVEL_BINDING, "stdin")
+          Rails.application.executor.wrap(source: "application.runner.railties") do
+            eval($stdin.read, TOPLEVEL_BINDING, "stdin")
+          end
         elsif File.exist?(code_or_file)
           expanded_file_path = File.expand_path code_or_file
           $0 = expanded_file_path
-          Kernel.load expanded_file_path
+          Rails.application.executor.wrap(source: "application.runner.railties") do
+            Kernel.load expanded_file_path
+          end
         else
           begin
-            eval(code_or_file, TOPLEVEL_BINDING, __FILE__, __LINE__)
+            Rails.application.executor.wrap(source: "application.runner.railties") do
+              eval(code_or_file, TOPLEVEL_BINDING, __FILE__, __LINE__)
+            end
           rescue SyntaxError, NameError => e
-            error "Please specify a valid ruby command or the path of a script to run."
-            error "Run '#{self.class.executable} -h' for help."
-            error ""
-            error e
+            if looks_like_a_file_path?(code_or_file)
+              error "The file #{code_or_file} could not be found, please check and try again."
+              error "Run '#{self.class.executable} -h' for help."
+            else
+              error "Please specify a valid ruby command or the path of a script to run."
+              error "Run '#{self.class.executable} -h' for help."
+              error ""
+              error e
+            end
+
             exit 1
           end
         end
       end
+
+      private
+        def looks_like_a_file_path?(code_or_file)
+          code_or_file.ends_with?(".rb")
+        end
     end
   end
 end

data/lib/rails/commands/secret/secret_command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class SecretCommand < Base # :nodoc:
+      desc "secret", "Generate a cryptographically secure secret key (this is typically used to generate a secret for cookie sessions)."
+      def perform
+        require "securerandom"
+        puts SecureRandom.hex(64)
+      end
+    end
+  end
+end

data/lib/rails/commands/secrets/USAGE

@@ -1,66 +1,61 @@
-=== ** DEPRECATED **
+Description:
+    ** DEPRECATED **
+    Rails 5.2 has introduced a new `credentials` API that replaces Rails secrets.
+    Please use the Rails `credentials` commands instead.
+    Run `bin/rails credentials:help` for more information.
 
-Rails 5.2 has introduced a new `credentials` API that replaces Rails secrets.
-Please use the Rails `credentials` commands instead.
-Run `rails credentials:help` for more information.
+    The Rails `secrets` commands helps encrypting secrets to slim a production
+    environment's `ENV` hash. It's also useful for atomic deploys: no need to
+    coordinate key changes to get everything working as the keys are shipped
+    with the code.
 
-=== Storing Encrypted Secrets in Source Control
+Setup:
+    Run `<%= executable(:setup) %>` to opt in and generate the `config/secrets.yml.key`
+    and `config/secrets.yml.enc` files.
 
-The Rails `secrets` commands helps encrypting secrets to slim a production
-environment's `ENV` hash. It's also useful for atomic deploys: no need to
-coordinate key changes to get everything working as the keys are shipped
-with the code.
+    The latter contains all the keys to be encrypted while the former holds the
+    encryption key.
 
-=== Setup
+    Don't lose the key! Put it in a password manager your team can access.
+    Should you lose it no one, including you, will be able to access any encrypted
+    secrets.
+    Don't commit the key! Add `config/secrets.yml.key` to your source control's
+    ignore file. If you use Git, Rails handles this for you.
 
-Run `bin/rails secrets:setup` to opt in and generate the `config/secrets.yml.key`
-and `config/secrets.yml.enc` files.
+    Rails also looks for the key in `ENV["RAILS_MASTER_KEY"]` if that's easier to
+    manage.
 
-The latter contains all the keys to be encrypted while the former holds the
-encryption key.
+    You could prepend that to your server's start command like this:
 
-Don't lose the key! Put it in a password manager your team can access.
-Should you lose it no one, including you, will be able to access any encrypted
-secrets.
-Don't commit the key! Add `config/secrets.yml.key` to your source control's
-ignore file. If you use Git, Rails handles this for you.
+        RAILS_MASTER_KEY="im-the-master-now-hahaha" server.start
 
-Rails also looks for the key in `ENV["RAILS_MASTER_KEY"]` if that's easier to
-manage.
+    The `config/secrets.yml.enc` has much the same format as `config/secrets.yml`:
 
-You could prepend that to your server's start command like this:
+        production:
+          secret_key_base: so-secret-very-hidden-wow
+          payment_processing_gateway_key: much-safe-very-gaedwey-wow
 
-   RAILS_MASTER_KEY="im-the-master-now-hahaha" server.start
+    But that's where the similarities between `secrets.yml` and `secrets.yml.enc`
+    end, e.g. no keys from `secrets.yml` will be moved to `secrets.yml.enc` and
+    be encrypted.
 
+    A `shared:` top level key is also supported such that any keys there is merged
+    into the other environments.
 
-The `config/secrets.yml.enc` has much the same format as `config/secrets.yml`:
+    Additionally, Rails won't read encrypted secrets out of the box even if you have
+    the key. Add this:
 
-   production:
-     secret_key_base: so-secret-very-hidden-wow
-     payment_processing_gateway_key: much-safe-very-gaedwey-wow
+        config.read_encrypted_secrets = true
 
-But that's where the similarities between `secrets.yml` and `secrets.yml.enc`
-end, e.g. no keys from `secrets.yml` will be moved to `secrets.yml.enc` and
-be encrypted.
+    to the environment you'd like to read encrypted secrets. `<%= executable(:setup) %>`
+    inserts this into the production environment by default.
 
-A `shared:` top level key is also supported such that any keys there is merged
-into the other environments.
+Editing Secrets:
+    After `<%= executable(:setup) %>`, run `<%= executable(:edit) %>`.
 
-Additionally, Rails won't read encrypted secrets out of the box even if you have
-the key. Add this:
+    That command opens a temporary file in `$VISUAL` or `$EDITOR` with the decrypted
+    contents of `config/secrets.yml.enc` to edit the encrypted secrets.
 
-   config.read_encrypted_secrets = true
-
-to the environment you'd like to read encrypted secrets. `bin/rails secrets:setup`
-inserts this into the production environment by default.
-
-=== Editing Secrets
-
-After `bin/rails secrets:setup`, run `bin/rails secrets:edit`.
-
-That command opens a temporary file in `$EDITOR` with the decrypted contents of
-`config/secrets.yml.enc` to edit the encrypted secrets.
-
-When the temporary file is next saved the contents are encrypted and written to
-`config/secrets.yml.enc` while the file itself is destroyed to prevent secrets
-from leaking.
+    When the temporary file is next saved the contents are encrypted and written to
+    `config/secrets.yml.enc` while the file itself is destroyed to prevent secrets
+    from leaking.

data/lib/rails/commands/secrets/secrets_command.rb

@@ -2,64 +2,45 @@
 
 require "active_support"
 require "rails/secrets"
+require "rails/command/helpers/editor"
 
 module Rails
   module Command
     class SecretsCommand < Rails::Command::Base # :nodoc:
-      no_commands do
-        def help
-          say "Usage:\n  #{self.class.banner}"
-          say ""
-          say self.class.desc
-        end
-      end
-
-      def setup
-        deprecate_in_favor_of_credentials_and_exit
-      end
+      include Helpers::Editor
 
+      desc "edit", "**deprecated** Open the secrets in `$VISUAL` or `$EDITOR` for editing"
       def edit
-        if ENV["EDITOR"].to_s.empty?
-          say "No $EDITOR to open decrypted secrets in. Assign one like this:"
-          say ""
-          say %(EDITOR="mate --wait" rails secrets:edit)
-          say ""
-          say "For editors that fork and exit immediately, it's important to pass a wait flag,"
-          say "otherwise the secrets will be saved immediately with no chance to edit."
+        Rails.deprecator.warn(<<~MSG.squish)
+          `bin/rails secrets:edit` is deprecated in favor of credentials and will be removed in Rails 7.2.
+          Run `bin/rails credentials:help` for more information.
+        MSG
 
-          return
-        end
-
-        require_application_and_environment!
+        boot_application!
 
-        Rails::Secrets.read_for_editing do |tmp_path|
-          system("#{ENV["EDITOR"]} #{tmp_path}")
+        using_system_editor do
+          Rails::Secrets.read_for_editing { |tmp_path| system_editor(tmp_path) }
+          say "File encrypted and saved."
         end
-
-        say "New secrets encrypted and saved."
-      rescue Interrupt
-        say "Aborted changing encrypted secrets: nothing saved."
       rescue Rails::Secrets::MissingKeyError => error
         say error.message
       rescue Errno::ENOENT => error
-        if /secrets\.yml\.enc/.match?(error.message)
-          deprecate_in_favor_of_credentials_and_exit
+        if error.message.include?("secrets.yml.enc")
+          exit 1
         else
           raise
         end
       end
 
+      desc "show", "**deprecated** Show the decrypted secrets"
       def show
+        Rails.deprecator.warn(<<~MSG.squish)
+          `bin/rails secrets:show` is deprecated in favor of credentials and will be removed in Rails 7.2.
+          Run `bin/rails credentials:help` for more information.
+        MSG
+
         say Rails::Secrets.read
       end
-
-      private
-        def deprecate_in_favor_of_credentials_and_exit
-          say "Encrypted secrets is deprecated in favor of credentials. Run:"
-          say "rails credentials:help"
-
-          exit 1
-        end
     end
   end
 end

data/lib/rails/commands/server/server_command.rb

@@ -3,12 +3,12 @@
 require "fileutils"
 require "action_dispatch"
 require "rails"
-require "active_support/core_ext/string/filters"
 require "rails/dev_caching"
 require "rails/command/environment_argument"
+require "rails/rackup/server"
 
 module Rails
-  class Server < ::Rack::Server
+  class Server < Rackup::Server
     class Options
       def parse!(args)
         Rails::Command::ServerCommand.new([], args).server_options
@@ -79,13 +79,13 @@ module Rails
         console.formatter = Rails.logger.formatter
         console.level = Rails.logger.level
 
-        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
+        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
           Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
         end
       end
 
       def use_puma?
-        server.to_s == "Rack::Handler::Puma"
+        server.to_s.end_with?("Handler::Puma")
       end
   end
 
@@ -93,30 +93,32 @@ module Rails
     class ServerCommand < Base # :nodoc:
       include EnvironmentArgument
 
+      RACK_HANDLER_GEMS = %w(cgi webrick scgi thin puma unicorn falcon)
       # Hard-coding a bunch of handlers here as we don't have a public way of
-      # querying them from the Rack::Handler registry.
-      RACK_SERVERS = %w(cgi fastcgi webrick lsws scgi thin puma unicorn falcon)
+      # querying them from the Rackup::Handler registry.
+      RACK_HANDLERS = RACK_HANDLER_GEMS + %w(fastcgi lsws)
+      RECOMMENDED_SERVER = "puma"
 
       DEFAULT_PORT = 3000
       DEFAULT_PIDFILE = "tmp/pids/server.pid"
 
       class_option :port, aliases: "-p", type: :numeric,
-        desc: "Runs Rails on the specified port - defaults to 3000.", banner: :port
+        desc: "Run Rails on the specified port - defaults to 3000.", banner: :port
       class_option :binding, aliases: "-b", type: :string,
-        desc: "Binds Rails to the specified IP - defaults to 'localhost' in development and '0.0.0.0' in other environments'.",
+        desc: "Bind Rails to the specified IP - defaults to 'localhost' in development and '0.0.0.0' in other environments'.",
         banner: :IP
       class_option :config, aliases: "-c", type: :string, default: "config.ru",
-        desc: "Uses a custom rackup configuration.", banner: :file
+        desc: "Use a custom rackup configuration.", banner: :file
       class_option :daemon, aliases: "-d", type: :boolean, default: false,
-        desc: "Runs server as a Daemon."
+        desc: "Run server as a Daemon."
       class_option :using, aliases: "-u", type: :string,
-        desc: "Specifies the Rack server used to run the application (thin/puma/webrick).", banner: :name
+        desc: "Specify the Rack server used to run the application (thin/puma/webrick).", banner: :name
       class_option :pid, aliases: "-P", type: :string,
-        desc: "Specifies the PID file - defaults to #{DEFAULT_PIDFILE}."
+        desc: "Specify the PID file - defaults to #{DEFAULT_PIDFILE}."
       class_option :dev_caching, aliases: "-C", type: :boolean, default: nil,
-        desc: "Specifies whether to perform caching in development."
+        desc: "Specify whether to perform caching in development."
       class_option :restart, type: :boolean, default: nil, hide: true
-      class_option :early_hints, type: :boolean, default: nil, desc: "Enables HTTP/2 early hints."
+      class_option :early_hints, type: :boolean, default: nil, desc: "Enable HTTP/2 early hints."
       class_option :log_to_stdout, type: :boolean, default: nil, optional: true,
         desc: "Whether to log to stdout. Enabled by default in development when not daemonized."
 
@@ -126,8 +128,8 @@ module Rails
         @original_options = local_options - %w( --restart )
       end
 
+      desc "server", "Start the Rails server"
       def perform
-        extract_environment_option_from_argument
         set_application_directory!
         prepare_restart
 
@@ -227,7 +229,7 @@ module Rails
         end
 
         def restart_command
-          "bin/rails server #{@original_options.join(" ")} --restart"
+          "#{executable} #{@original_options.join(" ")} --restart"
         end
 
         def early_hints
@@ -244,33 +246,32 @@ module Rails
           File.expand_path(options[:pid] || ENV.fetch("PIDFILE", DEFAULT_PIDFILE))
         end
 
-        def self.banner(*)
-          "rails server -u [thin/puma/webrick] [options]"
-        end
-
         def prepare_restart
           FileUtils.rm_f(pid) if options[:restart]
         end
 
         def rack_server_suggestion(server)
-          if server.in?(RACK_SERVERS)
+          if server.nil?
+            <<~MSG
+              Could not find a server gem. Maybe you need to add one to the Gemfile?
+
+                gem "#{RECOMMENDED_SERVER}"
+
+              Run `#{executable} --help` for more options.
+            MSG
+          elsif server.in?(RACK_HANDLER_GEMS)
             <<~MSG
               Could not load server "#{server}". Maybe you need to the add it to the Gemfile?
 
                 gem "#{server}"
 
-              Run `bin/rails server --help` for more options.
+              Run `#{executable} --help` for more options.
             MSG
           else
-            error = CorrectableError.new("Could not find server '#{server}'.", server, RACK_SERVERS)
-            if error.respond_to?(:detailed_message)
-              formatted_message = error.detailed_message
-            else
-              formatted_message = error.message
-            end
+            error = CorrectableNameError.new("Could not find server '#{server}'.", server, RACK_HANDLERS)
             <<~MSG
-              #{formatted_message}
-              Run `bin/rails server --help` for more options.
+              #{error.detailed_message}
+              Run `#{executable} --help` for more options.
             MSG
           end
         end
@@ -279,7 +280,7 @@ module Rails
           say <<~MSG
             => Booting #{ActiveSupport::Inflector.demodulize(server)}
             => Rails #{Rails.version} application starting in #{Rails.env} #{url}
-            => Run `bin/rails server --help` for more startup options
+            => Run `#{executable} --help` for more startup options
           MSG
         end
     end

data/lib/rails/commands/test/USAGE

@@ -0,0 +1,14 @@
+Examples:
+    You can run a single test by appending a line number to a filename:
+
+        <%= executable %> test/models/user_test.rb:27
+
+    You can run multiple tests with in a line range by appending the line range to a filename:
+
+        <%= executable %> test/models/user_test.rb:10-20
+
+    You can run multiple files and directories at the same time:
+
+        <%= executable %> test/controllers test/integration/login_test.rb
+
+    By default test failures and errors are reported inline during a run.

data/lib/rails/commands/test/test_command.rb

@@ -1,37 +1,79 @@
 # frozen_string_literal: true
 
 require "rails/command"
+require "rails/commands/rake/rake_command"
 require "rails/test_unit/runner"
 require "rails/test_unit/reporter"
 
 module Rails
   module Command
     class TestCommand < Base # :nodoc:
+      def self.executable(*args)
+        args.empty? ? Rails::TestUnitReporter.executable : super
+      end
+
       no_commands do
-        def help
-          say "Usage: #{Rails::TestUnitReporter.executable} [options] [files or directories]"
-          say ""
-          say "You can run a single test by appending a line number to a filename:"
-          say ""
-          say "    #{Rails::TestUnitReporter.executable} test/models/user_test.rb:27"
-          say ""
-          say "You can run multiple files and directories at the same time:"
-          say ""
-          say "    #{Rails::TestUnitReporter.executable} test/controllers test/integration/login_test.rb"
+        def help(command_name = nil, *)
+          super
+          if command_name == "test"
+            say ""
+            say self.class.class_usage
+          end
           say ""
-          say "By default test failures and errors are reported inline during a run."
-          say ""
-
           Minitest.run(%w(--help))
         end
       end
 
-      def perform(*)
+      desc "test [PATHS...]", "Run tests except system tests"
+      def perform(*args)
         $LOAD_PATH << Rails::Command.root.join("test").to_s
 
         Rails::TestUnit::Runner.parse_options(args)
+        run_prepare_task if self.args.none?(EXACT_TEST_ARGUMENT_PATTERN)
         Rails::TestUnit::Runner.run(args)
       end
+
+      # Define Thor tasks to avoid going through Rake and booting twice when using bin/rails test:*
+      Rails::TestUnit::Runner::TEST_FOLDERS.each do |name|
+        desc name, "Run tests in test/#{name}"
+        define_method(name) do |*args|
+          perform("test/#{name}", *args)
+        end
+      end
+
+      desc "all", "Run all tests, including system tests"
+      def all(*args)
+        perform("test/**/*_test.rb", *args)
+      end
+
+      desc "functionals", "Run tests in test/controllers, test/mailers, and test/functional"
+      def functionals(*args)
+        perform("test/controllers", "test/mailers", "test/functional", *args)
+      end
+
+      desc "units", "Run tests in test/models, test/helpers, and test/unit"
+      def units(*args)
+        perform("test/models", "test/helpers", "test/unit", *args)
+      end
+
+      desc "system", "Run system tests only"
+      def system(*args)
+        perform("test/system", *args)
+      end
+
+      desc "generators", "Run tests in test/lib/generators"
+      def generators(*args)
+        perform("test/lib/generators", *args)
+      end
+
+      private
+        EXACT_TEST_ARGUMENT_PATTERN = /^-n|^--name\b|#{Rails::TestUnit::Runner::PATH_ARGUMENT_PATTERN}/
+
+        def run_prepare_task
+          Rails::Command::RakeCommand.perform("test:prepare", [], {})
+        rescue UnrecognizedCommandError => error
+          raise unless error.name == "test:prepare"
+        end
     end
   end
 end

data/lib/rails/commands/unused_routes/unused_routes_command.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rails/commands/routes/routes_command"
+
+module Rails
+  module Command
+    class UnusedRoutesCommand < Rails::Command::Base # :nodoc:
+      hide_command!
+      class_option :controller, aliases: "-c", desc: "Filter by a specific controller, e.g. PostsController or Admin::PostsController."
+      class_option :grep, aliases: "-g", desc: "Grep routes by a specific pattern."
+
+      class RouteInfo
+        def initialize(route)
+          requirements = route.requirements
+          @controller_name = requirements[:controller]
+          @action_name = requirements[:action]
+          @controller_class = (@controller_name.to_s.camelize + "Controller").safe_constantize
+        end
+
+        def unused?
+          controller_class_missing? || (action_missing? && template_missing?)
+        end
+
+        private
+          def view_path(root)
+            File.join(root.path, @controller_name, @action_name)
+          end
+
+          def controller_class_missing?
+            @controller_name && @controller_class.nil?
+          end
+
+          def template_missing?
+            @controller_class && @controller_class.try(:view_paths).to_a.flat_map { |path| Dir["#{view_path(path)}.*"] }.none?
+          end
+
+          def action_missing?
+            @controller_class && @controller_class.instance_methods.exclude?(@action_name.to_sym)
+          end
+      end
+
+      def perform(*)
+        boot_application!
+        require "action_dispatch/routing/inspector"
+
+        say(inspector.format(formatter, routes_filter))
+
+        exit(1) if routes.any?
+      end
+
+      private
+        def inspector
+          ActionDispatch::Routing::RoutesInspector.new(routes)
+        end
+
+        def routes
+          @routes ||= begin
+            routes = Rails.application.routes.routes.select do |route|
+              RouteInfo.new(route).unused?
+            end
+
+            ActionDispatch::Journey::Routes.new(routes)
+          end
+        end
+
+        def formatter
+          ActionDispatch::Routing::ConsoleFormatter::Unused.new
+        end
+
+        def routes_filter
+          options.symbolize_keys.slice(:controller, :grep)
+        end
+    end
+  end
+end