railties 7.0.8 → 7.2.0

data/lib/rails/generators.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-activesupport_path = File.expand_path("../../../activesupport/lib", __dir__)
-$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
-
 require "thor/group"
 require "rails/command"
 
@@ -26,6 +23,7 @@ module Rails
     autoload :NamedBase,       "rails/generators/named_base"
     autoload :ResourceHelpers, "rails/generators/resource_helpers"
     autoload :TestCase,        "rails/generators/test_case"
+    autoload :Devcontainer,    "rails/generators/devcontainer"
 
     mattr_accessor :namespace
 
@@ -33,7 +31,7 @@ module Rails
       rails: {
         actions: "-a",
         orm: "-o",
-        javascripts: "-j",
+        javascripts: ["-j", "--js"],
         resource_controller: "-c",
         scaffold_controller: "-c",
         stylesheets: "-y",
@@ -93,7 +91,7 @@ module Rails
       end
 
       # Hold configured generators fallbacks. If a plugin developer wants a
-      # generator group to fallback to another group in case of missing generators,
+      # generator group to fall back to another group in case of missing generators,
       # they can add a fallback.
       #
       # For example, shoulda is considered a test_framework and is an extension
@@ -166,7 +164,8 @@ module Rails
 
       # Show help message with available generators.
       def help(command = "generate")
-        puts "Usage: rails #{command} GENERATOR [args] [options]"
+        puts "Usage:"
+        puts "  bin/rails #{command} GENERATOR [args] [options]"
         puts
         puts "General options:"
         puts "  -h, [--help]     # Print generator's options and usage"
@@ -204,7 +203,6 @@ module Rails
         rails.map! { |n| n.delete_prefix("rails:") }
         rails.delete("app")
         rails.delete("plugin")
-        rails.delete("encrypted_secrets")
         rails.delete("encrypted_file")
         rails.delete("encryption_key_file")
         rails.delete("master_key")
@@ -264,16 +262,10 @@ module Rails
           run_after_generate_callback if config[:behavior] == :invoke
         else
           options = sorted_groups.flat_map(&:last)
-          error   = Command::Base::CorrectableError.new("Could not find generator '#{namespace}'.", namespace, options)
-
-          if error.respond_to?(:detailed_message)
-            formatted_message = error.detailed_message
-          else
-            formatted_message = error.message
-          end
+          error = Command::CorrectableNameError.new("Could not find generator '#{namespace}'.", namespace, options)
 
           puts <<~MSG
-            #{formatted_message}
+            #{error.detailed_message}
             Run `bin/rails generate --help` for more options.
           MSG
         end

data/lib/rails/health_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rails
+  # Built-in Health Check Endpoint
+  #
+  # \Rails also comes with a built-in health check endpoint that is reachable at
+  # the +/up+ path. This endpoint will return a 200 status code if the app has
+  # booted with no exceptions, and a 500 status code otherwise.
+  #
+  # In production, many applications are required to report their status upstream,
+  # whether it's to an uptime monitor that will page an engineer when things go
+  # wrong, or a load balancer or Kubernetes controller used to determine a pod's
+  # health. This health check is designed to be a one-size fits all that will work
+  # in many situations.
+  #
+  # While any newly generated \Rails applications will have the health check at
+  # +/up+, you can configure the path to be anything you'd like in your
+  # <tt>"config/routes.rb"</tt>:
+  #
+  #   Rails.application.routes.draw do
+  #     get "healthz" => "rails/health#show", as: :rails_health_check
+  #   end
+  #
+  # The health check will now be accessible via the +/healthz+ path.
+  #
+  # NOTE: This endpoint does not reflect the status of all of your application's
+  # dependencies, such as the database or Redis cluster. Replace
+  # <tt>"rails/health#show"</tt> with your own controller action if you have
+  # application specific needs.
+  #
+  # Think carefully about what you want to check as it can lead to situations
+  # where your application is being restarted due to a third-party service going
+  # bad. Ideally, you should design your application to handle those outages
+  # gracefully.
+  class HealthController < ActionController::Base
+    rescue_from(Exception) { render_down }
+
+    def show
+      render_up
+    end
+
+    private
+      def render_up
+        render html: html_status(color: "green")
+      end
+
+      def render_down
+        render html: html_status(color: "red"), status: 500
+      end
+
+      def html_status(color:)
+        %(<!DOCTYPE html><html><body style="background-color: #{color}"></body></html>).html_safe
+      end
+  end
+end

data/lib/rails/info.rb

@@ -4,7 +4,7 @@ require "cgi"
 
 module Rails
   # This module helps build the runtime properties that are displayed in
-  # Rails::InfoController responses. These include the active Rails version,
+  # Rails::InfoController responses. These include the active \Rails version,
   # Ruby version, Rack version, and so on.
   module Info
     mattr_accessor :properties, default: []
@@ -95,11 +95,11 @@ module Rails
 
     # The name of the database adapter for the current environment.
     property "Database adapter" do
-      ActiveRecord::Base.connection.pool.db_config.adapter
+      ActiveRecord::Base.connection_pool.db_config.adapter
     end
 
     property "Database schema version" do
-      ActiveRecord::Base.connection.migration_context.current_version rescue nil
+      ActiveRecord::Base.connection_pool.migration_context.current_version rescue nil
     end
   end
 end

data/lib/rails/info_controller.rb

@@ -4,7 +4,7 @@ require "rails/application_controller"
 require "action_dispatch/routing/inspector"
 
 class Rails::InfoController < Rails::ApplicationController # :nodoc:
-  prepend_view_path ActionDispatch::DebugView::RESCUES_TEMPLATE_PATH
+  prepend_view_path ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS
   layout -> { request.xhr? ? false : "application" }
 
   before_action :require_local!
@@ -19,12 +19,12 @@ class Rails::InfoController < Rails::ApplicationController # :nodoc:
   end
 
   def routes
-    if path = params[:path]
-      path = URI::DEFAULT_PARSER.escape path
-      normalized_path = with_leading_slash path
+    if query = params[:query]
+      query = URI::DEFAULT_PARSER.escape query
+
       render json: {
-        exact: match_route { |it| it.match normalized_path },
-        fuzzy: match_route { |it| it.spec.to_s.match path }
+        exact: matching_routes(query: query, exact_match: true),
+        fuzzy: matching_routes(query: query, exact_match: false)
       }
     else
       @routes_inspector = ActionDispatch::Routing::RoutesInspector.new(_routes.routes)
@@ -33,11 +33,31 @@ class Rails::InfoController < Rails::ApplicationController # :nodoc:
   end
 
   private
-    def match_route
-      _routes.routes.filter_map { |route| route.path.spec.to_s if yield route.path }
-    end
+    def matching_routes(query:, exact_match:)
+      return [] if query.blank?
+
+      normalized_path = ("/" + query).squeeze("/")
+      query_without_url_or_path_suffix = query.gsub(/(\w)(_path$)/, '\1').gsub(/(\w)(_url$)/, '\1')
+
+      _routes.routes.filter_map do |route|
+        route_wrapper = ActionDispatch::Routing::RouteWrapper.new(route)
+
+        if exact_match
+          match = route.path.match(normalized_path)
+          match ||= (query_without_url_or_path_suffix === route_wrapper.name)
+        else
+          match = route_wrapper.path.match(query)
+          match ||= route_wrapper.name.include?(query_without_url_or_path_suffix)
+        end
+
+        match ||= (query === route_wrapper.verb)
+
+        unless match
+          controller_action = URI::DEFAULT_PARSER.escape(route_wrapper.reqs)
+          match = exact_match ? (query === controller_action) : controller_action.include?(query)
+        end
 
-    def with_leading_slash(path)
-      ("/" + path).squeeze("/")
+        route_wrapper.path if match
+      end
     end
 end

data/lib/rails/mailers_controller.rb

@@ -1,26 +1,37 @@
 # frozen_string_literal: true
 
 require "rails/application_controller"
+require "active_support/core_ext/enumerable"
 
 class Rails::MailersController < Rails::ApplicationController # :nodoc:
-  prepend_view_path ActionDispatch::DebugView::RESCUES_TEMPLATE_PATH
+  prepend_view_path ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS
 
-  around_action :set_locale, only: :preview
-  before_action :find_preview, only: :preview
+  around_action :set_locale, only: [:preview, :download]
+  before_action :find_preview, only: [:preview, :download]
   before_action :require_local!, unless: :show_previews?
 
-  helper_method :part_query, :locale_query
+  helper_method :attachment_url, :part_query, :locale_query
 
   content_security_policy(false)
 
   def index
     @previews = ActionMailer::Preview.all
-    @page_title = "Mailer Previews"
+    @page_title = "Action Mailer Previews"
+  end
+
+  def download
+    @email_action = File.basename(params[:path])
+    if @preview.email_exists?(@email_action)
+      @email = @preview.call(@email_action, params)
+      send_data @email.to_s, filename: "#{@email_action}.eml"
+    else
+      raise AbstractController::ActionNotFound, "Email '#{@email_action}' not found in #{@preview.name}"
+    end
   end
 
   def preview
     if params[:path] == @preview.preview_name
-      @page_title = "Mailer Previews for #{@preview.preview_name}"
+      @page_title = "Action Mailer Previews for #{@preview.preview_name}"
       render action: "mailer"
     else
       @email_action = File.basename(params[:path])
@@ -28,6 +39,8 @@ class Rails::MailersController < Rails::ApplicationController # :nodoc:
       if @preview.email_exists?(@email_action)
         @page_title = "Mailer Preview for #{@preview.preview_name}##{@email_action}"
         @email = @preview.call(@email_action, params)
+        @attachments = attachments_for(@email).reject { |filename, attachment| attachment.inline? }
+        @inline_attachments = attachments_for(@email).select { |filename, attachment| attachment.inline? }
 
         if params[:part]
           part_type = Mime::Type.lookup(params[:part])
@@ -85,6 +98,16 @@ class Rails::MailersController < Rails::ApplicationController # :nodoc:
       end
     end
 
+    def attachments_for(email)
+      email.all_parts.to_a.select(&:attachment?).index_by do |attachment|
+        attachment.respond_to?(:original_filename) ? attachment.original_filename : attachment.filename
+      end
+    end
+
+    def attachment_url(attachment)
+      "data:application/octet-stream;charset=utf-8;base64,#{Base64.encode64(attachment.body.to_s)}"
+    end
+
     def part_query(mime_type)
       request.query_parameters.merge(part: mime_type).to_query
     end

data/lib/rails/paths.rb

@@ -4,9 +4,9 @@ require "pathname"
 
 module Rails
   module Paths
-    # This object is an extended hash that behaves as root of the <tt>Rails::Paths</tt> system.
+    # This object is an extended hash that behaves as root of the Rails::Paths system.
     # It allows you to collect information about how you want to structure your application
-    # paths through a Hash-like API. It requires you to give a physical path on initialization.
+    # paths through a Hash-like \API. It requires you to give a physical path on initialization.
     #
     #   root = Root.new "/rails"
     #   root.add "app/controllers", eager_load: true
@@ -18,7 +18,8 @@ module Rails
     #   path.eager_load?               # => true
     #   path.is_a?(Rails::Paths::Path) # => true
     #
-    # The +Path+ object is simply an enumerable and allows you to easily add extra paths:
+    # The Path[rdoc-ref:Rails::Paths::Path] object is simply an enumerable and
+    # allows you to easily add extra paths:
     #
     #   path.is_a?(Enumerable) # => true
     #   path.to_ary.inspect    # => ["app/controllers"]
@@ -26,17 +27,19 @@ module Rails
     #   path << "lib/controllers"
     #   path.to_ary.inspect    # => ["app/controllers", "lib/controllers"]
     #
-    # Notice that when you add a path using +add+, the path object created already
-    # contains the path with the same path value given to +add+. In some situations,
-    # you may not want this behavior, so you can give <tt>:with</tt> as option.
+    # Notice that when you add a path using #add, the
+    # Path[rdoc-ref:Rails::Paths::Path] object created already contains the path
+    # with the same path value given to #add. In some situations, you may not
+    # want this behavior, so you can give <tt>:with</tt> as option.
     #
     #   root.add "config/routes", with: "config/routes.rb"
     #   root["config/routes"].inspect # => ["config/routes.rb"]
     #
-    # The +add+ method accepts the following options as arguments:
-    # eager_load, autoload, autoload_once, and glob.
+    # The #add method accepts the following options as arguments:
+    # +eager_load+, +autoload+, +autoload_once+, and +glob+.
     #
-    # Finally, the +Path+ object also provides a few helpers:
+    # Finally, the Path[rdoc-ref:Rails::Paths::Path] object also provides a few
+    # helpers:
     #
     #   root = Root.new "/rails"
     #   root.add "app/controllers"
@@ -44,7 +47,7 @@ module Rails
     #   root["app/controllers"].expanded # => ["/rails/app/controllers"]
     #   root["app/controllers"].existent # => ["/rails/app/controllers"]
     #
-    # Check the <tt>Rails::Paths::Path</tt> documentation for more information.
+    # Check the Rails::Paths::Path documentation for more information.
     class Root
       attr_accessor :path
 
@@ -102,8 +105,8 @@ module Rails
     private
       def filter_by(&block)
         all_paths.find_all(&block).flat_map { |path|
-          paths = path.existent
-          paths - path.children.flat_map { |p| yield(p) ? [] : p.existent }
+          paths = path.existent_directories
+          paths - path.children.flat_map { |p| yield(p) ? [] : p.existent_directories }
         }.uniq
       end
     end

data/lib/rails/pwa_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails/application_controller"
+
+class Rails::PwaController < Rails::ApplicationController # :nodoc:
+  skip_forgery_protection
+
+  def service_worker
+    render template: "pwa/service-worker", layout: false
+  end
+
+  def manifest
+    render template: "pwa/manifest", layout: false
+  end
+end

data/lib/rails/rack/logger.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/object/blank"
 require "active_support/log_subscriber"
 require "rack/body_proxy"
 
@@ -21,39 +20,45 @@ module Rails
       def call(env)
         request = ActionDispatch::Request.new(env)
 
-        if logger.respond_to?(:tagged)
-          logger.tagged(compute_tags(request)) { call_app(request, env) }
+        env["rails.rack_logger_tag_count"] = if logger.respond_to?(:push_tags)
+          logger.push_tags(*compute_tags(request)).size
         else
-          call_app(request, env)
+          0
         end
+
+        call_app(request, env)
       end
 
       private
         def call_app(request, env) # :doc:
+          logger_tag_pop_count = env["rails.rack_logger_tag_count"]
+
           instrumenter = ActiveSupport::Notifications.instrumenter
-          instrumenter_state = instrumenter.start "request.action_dispatch", request: request
-          instrumenter_finish = -> () {
-            instrumenter.finish_with_state(instrumenter_state, "request.action_dispatch", request: request)
-          }
+          handle = instrumenter.build_handle("request.action_dispatch", { request: request })
+          handle.start
 
           logger.info { started_request_message(request) }
-          status, headers, body = @app.call(env)
-          body = ::Rack::BodyProxy.new(body, &instrumenter_finish)
-          [status, headers, body]
+          status, headers, body = response = @app.call(env)
+          body = ::Rack::BodyProxy.new(body) { finish_request_instrumentation(handle, logger_tag_pop_count) }
+
+          if response.frozen?
+            [status, headers, body]
+          else
+            response[2] = body
+            response
+          end
         rescue Exception
-          instrumenter_finish.call
+          finish_request_instrumentation(handle, logger_tag_pop_count)
           raise
-        ensure
-          ActiveSupport::LogSubscriber.flush_all!
         end
 
         # Started GET "/session/new" for 127.0.0.1 at 2012-09-26 14:51:42 -0700
         def started_request_message(request) # :doc:
-          'Started %s "%s" for %s at %s' % [
+          sprintf('Started %s "%s" for %s at %s',
             request.raw_request_method,
             request.filtered_path,
             request.remote_ip,
-            Time.now.to_default_s ]
+            Time.now)
         end
 
         def compute_tags(request) # :doc:
@@ -72,6 +77,12 @@ module Rails
         def logger
           Rails.logger
         end
+
+        def finish_request_instrumentation(handle, logger_tag_pop_count)
+          handle.finish
+          logger.pop_tags(logger_tag_pop_count) if logger.respond_to?(:pop_tags) && logger_tag_pop_count > 0
+          ActiveSupport::LogSubscriber.flush_all!
+        end
     end
   end
 end

data/lib/rails/rackup/server.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
+module Rails
+  module Rackup
+    begin
+      require "rackup/server"
+      Server = ::Rackup::Server
+    rescue LoadError
+      require "rack/server"
+      Server = ::Rack::Server
+    end
+  end
+end

data/lib/rails/railtie/configurable.rb

@@ -27,8 +27,8 @@ module Rails
         end
 
         private
-          def method_missing(*args, &block)
-            instance.send(*args, &block)
+          def method_missing(...)
+            instance.send(...)
           end
       end
     end

data/lib/rails/railtie/configuration.rb

@@ -71,6 +71,11 @@ module Rails
         ActiveSupport.on_load(:after_initialize, yield: true, &block)
       end
 
+      # Called after application routes have been loaded.
+      def after_routes_loaded(&block)
+        ActiveSupport.on_load(:after_routes_loaded, yield: true, &block)
+      end
+
       # Array of callbacks defined by #to_prepare.
       def to_prepare_blocks
         @@to_prepare_blocks ||= []
@@ -87,9 +92,17 @@ module Rails
       end
 
     private
+      def actual_method?(key)
+        !@@options.key?(key) && respond_to?(key)
+      end
+
       def method_missing(name, *args, &blk)
         if name.end_with?("=")
-          @@options[:"#{name[0..-2]}"] = args.first
+          key = name[0..-2].to_sym
+          if actual_method?(key)
+            raise NoMethodError.new("Cannot assign to `#{key}`, it is a configuration method")
+          end
+          @@options[key] = args.first
         elsif @@options.key?(name)
           @@options[name]
         else

data/lib/rails/railtie.rb

@@ -7,34 +7,34 @@ require "active_support/core_ext/module/introspection"
 require "active_support/core_ext/module/delegation"
 
 module Rails
-  # <tt>Rails::Railtie</tt> is the core of the Rails framework and provides
-  # several hooks to extend Rails and/or modify the initialization process.
+  # +Rails::Railtie+ is the core of the \Rails framework and provides
+  # several hooks to extend \Rails and/or modify the initialization process.
   #
-  # Every major component of Rails (Action Mailer, Action Controller, Active
+  # Every major component of \Rails (Action Mailer, Action Controller, Active
   # Record, etc.) implements a railtie. Each of them is responsible for their
-  # own initialization. This makes Rails itself absent of any component hooks,
-  # allowing other components to be used in place of any of the Rails defaults.
+  # own initialization. This makes \Rails itself absent of any component hooks,
+  # allowing other components to be used in place of any of the \Rails defaults.
   #
-  # Developing a Rails extension does _not_ require implementing a railtie, but
-  # if you need to interact with the Rails framework during or after boot, then
+  # Developing a \Rails extension does _not_ require implementing a railtie, but
+  # if you need to interact with the \Rails framework during or after boot, then
   # a railtie is needed.
   #
   # For example, an extension doing any of the following would need a railtie:
   #
   # * creating initializers
-  # * configuring a Rails framework for the application, like setting a generator
+  # * configuring a \Rails framework for the application, like setting a generator
   # * adding <tt>config.*</tt> keys to the environment
   # * setting up a subscriber with ActiveSupport::Notifications
   # * adding Rake tasks
   #
   # == Creating a Railtie
   #
-  # To extend Rails using a railtie, create a subclass of <tt>Rails::Railtie</tt>.
-  # This class must be loaded during the Rails boot process, and is conventionally
-  # called <tt>MyNamespace::Railtie</tt>.
+  # To extend \Rails using a railtie, create a subclass of +Rails::Railtie+.
+  # This class must be loaded during the \Rails boot process, and is conventionally
+  # called +MyNamespace::Railtie+.
   #
   # The following example demonstrates an extension which can be used with or
-  # without Rails.
+  # without \Rails.
   #
   #   # lib/my_gem/railtie.rb
   #   module MyGem
@@ -47,7 +47,7 @@ module Rails
   #
   # == Initializers
   #
-  # To add an initialization step to the Rails boot process from your railtie, just
+  # To add an initialization step to the \Rails boot process from your railtie, just
   # define the initialization code with the +initializer+ macro:
   #
   #   class MyRailtie < Rails::Railtie
@@ -87,7 +87,7 @@ module Rails
   #
   # == Loading Rake Tasks and Generators
   #
-  # If your railtie has Rake tasks, you can tell Rails to load them through the method
+  # If your railtie has Rake tasks, you can tell \Rails to load them through the method
   # +rake_tasks+:
   #
   #   class MyRailtie < Rails::Railtie
@@ -96,7 +96,7 @@ module Rails
   #     end
   #   end
   #
-  # By default, Rails loads generators from your load path. However, if you want to place
+  # By default, \Rails loads generators from your load path. However, if you want to place
   # your generators at a different location, you can specify in your railtie a block which
   # will load them during normal generators lookup:
   #
@@ -109,13 +109,13 @@ module Rails
   # Since filenames on the load path are shared across gems, be sure that files you load
   # through a railtie have unique names.
   #
-  # == Run another program when the Rails server starts
+  # == Run another program when the \Rails server starts
   #
-  # In development, it's very usual to have to run another process next to the Rails Server. In example
+  # In development, it's very usual to have to run another process next to the \Rails Server. In example
   # you might want to start the Webpack or React server. Or maybe you need to run your job scheduler process
   # like Sidekiq. This is usually done by opening a new shell and running the program from here.
   #
-  # Rails allow you to specify a +server+ block which will get called when a Rails server starts.
+  # \Rails allow you to specify a +server+ block which will get called when a \Rails server starts.
   # This way, your users don't need to remember to have to open a new shell and run another program, making
   # this less confusing for everyone.
   # It can be used like this:
@@ -221,14 +221,13 @@ module Rails
 
         # If the class method does not have a method, then send the method call
         # to the Railtie instance.
-        def method_missing(name, *args, &block)
+        def method_missing(name, ...)
           if !abstract_railtie? && instance.respond_to?(name)
-            instance.public_send(name, *args, &block)
+            instance.public_send(name, ...)
           else
             super
           end
         end
-        ruby2_keywords(:method_missing)
 
         # receives an instance variable identifier, set the variable value if is
         # blank and append given block to value, which will be used later in