omg-railties 8.0.0.alpha3

data/lib/rails/application/default_middleware_stack.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Rails
+  class Application
+    class DefaultMiddlewareStack
+      attr_reader :config, :paths, :app
+
+      def initialize(app, config, paths)
+        @app = app
+        @config = config
+        @paths = paths
+      end
+
+      def build_stack
+        ActionDispatch::MiddlewareStack.new do |middleware|
+          unless Array(config.hosts).empty?
+            middleware.use ::ActionDispatch::HostAuthorization, config.hosts, **config.host_authorization
+          end
+
+          if config.assume_ssl
+            middleware.use ::ActionDispatch::AssumeSSL
+          end
+
+          if config.force_ssl
+            middleware.use ::ActionDispatch::SSL, **config.ssl_options,
+              ssl_default_redirect_status: config.action_dispatch.ssl_default_redirect_status
+          end
+
+          middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
+
+          if config.public_file_server.enabled
+            headers = config.public_file_server.headers || {}
+
+            middleware.use ::ActionDispatch::Static, paths["public"].first, index: config.public_file_server.index_name, headers: headers
+          end
+
+          if rack_cache = load_rack_cache
+            require "action_dispatch/http/rack_cache"
+            middleware.use ::Rack::Cache, rack_cache
+          end
+
+          if config.allow_concurrency == false
+            # User has explicitly opted out of concurrent request
+            # handling: presumably their code is not threadsafe
+
+            middleware.use ::Rack::Lock
+          end
+
+          middleware.use ::ActionDispatch::Executor, app.executor
+
+          middleware.use ::ActionDispatch::ServerTiming if config.server_timing
+          middleware.use ::Rack::Runtime
+          middleware.use ::Rack::MethodOverride unless config.api_only
+          middleware.use ::ActionDispatch::RequestId, header: config.action_dispatch.request_id_header
+          middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
+
+          if path = config.silence_healthcheck_path
+            middleware.use ::Rails::Rack::SilenceRequest, path: path
+          end
+
+          middleware.use ::Rails::Rack::Logger, config.log_tags
+          middleware.use ::ActionDispatch::ShowExceptions, show_exceptions_app
+          middleware.use ::ActionDispatch::DebugExceptions, app, config.debug_exception_response_format
+
+          if config.consider_all_requests_local
+            middleware.use ::ActionDispatch::ActionableExceptions
+          end
+
+          if config.reloading_enabled?
+            middleware.use ::ActionDispatch::Reloader, app.reloader
+          end
+
+          middleware.use ::ActionDispatch::Callbacks
+          middleware.use ::ActionDispatch::Cookies unless config.api_only
+
+          if !config.api_only && config.session_store
+            if config.force_ssl && config.ssl_options.fetch(:secure_cookies, true) && !config.session_options.key?(:secure)
+              config.session_options[:secure] = true
+            end
+            middleware.use config.session_store, config.session_options
+          end
+
+          unless config.api_only
+            middleware.use ::ActionDispatch::Flash
+            middleware.use ::ActionDispatch::ContentSecurityPolicy::Middleware
+            middleware.use ::ActionDispatch::PermissionsPolicy::Middleware
+          end
+
+          middleware.use ::Rack::Head
+          middleware.use ::Rack::ConditionalGet
+          middleware.use ::Rack::ETag, "no-cache"
+
+          middleware.use ::Rack::TempfileReaper unless config.api_only
+
+          if config.respond_to?(:active_record)
+            if selector_options = config.active_record.database_selector
+              resolver = config.active_record.database_resolver
+              context = config.active_record.database_resolver_context
+
+              middleware.use ::ActiveRecord::Middleware::DatabaseSelector, resolver, context, selector_options
+            end
+
+            if shard_resolver = config.active_record.shard_resolver
+              options = config.active_record.shard_selector || {}
+
+              middleware.use ::ActiveRecord::Middleware::ShardSelector, shard_resolver, options
+            end
+          end
+        end
+      end
+
+      private
+        def load_rack_cache
+          rack_cache = config.action_dispatch.rack_cache
+          return unless rack_cache
+
+          begin
+            require "rack/cache"
+          rescue LoadError => error
+            error.message << " Be sure to add rack-cache to your Gemfile"
+            raise
+          end
+
+          if rack_cache == true
+            {
+              metastore: "rails:/",
+              entitystore: "rails:/",
+              verbose: false
+            }
+          else
+            rack_cache
+          end
+        end
+
+        def show_exceptions_app
+          config.exceptions_app || ActionDispatch::PublicExceptions.new(Rails.public_path)
+        end
+    end
+  end
+end

data/lib/rails/application/dummy_config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class DummyConfig # :nodoc:
+  def initialize(config)
+    @config = config
+  end
+
+  def to_s
+    "DummyConfig"
+  end
+
+  def method_missing(selector, ...)
+    if @config.respond_to?(selector)
+      @config.send(selector, ...)
+    else
+      self
+    end
+  end
+end

data/lib/rails/application/finisher.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "set"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/array/conversions"
+require "active_support/descendants_tracker"
+require "active_support/dependencies"
+
+module Rails
+  class Application
+    module Finisher
+      include Initializable
+
+      initializer :add_generator_templates do
+        ensure_generator_templates_added
+      end
+
+      initializer :setup_main_autoloader do
+        autoloader = Rails.autoloaders.main
+
+        # Normally empty, but if the user already defined some, we won't
+        # override them. Important if there are custom namespaces associated.
+        already_configured_dirs = Set.new(autoloader.dirs)
+
+        ActiveSupport::Dependencies.autoload_paths.freeze
+        ActiveSupport::Dependencies.autoload_paths.uniq.each do |path|
+          # Zeitwerk only accepts existing directories in `push_dir`.
+          next unless File.directory?(path)
+          next if already_configured_dirs.member?(path.to_s)
+
+          autoloader.push_dir(path)
+          autoloader.do_not_eager_load(path) unless ActiveSupport::Dependencies.eager_load?(path)
+        end
+
+        if config.reloading_enabled?
+          autoloader.enable_reloading
+          ActiveSupport::Dependencies.autoloader = autoloader
+
+          autoloader.on_load do |_cpath, value, _abspath|
+            if value.is_a?(Class) && value.singleton_class < ActiveSupport::DescendantsTracker
+              ActiveSupport::Dependencies._autoloaded_tracked_classes << value
+            end
+          end
+        end
+
+        autoloader.setup
+      end
+
+      # Setup default session store if not already set in config/application.rb
+      initializer :setup_default_session_store, before: :build_middleware_stack do |app|
+        unless app.config.session_store?
+          app_name = app.class.name ? app.railtie_name.chomp("_application") : ""
+          app.config.session_store :cookie_store, key: "_#{app_name}_session"
+        end
+      end
+
+      initializer :build_middleware_stack do
+        build_middleware_stack
+      end
+
+      initializer :define_main_app_helper do |app|
+        app.routes.define_mounted_helper(:main_app)
+      end
+
+      initializer :add_to_prepare_blocks do |app|
+        config.to_prepare_blocks.each do |block|
+          app.reloader.to_prepare(&block)
+        end
+      end
+
+      # This needs to happen before eager load so it happens
+      # in exactly the same point regardless of config.eager_load
+      initializer :run_prepare_callbacks do |app|
+        app.reloader.prepare!
+      end
+
+      initializer :eager_load! do |app|
+        if config.eager_load
+          ActiveSupport.run_load_hooks(:before_eager_load, self)
+          Zeitwerk::Loader.eager_load_all
+          Rails.eager_load!
+          config.eager_load_namespaces.each(&:eager_load!)
+
+          if config.reloading_enabled?
+            app.reloader.after_class_unload do
+              Rails.autoloaders.main.eager_load
+            end
+          end
+        end
+      end
+
+      # All initialization is done, including eager loading in production
+      initializer :finisher_hook do
+        ActiveSupport.run_load_hooks(:after_initialize, self)
+      end
+
+      class MonitorHook # :nodoc:
+        def initialize(monitor = Monitor.new)
+          @monitor = monitor
+        end
+
+        def run
+          @monitor.enter
+        end
+
+        def complete(_state)
+          @monitor.exit
+        end
+      end
+
+      module InterlockHook # :nodoc:
+        def self.run
+          ActiveSupport::Dependencies.interlock.start_running
+        end
+
+        def self.complete(_state)
+          ActiveSupport::Dependencies.interlock.done_running
+        end
+      end
+
+      initializer :configure_executor_for_concurrency do |app|
+        if config.allow_concurrency == false
+          # User has explicitly opted out of concurrent request
+          # handling: presumably their code is not threadsafe
+
+          app.executor.register_hook(MonitorHook.new, outer: true)
+
+        elsif config.allow_concurrency == :unsafe
+          # Do nothing, even if we know this is dangerous. This is the
+          # historical behavior for true.
+
+        else
+          # Default concurrency setting: enabled, but safe
+
+          if config.reloading_enabled?
+            app.executor.register_hook(InterlockHook, outer: true)
+          end
+        end
+      end
+
+      initializer :add_internal_routes do |app|
+        if Rails.env.development?
+          app.routes.prepend do
+            get "/rails/info/properties" => "rails/info#properties", internal: true
+            get "/rails/info/routes"     => "rails/info#routes",     internal: true
+            get "/rails/info/notes"      => "rails/info#notes",      internal: true
+            get "/rails/info"            => "rails/info#index",      internal: true
+          end
+
+          routes_reloader.run_after_load_paths = -> do
+            app.routes.append do
+              get "/" => "rails/welcome#index", internal: true
+            end
+          end
+        end
+      end
+
+      # Set routes reload after the finisher hook to ensure routes added in
+      # the hook are taken into account.
+      initializer :set_routes_reloader_hook do |app|
+        reloader = routes_reloader
+        reloader.eager_load = app.config.eager_load
+        reloaders << reloader
+
+        app.reloader.to_run do
+          # We configure #execute rather than #execute_if_updated because if
+          # autoloaded constants are cleared we need to reload routes also in
+          # case any was used there, as in
+          #
+          #   mount MailPreview => 'mail_view'
+          #
+          # This means routes are also reloaded if i18n is updated, which
+          # might not be necessary, but in order to be more precise we need
+          # some sort of reloaders dependency support, to be added.
+          require_unload_lock!
+          reloader.execute
+          ActiveSupport.run_load_hooks(:after_routes_loaded, self)
+        end
+
+        reloader.execute_unless_loaded if !app.routes.is_a?(Engine::LazyRouteSet) || app.config.eager_load
+      end
+
+      # Set clearing dependencies after the finisher hook to ensure paths
+      # added in the hook are taken into account.
+      initializer :set_clear_dependencies_hook, group: :all do |app|
+        callback = lambda do
+          # Order matters.
+          ActiveSupport::DescendantsTracker.clear(ActiveSupport::Dependencies._autoloaded_tracked_classes)
+          ActiveSupport::Dependencies.clear
+        end
+
+        if config.reloading_enabled?
+          if config.reload_classes_only_on_change
+            app.reloader.check = lambda do
+              app.reloaders.map(&:updated?).any?
+            end
+          else
+            app.reloader.check = lambda { true }
+          end
+        else
+          app.reloader.check = lambda { false }
+        end
+
+        if config.reloading_enabled?
+          if config.reload_classes_only_on_change
+            reloader = config.file_watcher.new(*watchable_args, &callback)
+            reloaders << reloader
+
+            # Prepend this callback to have autoloaded constants cleared before
+            # any other possible reloading, in case they need to autoload fresh
+            # constants.
+            app.reloader.to_run(prepend: true) do
+              # In addition to changes detected by the file watcher, if routes
+              # or i18n have been updated we also need to clear constants,
+              # that's why we run #execute rather than #execute_if_updated, this
+              # callback has to clear autoloaded constants after any update.
+              class_unload! do
+                reloader.execute
+              end
+            end
+          else
+            app.reloader.to_complete do
+              class_unload!(&callback)
+            end
+          end
+        else
+          ActiveSupport::DescendantsTracker.disable_clear!
+        end
+      end
+
+      initializer :enable_yjit do
+        if config.yjit && defined?(RubyVM::YJIT.enable)
+          RubyVM::YJIT.enable
+        end
+      end
+    end
+  end
+end

data/lib/rails/application/routes_reloader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module Rails
+  class Application
+    class RoutesReloader
+      include ActiveSupport::Callbacks
+
+      attr_reader :route_sets, :paths, :external_routes, :loaded
+      attr_accessor :eager_load
+      attr_writer :run_after_load_paths # :nodoc:
+      delegate :execute_if_updated, :execute, :updated?, to: :updater
+
+      def initialize
+        @paths      = []
+        @route_sets = []
+        @external_routes = []
+        @eager_load = false
+        @loaded = false
+      end
+
+      def reload!
+        @loaded = true
+        clear!
+        load_paths
+        finalize!
+        route_sets.each(&:eager_load!) if eager_load
+      ensure
+        revert
+      end
+
+      def execute_unless_loaded
+        unless @loaded
+          execute
+          ActiveSupport.run_load_hooks(:after_routes_loaded, Rails.application)
+          true
+        end
+      end
+
+    private
+      def updater
+        @updater ||= begin
+          dirs = @external_routes.each_with_object({}) do |dir, hash|
+            hash[dir.to_s] = %w(rb)
+          end
+
+          ActiveSupport::FileUpdateChecker.new(paths, dirs) { reload! }
+        end
+      end
+
+      def clear!
+        route_sets.each do |routes|
+          routes.disable_clear_and_finalize = true
+          routes.clear!
+        end
+      end
+
+      def load_paths
+        paths.each { |path| load(path) }
+        run_after_load_paths.call
+      end
+
+      def run_after_load_paths
+        @run_after_load_paths ||= -> { }
+      end
+
+      def finalize!
+        route_sets.each(&:finalize!)
+      end
+
+      def revert
+        route_sets.each do |routes|
+          routes.disable_clear_and_finalize = false
+        end
+      end
+    end
+  end
+end