railties 5.2.7.1 → 6.1.4.6

data/lib/rails/commands/initializers/initializers_command.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class InitializersCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      desc "initializers", "Print out all defined initializers in the order they are invoked by Rails."
+      def perform
+        extract_environment_option_from_argument
+        ENV["RAILS_ENV"] = options[:environment]
+
+        require_application_and_environment!
+
+        Rails.application.initializers.tsort_each do |initializer|
+          say "#{initializer.context_class}.#{initializer.name}"
+        end
+      end
+    end
+  end
+end

data/lib/rails/commands/new/new_command.rb

@@ -10,8 +10,8 @@ module Rails
       end
 
       def perform(*)
-        puts "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
-        puts "Type 'rails' for help."
+        say "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
+        say "Type 'rails' for help."
         exit 1
       end
     end

data/lib/rails/commands/notes/notes_command.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/source_annotation_extractor"
+
+module Rails
+  module Command
+    class NotesCommand < Base # :nodoc:
+      class_option :annotations, aliases: "-a", desc: "Filter by specific annotations, e.g. Foobar TODO", type: :array
+
+      def perform(*)
+        require_application_and_environment!
+
+        display_annotations
+      end
+
+      private
+        def display_annotations
+          annotations = options[:annotations] || Rails::SourceAnnotationExtractor::Annotation.tags
+          tag = (annotations.length > 1)
+
+          Rails::SourceAnnotationExtractor.enumerate annotations.join("|"), tag: tag, dirs: directories
+        end
+
+        def directories
+          Rails::SourceAnnotationExtractor::Annotation.directories
+        end
+    end
+  end
+end

data/lib/rails/commands/plugin/plugin_command.rb

@@ -26,7 +26,7 @@ module Rails
 
           if File.exist?(railsrc)
             extra_args = File.read(railsrc).split(/\n+/).flat_map(&:split)
-            puts "Using #{extra_args.join(" ")} from #{railsrc}"
+            say "Using #{extra_args.join(" ")} from #{railsrc}"
             plugin_args.insert(1, *extra_args)
           end
         end

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

@@ -12,15 +12,16 @@ module Rails
           formatted_rake_tasks.map(&:first)
         end
 
-        def perform(task, *)
+        def perform(task, args, config)
           require_rake
 
-          ARGV.unshift(task) # Prepend the task, so Rake knows how to run it.
-
-          Rake.application.standard_exception_handling do
-            Rake.application.init("rails")
-            Rake.application.load_rakefile
-            Rake.application.top_level
+          Rake.with_application do |rake|
+            rake.init("rails", [task, *args])
+            rake.load_rakefile
+            if Rails.respond_to?(:root)
+              rake.options.suppress_backtrace_pattern = /\A(?!#{Regexp.quote(Rails.root.to_s)})/
+            end
+            rake.standard_exception_handling { rake.top_level }
           end
         end
 
@@ -30,7 +31,7 @@ module Rails
 
             return @rake_tasks if defined?(@rake_tasks)
 
-            require_application_and_environment!
+            require_application!
 
             Rake::TaskManager.record_task_metadata = true
             Rake.application.instance_variable_set(:@name, "rails")

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rails/command"
+
+module Rails
+  module Command
+    class RoutesCommand < Base # :nodoc:
+      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."
+
+      def perform(*)
+        require_application_and_environment!
+        require "action_dispatch/routing/inspector"
+
+        say inspector.format(formatter, routes_filter)
+      end
+
+      private
+        def inspector
+          ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes)
+        end
+
+        def formatter
+          if options.key?("expanded")
+            ActionDispatch::Routing::ConsoleFormatter::Expanded.new
+          else
+            ActionDispatch::Routing::ConsoleFormatter::Sheet.new
+          end
+        end
+
+        def routes_filter
+          options.symbolize_keys.slice(:controller, :grep)
+        end
+    end
+  end
+end

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

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
+require "rails/command/environment_argument"
+
 module Rails
   module Command
     class RunnerCommand < Base # :nodoc:
-      class_option :environment, aliases: "-e", type: :string,
-        default: Rails::Command.environment.dup,
-        desc: "The environment for the runner to operate under (test/development/production)"
+      include EnvironmentArgument
+
+      self.environment_desc = "The environment for the runner to operate under (test/development/production)"
 
       no_commands do
         def help
           super
-          puts self.class.desc
+          say self.class.desc
         end
       end
 
@@ -19,6 +21,8 @@ module Rails
       end
 
       def perform(code_or_file = nil, *command_argv)
+        extract_environment_option_from_argument
+
         unless code_or_file
           help
           exit 1
@@ -39,11 +43,11 @@ module Rails
         else
           begin
             eval(code_or_file, TOPLEVEL_BINDING, __FILE__, __LINE__)
-          rescue SyntaxError, NameError => error
-            $stderr.puts "Please specify a valid ruby command or the path of a script to run."
-            $stderr.puts "Run '#{self.class.executable} -h' for help."
-            $stderr.puts
-            $stderr.puts error
+          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
             exit 1
           end
         end

data/lib/rails/commands/secrets/USAGE

@@ -1,3 +1,9 @@
+=== ** DEPRECATED **
+
+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.
+
 === Storing Encrypted Secrets in Source Control
 
 The Rails `secrets` commands helps encrypting secrets to slim a production

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

@@ -22,7 +22,7 @@ module Rails
         if ENV["EDITOR"].to_s.empty?
           say "No $EDITOR to open decrypted secrets in. Assign one like this:"
           say ""
-          say %(EDITOR="mate --wait" bin/rails secrets:edit)
+          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."
@@ -42,7 +42,7 @@ module Rails
       rescue Rails::Secrets::MissingKeyError => error
         say error.message
       rescue Errno::ENOENT => error
-        if error.message =~ /secrets\.yml\.enc/
+        if /secrets\.yml\.enc/.match?(error.message)
           deprecate_in_favor_of_credentials_and_exit
         else
           raise
@@ -56,7 +56,7 @@ module Rails
       private
         def deprecate_in_favor_of_credentials_and_exit
           say "Encrypted secrets is deprecated in favor of credentials. Run:"
-          say "bin/rails credentials:help"
+          say "rails credentials:help"
 
           exit 1
         end

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require "optparse"
 require "action_dispatch"
 require "rails"
-require "active_support/deprecation"
 require "active_support/core_ext/string/filters"
+require "active_support/core_ext/symbol/starts_ends_with"
 require "rails/dev_caching"
+require "rails/command/environment_argument"
 
 module Rails
   class Server < ::Rack::Server
@@ -22,19 +22,6 @@ module Rails
       set_environment
     end
 
-    def app
-      @app ||= begin
-        app = super
-        if app.is_a?(Class)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Using `Rails::Application` subclass to start the server is deprecated and will be removed in Rails 6.0.
-            Please change `run #{app}` to `run Rails.application` in config.ru.
-          MSG
-        end
-        app.respond_to?(:to_app) ? app.to_app : app
-      end
-    end
-
     def opt_parser
       Options.new
     end
@@ -43,18 +30,22 @@ module Rails
       ENV["RAILS_ENV"] ||= options[:environment]
     end
 
-    def start
-      print_boot_information
+    def start(after_stop_callback = nil)
       trap(:INT) { exit }
       create_tmp_directories
       setup_dev_caching
       log_to_stdout if options[:log_stdout]
 
-      super
+      super()
     ensure
-      # The '-h' option calls exit before @options is set.
-      # If we call 'options' with it unset, we get double help banners.
-      puts "Exiting" unless @options && options[:daemonize]
+      after_stop_callback.call if after_stop_callback
+    end
+
+    def serveable? # :nodoc:
+      server
+      true
+    rescue LoadError, NameError
+      false
     end
 
     def middleware
@@ -65,6 +56,10 @@ module Rails
       super.merge(@default_options)
     end
 
+    def served_url
+      "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}" unless use_puma?
+    end
+
     private
       def setup_dev_caching
         if options[:environment] == "development"
@@ -72,13 +67,6 @@ module Rails
         end
       end
 
-      def print_boot_information
-        url = "on #{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}" unless use_puma?
-        puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
-        puts "=> Rails #{Rails.version} application starting in #{Rails.env} #{url}"
-        puts "=> Run `rails server -h` for more startup options"
-      end
-
       def create_tmp_directories
         %w(cache pids sockets).each do |dir_to_make|
           FileUtils.mkdir_p(File.join(Rails.root, "tmp", dir_to_make))
@@ -97,10 +85,6 @@ module Rails
         end
       end
 
-      def restart_command
-        "bin/rails server #{ARGV.join(' ')}"
-      end
-
       def use_puma?
         server.to_s == "Rack::Handler::Puma"
       end
@@ -108,8 +92,14 @@ module Rails
 
   module Command
     class ServerCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      # 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)
+
       DEFAULT_PORT = 3000
-      DEFAULT_PID_PATH = "tmp/pids/server.pid".freeze
+      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
@@ -120,31 +110,41 @@ module Rails
         desc: "Uses a custom rackup configuration.", banner: :file
       class_option :daemon, aliases: "-d", type: :boolean, default: false,
         desc: "Runs server as a Daemon."
-      class_option :environment, aliases: "-e", type: :string,
-        desc: "Specifies the environment to run this server under (development/test/production).", banner: :name
-      class_option :pid, aliases: "-P", type: :string, default: DEFAULT_PID_PATH,
-        desc: "Specifies the PID file."
-      class_option "dev-caching", aliases: "-C", type: :boolean, default: nil,
+      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,
+        desc: "Specifies 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."
-      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 :restart, type: :boolean, default: nil, hide: true
+      class_option :early_hints, type: :boolean, default: nil, desc: "Enables 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."
 
-      def initialize(args = [], local_options = {}, config = {})
-        @original_options = local_options
+      def initialize(args, local_options, *)
         super
-        @server = self.args.shift
-        @log_stdout = options[:daemon].blank? && (options[:environment] || Rails.env) == "development"
+
+        @original_options = local_options - %w( --restart )
       end
 
       def perform
+        extract_environment_option_from_argument
         set_application_directory!
         prepare_restart
+
         Rails::Server.new(server_options).tap do |server|
           # Require application after server sets environment to propagate
           # the --environment option.
           require APP_PATH
           Dir.chdir(Rails.application.root)
-          server.start
+
+          if server.serveable?
+            print_boot_information(server.server, server.served_url)
+            after_stop_callback = -> { say "Exiting" unless options[:daemon] }
+            server.start(after_stop_callback)
+          else
+            say rack_server_suggestion(options[:using])
+          end
         end
       end
 
@@ -152,8 +152,8 @@ module Rails
         def server_options
           {
             user_supplied_options: user_supplied_options,
-            server:                @server,
-            log_stdout:            @log_stdout,
+            server:                options[:using],
+            log_stdout:            log_to_stdout?,
             Port:                  port,
             Host:                  host,
             DoNotReverseLookup:    true,
@@ -161,7 +161,7 @@ module Rails
             environment:           environment,
             daemonize:             options[:daemon],
             pid:                   pid,
-            caching:               options["dev-caching"],
+            caching:               options[:dev_caching],
             restart_cmd:           restart_command,
             early_hints:           early_hints
           }
@@ -175,7 +175,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(-.)/
@@ -194,7 +194,7 @@ module Rails
                   name = :Port
                 when :binding
                   name = :Host
-                when :"dev-caching"
+                when :dev_caching
                   name = :caching
                 when :daemonize
                   name = :daemon
@@ -202,8 +202,9 @@ module Rails
                 user_supplied_options << name
               end
             end
-            user_supplied_options << :Host if ENV["HOST"]
+            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
@@ -217,7 +218,8 @@ module Rails
             options[:binding]
           else
             default_host = environment == "development" ? "localhost" : "0.0.0.0"
-            ENV.fetch("HOST", default_host)
+
+            ENV.fetch("BINDING", default_host)
           end
         end
 
@@ -226,23 +228,57 @@ module Rails
         end
 
         def restart_command
-          "bin/rails server #{@server} #{@original_options.join(" ")} --restart"
+          "bin/rails server #{@original_options.join(" ")} --restart"
         end
 
         def early_hints
           options[:early_hints]
         end
 
+        def log_to_stdout?
+          options.fetch(:log_to_stdout) do
+            options[:daemon].blank? && environment == "development"
+          end
+        end
+
         def pid
-          File.expand_path(options[:pid])
+          File.expand_path(options[:pid] || ENV.fetch("PIDFILE", DEFAULT_PIDFILE))
         end
 
         def self.banner(*)
-          "rails server [puma, thin etc] [options]"
+          "rails server -u [thin/puma/webrick] [options]"
         end
 
         def prepare_restart
-          FileUtils.rm_f(options[:pid]) if options[:restart]
+          FileUtils.rm_f(pid) if options[:restart]
+        end
+
+        def rack_server_suggestion(server)
+          if server.in?(RACK_SERVERS)
+            <<~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.
+            MSG
+          else
+            suggestion = Rails::Command::Spellchecker.suggest(server, from: RACK_SERVERS)
+            suggestion_msg = "Maybe you meant #{suggestion.inspect}?" if suggestion
+
+            <<~MSG
+              Could not find server "#{server}". #{suggestion_msg}
+              Run `bin/rails server --help` for more options.
+            MSG
+          end
+        end
+
+        def print_boot_information(server, url)
+          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
+          MSG
         end
     end
   end

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

@@ -29,8 +29,8 @@ module Rails
       def perform(*)
         $LOAD_PATH << Rails::Command.root.join("test").to_s
 
-        Rails::TestUnit::Runner.parse_options(ARGV)
-        Rails::TestUnit::Runner.run(ARGV)
+        Rails::TestUnit::Runner.parse_options(args)
+        Rails::TestUnit::Runner.run(args)
       end
     end
   end

data/lib/rails/configuration.rb

@@ -30,6 +30,15 @@ module Rails
     #
     #     config.middleware.swap ActionDispatch::Flash, Magical::Unicorns
     #
+    # Middlewares can be moved from one place to another:
+    #
+    #     config.middleware.move_before ActionDispatch::Flash, Magical::Unicorns
+    #
+    # This will move the <tt>Magical::Unicorns</tt> middleware before the
+    # <tt>ActionDispatch::Flash</tt>. You can also move it after:
+    #
+    #     config.middleware.move_after ActionDispatch::Flash, Magical::Unicorns
+    #
     # And finally they can also be removed from the stack completely:
     #
     #     config.middleware.delete ActionDispatch::Flash
@@ -41,34 +50,49 @@ module Rails
       end
 
       def insert_before(*args, &block)
-        @operations << [__method__, args, block]
+        @operations << -> middleware { middleware.insert_before(*args, &block) }
       end
+      ruby2_keywords(:insert_before) if respond_to?(:ruby2_keywords, true)
 
       alias :insert :insert_before
 
       def insert_after(*args, &block)
-        @operations << [__method__, args, block]
+        @operations << -> middleware { middleware.insert_after(*args, &block) }
       end
+      ruby2_keywords(:insert_after) if respond_to?(:ruby2_keywords, true)
 
       def swap(*args, &block)
-        @operations << [__method__, args, block]
+        @operations << -> middleware { middleware.swap(*args, &block) }
       end
+      ruby2_keywords(:swap) if respond_to?(:ruby2_keywords, true)
 
       def use(*args, &block)
-        @operations << [__method__, args, block]
+        @operations << -> middleware { middleware.use(*args, &block) }
       end
+      ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
 
       def delete(*args, &block)
-        @delete_operations << [__method__, args, block]
+        @delete_operations << -> middleware { middleware.delete(*args, &block) }
+      end
+
+      def move_before(*args, &block)
+        @delete_operations << -> middleware { middleware.move_before(*args, &block) }
+      end
+
+      alias :move :move_before
+
+      def move_after(*args, &block)
+        @delete_operations << -> middleware { middleware.move_after(*args, &block) }
       end
 
       def unshift(*args, &block)
-        @operations << [__method__, args, block]
+        @operations << -> middleware { middleware.unshift(*args, &block) }
       end
+      ruby2_keywords(:unshift) if respond_to?(:ruby2_keywords, true)
 
       def merge_into(other) #:nodoc:
-        (@operations + @delete_operations).each do |operation, args, block|
-          other.send(operation, *args, &block)
+        (@operations + @delete_operations).each do |operation|
+          operation.call(other)
         end
 
         other
@@ -79,18 +103,12 @@ module Rails
       end
 
       protected
-        def operations
-          @operations
-        end
-
-        def delete_operations
-          @delete_operations
-        end
+        attr_reader :operations, :delete_operations
     end
 
     class Generators #:nodoc:
       attr_accessor :aliases, :options, :templates, :fallbacks, :colorize_logging, :api_only
-      attr_reader :hidden_namespaces
+      attr_reader :hidden_namespaces, :after_generate_callbacks
 
       def initialize
         @aliases = Hash.new { |h, k| h[k] = {} }
@@ -100,6 +118,7 @@ module Rails
         @colorize_logging = true
         @api_only = false
         @hidden_namespaces = []
+        @after_generate_callbacks = []
       end
 
       def initialize_copy(source)
@@ -113,10 +132,20 @@ module Rails
         @hidden_namespaces << namespace
       end
 
-      def method_missing(method, *args)
-        method = method.to_s.sub(/=$/, "").to_sym
+      def after_generate(&block)
+        @after_generate_callbacks << block
+      end
 
-        return @options[method] if args.empty?
+      def method_missing(method, *args)
+        method = method.to_s.delete_suffix("=").to_sym
+
+        if args.empty?
+          if method == :rails
+            return @options[method]
+          else
+            return @options[:rails][method]
+          end
+        end
 
         if method == :rails || args.first.is_a?(Hash)
           namespace, configuration = method, args.shift