railties 6.0.4.3 → 6.1.1

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

@@ -3,8 +3,8 @@
 require "fileutils"
 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"
 
@@ -96,12 +96,10 @@ module Rails
 
       # 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)
+      RACK_SERVERS = %w(cgi fastcgi webrick lsws scgi thin puma unicorn falcon)
 
       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
@@ -114,8 +112,8 @@ module Rails
         desc: "Runs 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."
+      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
@@ -127,7 +125,6 @@ module Rails
         super
 
         @original_options = local_options - %w( --restart )
-        deprecate_positional_rack_server_and_rewrite_to_option(@original_options)
       end
 
       def perform
@@ -146,7 +143,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 +152,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 +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(-.)/
@@ -207,6 +204,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 +219,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
@@ -253,7 +242,7 @@ module Rails
         end
 
         def pid
-          File.expand_path(options[:pid])
+          File.expand_path(options[:pid] || ENV.fetch("PIDFILE", DEFAULT_PIDFILE))
         end
 
         def self.banner(*)
@@ -261,23 +250,7 @@ module Rails
         end
 
         def prepare_restart
-          FileUtils.rm_f(options[: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
-
-            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
+          FileUtils.rm_f(pid) if options[:restart]
         end
 
         def rack_server_suggestion(server)
@@ -287,7 +260,7 @@ module Rails
 
                 gem "#{server}"
 
-              Run `rails server --help` for more options.
+              Run `bin/rails server --help` for more options.
             MSG
           else
             suggestion = Rails::Command::Spellchecker.suggest(server, from: RACK_SERVERS)
@@ -295,7 +268,7 @@ module Rails
 
             <<~MSG
               Could not find server "#{server}". #{suggestion_msg}
-              Run `rails server --help` for more options.
+              Run `bin/rails server --help` for more options.
             MSG
           end
         end
@@ -304,7 +277,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 `bin/rails server --help` for more startup options
           MSG
         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,33 +50,43 @@ module Rails
       end
 
       def insert_before(*args, &block)
-        @operations << -> middleware { middleware.send(__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 << -> middleware { middleware.send(__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 << -> middleware { middleware.send(__method__, *args, &block) }
+        @operations << -> middleware { middleware.swap(*args, &block) }
       end
       ruby2_keywords(:swap) if respond_to?(:ruby2_keywords, true)
 
       def use(*args, &block)
-        @operations << -> middleware { middleware.send(__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 << -> middleware { middleware.send(__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 << -> middleware { middleware.send(__method__, *args, &block) }
+        @operations << -> middleware { middleware.unshift(*args, &block) }
       end
       ruby2_keywords(:unshift) if respond_to?(:ruby2_keywords, true)
 
@@ -89,7 +108,7 @@ module Rails
 
     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] = {} }
@@ -99,6 +118,7 @@ module Rails
         @colorize_logging = true
         @api_only = false
         @hidden_namespaces = []
+        @after_generate_callbacks = []
       end
 
       def initialize_copy(source)
@@ -112,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

data/lib/rails/engine/configuration.rb

@@ -59,6 +59,7 @@ module Rails
           paths.add "config/initializers", glob: "**/*.rb"
           paths.add "config/locales",      glob: "*.{rb,yml}"
           paths.add "config/routes.rb"
+          paths.add "config/routes",       glob: "**/*.rb"
 
           paths.add "db"
           paths.add "db/migrate"

data/lib/rails/engine/updater.rb

@@ -13,7 +13,7 @@ module Rails
         end
 
         def run(action)
-          generator.send(action)
+          generator.public_send(action)
         end
       end
     end

data/lib/rails/engine.rb

@@ -2,7 +2,9 @@
 
 require "rails/railtie"
 require "rails/engine/railties"
+require "active_support/callbacks"
 require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/try"
 require "pathname"
 require "thread"
 
@@ -35,10 +37,10 @@ module Rails
   #
   # == Configuration
   #
-  # Besides the +Railtie+ configuration which is shared across the application, in a
-  # <tt>Rails::Engine</tt> you can access <tt>autoload_paths</tt>, <tt>eager_load_paths</tt>
-  # and <tt>autoload_once_paths</tt>, which, differently from a <tt>Railtie</tt>, are scoped to
-  # the current engine.
+  # Like railties, engines can access a config object which contains configuration shared by
+  # all railties and the application.
+  # Additionally, each engine can access <tt>autoload_paths</tt>, <tt>eager_load_paths</tt> and
+  # <tt>autoload_once_paths</tt> settings which are scoped to that engine.
   #
   #   class MyEngine < Rails::Engine
   #     # Add a load path for this specific Engine
@@ -112,7 +114,7 @@ module Rails
   # == Endpoint
   #
   # An engine can also be a Rack application. It can be useful if you have a Rack application that
-  # you would like to wrap with +Engine+ and provide with some of the +Engine+'s features.
+  # you would like to provide with some of the +Engine+'s features.
   #
   # To do that, use the +endpoint+ method:
   #
@@ -122,7 +124,7 @@ module Rails
   #     end
   #   end
   #
-  # Now you can mount your engine in application's routes just like that:
+  # Now you can mount your engine in application's routes:
   #
   #   Rails.application.routes.draw do
   #     mount MyEngine::Engine => "/engine"
@@ -228,7 +230,7 @@ module Rails
   #     resources :articles
   #   end
   #
-  # If +MyEngine+ is isolated, The routes above will point to
+  # If +MyEngine+ is isolated, the routes above will point to
   # <tt>MyEngine::ArticlesController</tt>. You also don't need to use longer
   # URL helpers like +my_engine_articles_path+. Instead, you should simply use
   # +articles_path+, like you would do with your main application.
@@ -313,7 +315,7 @@ module Rails
   #     helper MyEngine::Engine.helpers
   #   end
   #
-  # It will include all of the helpers from engine's directory. Take into account that this does
+  # It will include all of the helpers from engine's directory. Take into account this does
   # not include helpers defined in controllers with helper_method or other similar solutions,
   # only helpers defined in the helpers directory will be included.
   #
@@ -362,7 +364,7 @@ module Rails
           base.called_from = begin
             call_stack = caller_locations.map { |l| l.absolute_path || l.path }
 
-            File.dirname(call_stack.detect { |p| p !~ %r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack] })
+            File.dirname(call_stack.detect { |p| !p.match?(%r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack]) })
           end
         end
 
@@ -421,6 +423,9 @@ module Rails
       end
     end
 
+    include ActiveSupport::Callbacks
+    define_callbacks :load_seed
+
     delegate :middleware, :root, :paths, to: :config
     delegate :engine_name, :isolated?, to: :class
 
@@ -469,6 +474,13 @@ module Rails
       self
     end
 
+    # Invoke the server registered hooks.
+    # Check <tt>Rails::Railtie.server</tt> for more info.
+    def load_server(app = self)
+      run_server_blocks(app)
+      self
+    end
+
     def eager_load!
       # Already done by Zeitwerk::Loader.eager_load_all. We need this guard to
       # easily provide a compatible API for both zeitwerk and classic modes.
@@ -551,12 +563,12 @@ module Rails
     # Blog::Engine.load_seed
     def load_seed
       seed_file = paths["db/seeds.rb"].existent.first
-      return unless seed_file
+      run_callbacks(:load_seed) { load(seed_file) } if seed_file
+    end
 
-      if config.try(:active_job)&.queue_adapter == :async
-        with_inline_jobs { load(seed_file) }
-      else
-        load(seed_file)
+    initializer :load_environment_config, before: :load_environment_hook, group: :all do
+      paths["config/environments"].existent.each do |environment|
+        require environment
       end
     end
 
@@ -587,10 +599,13 @@ module Rails
 
     initializer :add_routing_paths do |app|
       routing_paths = paths["config/routes.rb"].existent
+      external_paths = self.paths["config/routes"].paths
+      routes.draw_paths.concat(external_paths)
 
       if routes? || routing_paths.any?
         app.routes_reloader.paths.unshift(*routing_paths)
         app.routes_reloader.route_sets << routes
+        app.routes_reloader.external_routes.unshift(*external_paths)
       end
     end
 
@@ -608,12 +623,6 @@ module Rails
       end
     end
 
-    initializer :load_environment_config, before: :load_environment_hook, group: :all do
-      paths["config/environments"].existent.each do |environment|
-        require environment
-      end
-    end
-
     initializer :prepend_helpers_path do |app|
       if !isolated? || (app == self)
         app.config.helpers_paths.unshift(*paths["app/helpers"].existent)
@@ -626,6 +635,12 @@ module Rails
       end
     end
 
+    initializer :wrap_executor_around_load_seed do |app|
+      self.class.set_callback(:load_seed, :around) do |engine, seeds_block|
+        app.executor.wrap(&seeds_block)
+      end
+    end
+
     initializer :engines_blank_point do
       # We need this initializer so all extra initializers added in engines are
       # consistently executed after all the initializers above across all engines.
@@ -667,18 +682,6 @@ module Rails
         end
       end
 
-      def with_inline_jobs
-        queue_adapter = config.active_job.queue_adapter
-        ActiveSupport.on_load(:active_job) do
-          self.queue_adapter = :inline
-        end
-        yield
-      ensure
-        ActiveSupport.on_load(:active_job) do
-          self.queue_adapter = queue_adapter
-        end
-      end
-
       def has_migrations?
         paths["db/migrate"].existent.any?
       end

data/lib/rails/gem_version.rb

@@ -8,9 +8,9 @@ module Rails
 
   module VERSION
     MAJOR = 6
-    MINOR = 0
-    TINY  = 4
-    PRE   = "3"
+    MINOR = 1
+    TINY  = 1
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/rails/generators/actions/create_migration.rb

@@ -19,6 +19,11 @@ module Rails
           exists? && File.binread(existing_migration) == render
         end
 
+        def invoke!
+          invoked_file = super
+          File.exist?(@destination) ? invoked_file : relative_existing_migration
+        end
+
         def revoke!
           say_destination = exists? ? relative_existing_migration : relative_destination
           say_status :remove, :red, say_destination

data/lib/rails/generators/actions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "shellwords"
+require "active_support/core_ext/kernel/reporting"
 require "active_support/core_ext/string/strip"
 
 module Rails
@@ -40,8 +42,7 @@ module Rails
         in_root do
           str = "gem #{parts.join(", ")}"
           str = indentation + str
-          str = "\n" + str
-          append_file "Gemfile", str, verbose: false
+          append_file_with_newline "Gemfile", str, verbose: false
         end
       end
 
@@ -58,9 +59,9 @@ module Rails
         log :gemfile, "group #{str}"
 
         in_root do
-          append_file "Gemfile", "\ngroup #{str} do", force: true
+          append_file_with_newline "Gemfile", "\ngroup #{str} do", force: true
           with_indentation(&block)
-          append_file "Gemfile", "\nend\n", force: true
+          append_file_with_newline "Gemfile", "end", force: true
         end
       end
 
@@ -71,9 +72,13 @@ module Rails
         log :github, "github #{str}"
 
         in_root do
-          append_file "Gemfile", "\n#{indentation}github #{str} do", force: true
+          if @indentation.zero?
+            append_file_with_newline "Gemfile", "\ngithub #{str} do", force: true
+          else
+            append_file_with_newline "Gemfile", "#{indentation}github #{str} do", force: true
+          end
           with_indentation(&block)
-          append_file "Gemfile", "\n#{indentation}end", force: true
+          append_file_with_newline "Gemfile", "#{indentation}end", force: true
         end
       end
 
@@ -91,9 +96,9 @@ module Rails
 
         in_root do
           if block
-            append_file "Gemfile", "\nsource #{quote(source)} do", force: true
+            append_file_with_newline "Gemfile", "\nsource #{quote(source)} do", force: true
             with_indentation(&block)
-            append_file "Gemfile", "\nend\n", force: true
+            append_file_with_newline "Gemfile", "end", force: true
           else
             prepend_file "Gemfile", "source #{quote(source)}\n", verbose: false
           end
@@ -106,11 +111,11 @@ module Rails
       # file in <tt>config/environments</tt>.
       #
       #   environment do
-      #     "config.action_controller.asset_host = 'cdn.provider.com'"
+      #     "config.asset_host = 'cdn.provider.com'"
       #   end
       #
       #   environment(nil, env: "development") do
-      #     "config.action_controller.asset_host = 'localhost:3000'"
+      #     "config.asset_host = 'localhost:3000'"
       #   end
       def environment(data = nil, options = {})
         sentinel = "class Application < Rails::Application\n"
@@ -222,10 +227,9 @@ module Rails
         log :generate, what
 
         options = args.extract_options!
-        options[:without_rails_env] = true
-        argument = args.flat_map(&:to_s).join(" ")
+        options[:abort_on_failure] = !options[:inline]
 
-        execute_command :rails, "generate #{what} #{argument}", options
+        rails_command "generate #{what} #{args.join(" ")}", options
       end
 
       # Runs the supplied rake task (invoked with 'rake ...')
@@ -245,13 +249,28 @@ module Rails
       #   rails_command("gems:install", sudo: true)
       #   rails_command("gems:install", capture: true)
       def rails_command(command, options = {})
-        execute_command :rails, command, options
+        if options[:inline]
+          log :rails, command
+          command, *args = Shellwords.split(command)
+          in_root do
+            silence_warnings do
+              ::Rails::Command.invoke(command, args, **options)
+            end
+          end
+        else
+          execute_command :rails, command, options
+        end
       end
 
       # Make an entry in Rails routing file <tt>config/routes.rb</tt>
       #
       #   route "root 'welcome#index'"
-      def route(routing_code)
+      #   route "root 'admin#index'", namespace: :admin
+      def route(routing_code, namespace: nil)
+        routing_code = Array(namespace).reverse.reduce(routing_code) do |code, ns|
+          "namespace :#{ns} do\n#{indent(code, 2)}\nend"
+        end
+
         log :route, routing_code
         sentinel = /\.routes\.draw do\s*\n/m
 
@@ -284,15 +303,15 @@ module Rails
         # based on the executor parameter provided.
         def execute_command(executor, command, options = {}) # :doc:
           log executor, command
-          env = options[:env] || ENV["RAILS_ENV"] || "development"
-          rails_env = " RAILS_ENV=#{env}" unless options[:without_rails_env]
           sudo = options[:sudo] && !Gem.win_platform? ? "sudo " : ""
-          config = { verbose: false }
-
-          config[:capture] = options[:capture] if options[:capture]
-          config[:abort_on_failure] = options[:abort_on_failure] if options[:abort_on_failure]
-
-          in_root { run("#{sudo}#{extify(executor)} #{command}#{rails_env}", config) }
+          config = {
+            env: { "RAILS_ENV" => (options[:env] || ENV["RAILS_ENV"] || "development") },
+            verbose: false,
+            capture: options[:capture],
+            abort_on_failure: options[:abort_on_failure],
+          }
+
+          in_root { run("#{sudo}#{extify(executor)} #{command}", config) }
         end
 
         # Add an extension to the given name based on the platform.
@@ -324,12 +343,7 @@ module Rails
         # Returns optimized string with indentation
         def optimize_indentation(value, amount = 0) # :doc:
           return "#{value}\n" unless value.is_a?(String)
-
-          if value.lines.size > 1
-            value.strip_heredoc.indent(amount)
-          else
-            "#{value.strip.indent(amount)}\n"
-          end
+          "#{value.strip_heredoc.indent(amount).chomp}\n"
         end
 
         # Indent the +Gemfile+ to the depth of @indentation
@@ -344,6 +358,13 @@ module Rails
         ensure
           @indentation -= 1
         end
+
+        # Append string to a file with a newline if necessary
+        def append_file_with_newline(path, str, options = {})
+          gsub_file path, /\n?\z/, options do |match|
+            match.end_with?("\n") ? "" : "\n#{str}\n"
+          end
+        end
     end
   end
 end