railties 6.0.0 → 7.1.3.2

data/lib/rails/commands/rake/rake_command.rb

@@ -9,41 +9,45 @@ module Rails
 
       class << self
         def printing_commands
-          formatted_rake_tasks.map(&:first)
+          rake_tasks.filter_map do |task|
+            if task.comment && task.locations.any?(non_app_file_pattern)
+              [task.name_with_args, task.comment]
+            end
+          end
         end
 
-        def perform(task, *)
-          require_rake
-
-          ARGV.unshift(task) # Prepend the task, so Rake knows how to run it.
+        def perform(task, args, config)
+          with_rake(task, *args) do |rake|
+            if unrecognized_task = rake.top_level_tasks.find { |task| !rake.lookup(task[/[^\[]+/]) }
+              @rake_tasks = rake.tasks
+              raise UnrecognizedCommandError.new(unrecognized_task)
+            end
 
-          Rake.application.standard_exception_handling do
-            Rake.application.init("rails")
-            Rake.application.load_rakefile
-            Rake.application.top_level
+            rake.options.suppress_backtrace_pattern = non_app_file_pattern
+            rake.standard_exception_handling { rake.top_level }
           end
         end
 
         private
-          def rake_tasks
-            require_rake
-
-            return @rake_tasks if defined?(@rake_tasks)
-
-            require_application_and_environment!
+          def non_app_file_pattern
+            /\A(?!#{Regexp.quote Rails::Command.root.to_s})/
+          end
 
+          def with_rake(*args, &block)
+            require "rake"
             Rake::TaskManager.record_task_metadata = true
-            Rake.application.instance_variable_set(:@name, "rails")
-            load_tasks
-            @rake_tasks = Rake.application.tasks.select(&:comment)
-          end
 
-          def formatted_rake_tasks
-            rake_tasks.map { |t| [ t.name_with_args, t.comment ] }
+            result = nil
+            Rake.with_application do |rake|
+              rake.init(bin, args) unless args.empty?
+              rake.load_rakefile
+              result = block.call(rake)
+            end
+            result
           end
 
-          def require_rake
-            require "rake" # Defer booting Rake until we know it's needed.
+          def rake_tasks
+            @rake_tasks ||= with_rake(&:tasks)
           end
       end
     end

data/lib/rails/commands/restart/restart_command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class RestartCommand < Base # :nodoc:
+      desc "restart", "Restart app by touching tmp/restart.txt"
+      def perform
+        require "fileutils"
+        FileUtils.mkdir_p Rails::Command.application_root.join("tmp")
+        FileUtils.touch   Rails::Command.application_root.join("tmp/restart.txt")
+      end
+    end
+  end
+end

data/lib/rails/commands/routes/routes_command.rb

@@ -8,9 +8,21 @@ module Rails
       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_option :expanded, type: :boolean, aliases: "-E", desc: "Print routes expanded vertically with parts explained."
+      class_option :unused, type: :boolean, aliases: "-u", desc: "Print unused routes."
 
+      no_commands do
+        def invoke_command(*)
+          if options.key?("unused")
+            Rails::Command.invoke "unused_routes", ARGV
+          else
+            super
+          end
+        end
+      end
+
+      desc "routes", "List all the defined routes"
       def perform(*)
-        require_application_and_environment!
+        boot_application!
         require "action_dispatch/routing/inspector"
 
         say inspector.format(formatter, routes_filter)

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,51 +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)
-          $0 = code_or_file
-          Kernel.load code_or_file
+          expanded_file_path = File.expand_path code_or_file
+          $0 = 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,60 +1,61 @@
-=== Storing Encrypted Secrets in Source Control
+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.
 
-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 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.
 
-=== Setup
+Setup:
+    Run `<%= executable(:setup) %>` to opt in and generate the `config/secrets.yml.key`
+    and `config/secrets.yml.enc` files.
 
-Run `rails secrets:setup` to opt in and generate the `config/secrets.yml.key`
-and `config/secrets.yml.enc` files.
+    The latter contains all the keys to be encrypted while the former holds the
+    encryption key.
 
-The latter contains all the keys to be encrypted while the former holds the
-encryption key.
+    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.
 
-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 also looks for the key in `ENV["RAILS_MASTER_KEY"]` if that's easier to
+    manage.
 
-Rails also looks for the key in `ENV["RAILS_MASTER_KEY"]` if that's easier to
-manage.
+    You could prepend that to your server's start command like this:
 
-You could prepend that to your server's start command like this:
+        RAILS_MASTER_KEY="im-the-master-now-hahaha" bin/rails server
 
-   RAILS_MASTER_KEY="im-the-master-now-hahaha" server.start
+    The `config/secrets.yml.enc` has much the same format as `config/secrets.yml`:
 
+        production:
+          secret_key_base: so-secret-very-hidden-wow
+          payment_processing_gateway_key: much-safe-very-gaedwey-wow
 
-The `config/secrets.yml.enc` has much the same format as `config/secrets.yml`:
+    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.
 
-   production:
-     secret_key_base: so-secret-very-hidden-wow
-     payment_processing_gateway_key: much-safe-very-gaedwey-wow
+    A `shared:` top level key is also supported such that any keys there is merged
+    into the other environments.
 
-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.
+    Additionally, Rails won't read encrypted secrets out of the box even if you have
+    the key. Add this:
 
-A `shared:` top level key is also supported such that any keys there is merged
-into the other environments.
+        config.read_encrypted_secrets = true
 
-Additionally, Rails won't read encrypted secrets out of the box even if you have
-the key. Add this:
+    to the environment you'd like to read encrypted secrets. `<%= executable(:setup) %>`
+    inserts this into the production environment by default.
 
-   config.read_encrypted_secrets = true
+Editing Secrets:
+    After `<%= executable(:setup) %>`, run `<%= executable(:edit) %>`.
 
-to the environment you'd like to read encrypted secrets. `rails secrets:setup`
-inserts this into the production environment by default.
+    That command opens a temporary file in `$VISUAL` or `$EDITOR` with the decrypted
+    contents of `config/secrets.yml.enc` to edit the encrypted secrets.
 
-=== Editing Secrets
-
-After `rails secrets:setup`, run `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

@@ -1,65 +1,47 @@
 # frozen_string_literal: true
 
 require "active_support"
+require "active_support/core_ext/string/filters"
 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,13 +3,12 @@
 require "fileutils"
 require "action_dispatch"
 require "rails"
-require "active_support/deprecation"
-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
@@ -80,13 +79,13 @@ module Rails
         console.formatter = Rails.logger.formatter
         console.level = Rails.logger.level
 
-        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
-          Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
+        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
+          Rails.logger.broadcast_to(console)
         end
       end
 
       def use_puma?
-        server.to_s == "Rack::Handler::Puma"
+        server.to_s.end_with?("Handler::Puma")
       end
   end
 
@@ -94,32 +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)
+      # querying them from the Rackup::Handler registry.
+      RACK_HANDLERS = RACK_HANDLER_GEMS + %w(fastcgi lsws)
+      RECOMMENDED_SERVER = "puma"
 
       DEFAULT_PORT = 3000
-      DEFAULT_PID_PATH = "tmp/pids/server.pid"
-
-      argument :using, optional: true
+      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
-      class_option :pid, aliases: "-P", type: :string, default: DEFAULT_PID_PATH,
-        desc: "Specifies the PID file."
+        desc: "Specify the Rack server used to run the application (thin/puma/webrick).", banner: :name
+      class_option :pid, aliases: "-P", type: :string,
+        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."
 
@@ -127,11 +126,10 @@ module Rails
         super
 
         @original_options = local_options - %w( --restart )
-        deprecate_positional_rack_server_and_rewrite_to_option(@original_options)
       end
 
+      desc "server", "Start the Rails server"
       def perform
-        extract_environment_option_from_argument
         set_application_directory!
         prepare_restart
 
@@ -146,7 +144,7 @@ module Rails
             after_stop_callback = -> { say "Exiting" unless options[:daemon] }
             server.start(after_stop_callback)
           else
-            say rack_server_suggestion(using)
+            say rack_server_suggestion(options[:using])
           end
         end
       end
@@ -155,7 +153,7 @@ module Rails
         def server_options
           {
             user_supplied_options: user_supplied_options,
-            server:                using,
+            server:                options[:using],
             log_stdout:            log_to_stdout?,
             Port:                  port,
             Host:                  host,
@@ -178,7 +176,7 @@ module Rails
             #   ["-p3001", "-C", "--binding", "127.0.0.1"] # => {"-p"=>true, "-C"=>true, "--binding"=>true}
             user_flag = {}
             @original_options.each do |command|
-              if command.to_s.start_with?("--")
+              if command.start_with?("--")
                 option = command.split("=")[0]
                 user_flag[option] = true
               elsif command =~ /\A(-.)/
@@ -207,6 +205,7 @@ module Rails
             end
             user_supplied_options << :Host if ENV["HOST"] || ENV["BINDING"]
             user_supplied_options << :Port if ENV["PORT"]
+            user_supplied_options << :pid if ENV["PIDFILE"]
             user_supplied_options.uniq
           end
         end
@@ -221,15 +220,6 @@ module Rails
           else
             default_host = environment == "development" ? "localhost" : "0.0.0.0"
 
-            if ENV["HOST"] && !ENV["BINDING"]
-              ActiveSupport::Deprecation.warn(<<-MSG.squish)
-                Using the `HOST` environment variable to specify the IP is deprecated and will be removed in Rails 6.1.
-                Please use `BINDING` environment variable instead.
-              MSG
-
-              return ENV["HOST"]
-            end
-
             ENV.fetch("BINDING", default_host)
           end
         end
@@ -239,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
@@ -253,49 +243,35 @@ module Rails
         end
 
         def pid
-          File.expand_path(options[:pid])
-        end
-
-        def self.banner(*)
-          "rails server -u [thin/puma/webrick] [options]"
+          File.expand_path(options[:pid] || ENV.fetch("PIDFILE", DEFAULT_PIDFILE))
         end
 
         def prepare_restart
-          FileUtils.rm_f(options[:pid]) if options[:restart]
+          FileUtils.rm_f(pid) if options[:restart]
         end
 
-        def deprecate_positional_rack_server_and_rewrite_to_option(original_options)
-          if using
-            ActiveSupport::Deprecation.warn(<<~MSG.squish)
-              Passing the Rack server name as a regular argument is deprecated
-              and will be removed in the next Rails version. Please, use the -u
-              option instead.
-            MSG
+        def rack_server_suggestion(server)
+          if server.nil?
+            <<~MSG
+              Could not find a server gem. Maybe you need to add one to the Gemfile?
 
-            original_options.concat [ "-u", using ]
-          else
-            # Use positional internally to get around Thor's immutable options.
-            # TODO: Replace `using` occurrences with `options[:using]` after deprecation removal.
-            @using = options[:using]
-          end
-        end
+                gem "#{RECOMMENDED_SERVER}"
 
-        def rack_server_suggestion(server)
-          if server.in?(RACK_SERVERS)
+              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 `rails server --help` for more options.
+              Run `#{executable} --help` for more options.
             MSG
           else
-            suggestion = Rails::Command::Spellchecker.suggest(server, from: RACK_SERVERS)
-            suggestion_msg = "Maybe you meant #{suggestion.inspect}?" if suggestion
-
+            error = CorrectableNameError.new("Could not find server '#{server}'.", server, RACK_HANDLERS)
             <<~MSG
-              Could not find server "#{server}". #{suggestion_msg}
-              Run `rails server --help` for more options.
+              #{error.detailed_message}
+              Run `#{executable} --help` for more options.
             MSG
           end
         end
@@ -304,7 +280,7 @@ module Rails
           say <<~MSG
             => Booting #{ActiveSupport::Inflector.demodulize(server)}
             => Rails #{Rails.version} application starting in #{Rails.env} #{url}
-            => Run `rails server --help` for more startup options
+            => Run `#{executable} --help` for more startup options
           MSG
         end
     end