omg-railties 8.0.0.alpha3

data/lib/rails/api/task.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "rdoc/task"
+require "rails/api/generator"
+
+module Rails
+  module API
+    class Task < RDoc::Task
+      RDOC_FILES = {
+        "activesupport" => {
+          include: %w(
+            README.rdoc
+            lib/active_support.rb
+            lib/active_support/**/*.rb
+          )
+        },
+
+        "activerecord" => {
+          include: %w(
+            README.rdoc
+            lib/active_record.rb
+            lib/active_record/**/*.rb
+            lib/arel.rb
+          )
+        },
+
+        "activemodel" => {
+          include: %w(
+            README.rdoc
+            lib/active_model.rb
+            lib/active_model/**/*.rb
+          )
+        },
+
+        "actionpack" => {
+          include: %w(
+            README.rdoc
+            lib/abstract_controller/**/*.rb
+            lib/action_controller.rb
+            lib/action_controller/**/*.rb
+            lib/action_dispatch.rb
+            lib/action_dispatch/**/*.rb
+          )
+        },
+
+        "actionview" => {
+          include: %w(
+            README.rdoc
+            lib/action_view.rb
+            lib/action_view/**/*.rb
+          ),
+          exclude: "lib/action_view/vendor/*"
+        },
+
+        "actionmailer" => {
+          include: %w(
+            README.rdoc
+            lib/action_mailer.rb
+            lib/action_mailer/**/*.rb
+          )
+        },
+
+        "activejob" => {
+          include: %w(
+            README.md
+            lib/active_job.rb
+            lib/active_job/**/*.rb
+          )
+        },
+
+        "actioncable" => {
+          include: %w(
+            README.md
+            lib/action_cable.rb
+            lib/action_cable/**/*.rb
+          )
+        },
+
+        "activestorage" => {
+          include: %w(
+            README.md
+            app/**/active_storage/**/*.rb
+            lib/active_storage.rb
+            lib/active_storage/**/*.rb
+          )
+        },
+
+        "actionmailbox" => {
+          include: %w(
+            README.md
+            app/**/action_mailbox/**/*.rb
+            lib/action_mailbox.rb
+            lib/action_mailbox/**/*.rb
+          )
+        },
+
+        "actiontext" => {
+          include: %w(
+            README.md
+            app/**/action_text/**/*.rb
+            lib/action_text.rb
+            lib/action_text/**/*.rb
+          )
+        },
+
+        "railties" => {
+          include: %w(
+            README.rdoc
+            lib/**/*.rb
+          ),
+          exclude: %w(
+            lib/rails/generators/**/templates/**/*.rb
+            lib/rails/test_unit/*
+            lib/rails/api/generator.rb
+          )
+        }
+      }
+
+      def initialize(name)
+        super
+
+        # Every time rake runs this task is instantiated as all the rest.
+        # Be lazy computing stuff to have as light impact as possible to
+        # the rest of tasks.
+        before_running_rdoc do
+          configure_sdoc
+          configure_rdoc_files
+          setup_horo_variables
+        end
+      end
+
+      # Hack, ignore the desc calls performed by the original initializer.
+      def desc(description)
+        # no-op
+      end
+
+      def configure_sdoc
+        self.title    = "Ruby on Rails API"
+        self.rdoc_dir = api_dir
+
+        options << "-m"  << api_main
+        options << "-e"  << "UTF-8"
+
+        options << "-f"  << "api"
+        options << "-T"  << "rails"
+      end
+
+      def configure_rdoc_files
+        RDOC_FILES.each do |component, cfg|
+          cdr = component_root_dir(component)
+
+          Array(cfg[:include]).each do |pattern|
+            rdoc_files.include("#{cdr}/#{pattern}")
+          end
+
+          Array(cfg[:exclude]).each do |pattern|
+            rdoc_files.exclude("#{cdr}/#{pattern}")
+          end
+        end
+
+        # Only generate documentation for files that have been
+        # changed since the API was generated.
+        timestamp_path = "#{api_dir}/created.rid"
+        if File.exist?(timestamp_path) && !File.zero?(timestamp_path) && !ENV["ALL"]
+          last_generation = DateTime.rfc2822(File.open(timestamp_path, &:readline))
+
+          rdoc_files.keep_if do |file|
+            File.mtime(file).to_datetime > last_generation
+          end
+
+          # Nothing to do
+          exit(0) if rdoc_files.empty?
+        end
+
+        # This must come after the mtime comparison to ensure the main page is not excluded.
+        rdoc_files.include(api_main)
+      end
+
+      # These variables are used by the sdoc template
+      def setup_horo_variables # :nodoc:
+        ENV["HORO_PROJECT_NAME"]    = "Ruby on Rails"
+        ENV["HORO_PROJECT_VERSION"] = rails_version
+        ENV["HORO_BADGE_VERSION"]   = badge_version
+        ENV["HORO_CANONICAL_URL"]   = canonical_url
+      end
+
+      def api_main
+        component_root_dir("railties") + "/RDOC_MAIN.md"
+      end
+    end
+
+    class RepoTask < Task
+      def configure_sdoc
+        super
+        options << "-g" # link to GitHub, SDoc flag
+      end
+
+      def component_root_dir(component)
+        component
+      end
+
+      def api_dir
+        "doc/rdoc"
+      end
+    end
+
+    class EdgeTask < RepoTask
+      def rails_version
+        "main@#{`git rev-parse HEAD`[0, 7]}"
+      end
+
+      def badge_version
+        "edge"
+      end
+
+      def canonical_url
+        "https://edgeapi.rubyonrails.org"
+      end
+    end
+
+    class StableTask < RepoTask
+      def rails_version
+        File.read("RAILS_VERSION").strip
+      end
+
+      def badge_version
+        "v#{rails_version}"
+      end
+
+      def canonical_url
+        "https://api.rubyonrails.org/#{badge_version}"
+      end
+    end
+  end
+end

data/lib/rails/app_loader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "rails/version"
+
+module Rails
+  module AppLoader # :nodoc:
+    extend self
+
+    RUBY = Gem.ruby
+    EXECUTABLES = ["bin/rails", "script/rails"]
+    BUNDLER_WARNING = <<EOS
+Beginning in Rails 4, Rails ships with a `rails` binstub at ./bin/rails that
+should be used instead of the Bundler-generated `rails` binstub.
+
+If you are seeing this message, your binstub at ./bin/rails was generated by
+Bundler instead of Rails.
+
+You might need to regenerate your `rails` binstub locally and add it to source
+control:
+
+ rails app:update:bin           # Bear in mind this generates other binstubs
+                                # too that you may or may not want (like yarn)
+
+If you already have Rails binstubs in source control, you might be
+inadvertently overwriting them during deployment by using bundle install
+with the --binstubs option.
+
+If your application was created prior to Rails 4, here's how to upgrade:
+
+  bundle config --delete bin    # Turn off Bundler's stub generator
+  rails app:update:bin          # Use the new Rails executables
+  git add bin                   # Add bin/ to source control
+
+You may need to remove bin/ from your .gitignore as well.
+
+When you install a gem whose executable you want to use in your app,
+generate it and add it to source control:
+
+  bundle binstubs some-gem-name
+  git add bin/new-executable
+
+EOS
+
+    def exec_app
+      original_cwd = Dir.pwd
+
+      loop do
+        if exe = find_executable
+          contents = File.read(exe)
+
+          if /(APP|ENGINE)_PATH/.match?(contents)
+            exec RUBY, exe, *ARGV
+            break # non reachable, hack to be able to stub exec in the test suite
+          elsif exe.end_with?("bin/rails") && contents.include?("This file was generated by Bundler")
+            $stderr.puts(BUNDLER_WARNING)
+            Object.const_set(:APP_PATH, File.expand_path("config/application", Dir.pwd))
+            require File.expand_path("../boot", APP_PATH)
+            require "rails/commands"
+            break
+          end
+        end
+
+        # If we exhaust the search there is no executable, this could be a
+        # call to generate a new application, so restore the original cwd.
+        Dir.chdir(original_cwd) && return if Pathname.new(Dir.pwd).root?
+
+        # Otherwise keep moving upwards in search of an executable.
+        Dir.chdir("..")
+      end
+    end
+
+    def find_executable
+      EXECUTABLES.find { |exe| File.file?(exe) }
+    end
+  end
+end

data/lib/rails/application/bootstrap.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "set"
+require "active_support/notifications"
+require "active_support/dependencies"
+require "active_support/descendants_tracker"
+
+module Rails
+  class Application
+    module Bootstrap
+      include Initializable
+
+      initializer :load_environment_hook, group: :all do end
+
+      initializer :load_active_support, group: :all do
+        require "active_support/all" unless config.active_support.bare
+      end
+
+      initializer :set_eager_load, group: :all do
+        if config.eager_load.nil?
+          warn <<~INFO
+            config.eager_load is set to nil. Please update your config/environments/*.rb files accordingly:
+
+              * development - set it to false
+              * test - set it to false (unless you use a tool that preloads your test environment)
+              * production - set it to true
+
+          INFO
+          config.eager_load = !config.reloading_enabled?
+        end
+      end
+
+      # Initialize the logger early in the stack in case we need to log some deprecation.
+      initializer :initialize_logger, group: :all do
+        Rails.logger ||= config.logger || begin
+          logger = if config.log_file_size
+            ActiveSupport::Logger.new(config.default_log_file, 1, config.log_file_size)
+          else
+            ActiveSupport::Logger.new(config.default_log_file)
+          end
+          logger.formatter = config.log_formatter
+          logger = ActiveSupport::TaggedLogging.new(logger)
+          logger
+        rescue StandardError
+          path = config.paths["log"].first
+          logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDERR))
+          logger.level = ActiveSupport::Logger::WARN
+          logger.warn(
+            "Rails Error: Unable to access log file. Please ensure that #{path} exists and is writable " \
+            "(i.e. make it writable for user and group: chmod 0664 #{path}). " \
+            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
+          )
+          logger
+        end
+
+        if Rails.logger.is_a?(ActiveSupport::BroadcastLogger)
+          if config.broadcast_log_level
+            Rails.logger.level = ActiveSupport::Logger.const_get(config.broadcast_log_level.to_s.upcase)
+          end
+        else
+          Rails.logger.level = ActiveSupport::Logger.const_get(config.log_level.to_s.upcase)
+          broadcast_logger = ActiveSupport::BroadcastLogger.new(Rails.logger)
+          broadcast_logger.formatter = Rails.logger.formatter
+          Rails.logger = broadcast_logger
+        end
+      end
+
+      initializer :initialize_error_reporter, group: :all do
+        if config.consider_all_requests_local
+          Rails.error.debug_mode = true
+        else
+          Rails.error.logger = Rails.logger
+        end
+      end
+
+      # Initialize cache early in the stack so railties can make use of it.
+      initializer :initialize_cache, group: :all do
+        cache_format_version = config.active_support.delete(:cache_format_version)
+        ActiveSupport.cache_format_version = cache_format_version if cache_format_version
+
+        unless Rails.cache
+          Rails.cache = ActiveSupport::Cache.lookup_store(*config.cache_store)
+
+          if Rails.cache.respond_to?(:middleware)
+            config.middleware.insert_before(::Rack::Runtime, Rails.cache.middleware)
+          end
+        end
+      end
+
+      # We setup the once autoloader this early so that engines and applications
+      # are able to autoload from these paths during initialization.
+      initializer :setup_once_autoloader, after: :set_eager_load_paths, before: :bootstrap_hook do
+        autoloader = Rails.autoloaders.once
+
+        # 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_once_paths.freeze
+        ActiveSupport::Dependencies.autoload_once_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
+
+        autoloader.setup
+      end
+
+      initializer :bootstrap_hook, group: :all do |app|
+        ActiveSupport.run_load_hooks(:before_initialize, app)
+      end
+    end
+  end
+end