omg-railties 8.0.0.alpha3

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

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "action_dispatch"
+require "rails"
+require "rails/dev_caching"
+require "rails/command/environment_argument"
+require "rails/rackup/server"
+
+module Rails
+  class Server < Rackup::Server
+    class Options
+      def parse!(args)
+        Rails::Command::ServerCommand.new([], args).server_options
+      end
+    end
+
+    def initialize(options = nil)
+      @default_options = options || {}
+      super(@default_options)
+      set_environment
+    end
+
+    def opt_parser
+      Options.new
+    end
+
+    def set_environment
+      ENV["RAILS_ENV"] ||= options[:environment]
+    end
+
+    def start(after_stop_callback = nil)
+      trap(:INT) { exit }
+      create_tmp_directories
+      setup_dev_caching
+      log_to_stdout if options[:log_stdout]
+
+      super()
+    ensure
+      after_stop_callback.call if after_stop_callback
+    end
+
+    def serveable? # :nodoc:
+      server
+      true
+    rescue LoadError, NameError
+      false
+    end
+
+    def middleware
+      Hash.new([])
+    end
+
+    def default_options
+      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"
+          Rails::DevCaching.enable_by_argument(options[:caching])
+        end
+      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))
+        end
+      end
+
+      def log_to_stdout
+        wrapped_app # touch the app so the logger is set up
+
+        console = ActiveSupport::Logger.new(STDOUT)
+        console.formatter = Rails.logger.formatter
+        console.level = Rails.logger.level
+
+        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
+          Rails.logger.broadcast_to(console)
+        end
+      end
+
+      def use_puma?
+        server.to_s.end_with?("Handler::Puma")
+      end
+  end
+
+  module Command
+    class ServerCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      RACK_HANDLER_GEMS = %w(cgi webrick scgi thin puma unicorn falcon)
+      # Hard-coding a bunch of handlers here as we don't have a public way of
+      # querying them from the Rackup::Handler registry.
+      RACK_HANDLERS = RACK_HANDLER_GEMS + %w(fastcgi lsws)
+      RECOMMENDED_SERVER = "puma"
+
+      DEFAULT_PORT = 3000
+      DEFAULT_PIDFILE = "tmp/pids/server.pid"
+
+      class_option :port, aliases: "-p", type: :numeric,
+        desc: "Run Rails on the specified port - defaults to 3000.", banner: :port
+      class_option :binding, aliases: "-b", type: :string,
+        desc: "Bind Rails to the specified IP - defaults to 'localhost' in development and '0.0.0.0' in other environments'.",
+        banner: :IP
+      class_option :config, aliases: "-c", type: :string, default: "config.ru",
+        desc: "Use a custom rackup configuration.", banner: :file
+      class_option :daemon, aliases: "-d", type: :boolean, default: false,
+        desc: "Run server as a Daemon."
+      class_option :using, aliases: "-u", type: :string,
+        desc: "Specify the Rack server used to run the application (thin/puma/webrick).", banner: :name
+      class_option :pid, aliases: "-P", type: :string,
+        desc: "Specify the PID file. Defaults to #{DEFAULT_PIDFILE} in development."
+      class_option :dev_caching, aliases: "-C", type: :boolean, default: nil,
+        desc: "Specify whether to perform caching in development."
+      class_option :restart, type: :boolean, default: nil, hide: true
+      class_option :early_hints, type: :boolean, default: nil, desc: "Enable 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, *)
+        super
+
+        @original_options = local_options - %w( --restart )
+      end
+
+      desc "server", "Start the Rails server"
+      def perform
+        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)
+
+          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
+
+      no_commands do
+        def server_options
+          {
+            user_supplied_options: user_supplied_options,
+            server:                options[:using],
+            log_stdout:            log_to_stdout?,
+            Port:                  port,
+            Host:                  host,
+            DoNotReverseLookup:    true,
+            config:                options[:config],
+            environment:           environment,
+            daemonize:             options[:daemon],
+            pid:                   pid,
+            caching:               options[:dev_caching],
+            restart_cmd:           restart_command,
+            early_hints:           early_hints
+          }
+        end
+      end
+
+      private
+        def user_supplied_options
+          @user_supplied_options ||= begin
+            # Convert incoming options array to a hash of flags
+            #   ["-p3001", "-C", "--binding", "127.0.0.1"] # => {"-p"=>true, "-C"=>true, "--binding"=>true}
+            user_flag = {}
+            @original_options.each do |command|
+              if command.start_with?("--")
+                option = command.split("=")[0]
+                user_flag[option] = true
+              elsif command =~ /\A(-.)/
+                user_flag[Regexp.last_match[0]] = true
+              end
+            end
+
+            # Collect all options that the user has explicitly defined so we can
+            # differentiate them from defaults
+            user_supplied_options = []
+            self.class.class_options.select do |key, option|
+              if option.aliases.any? { |name| user_flag[name] } || user_flag["--#{option.name}"]
+                name = option.name.to_sym
+                case name
+                when :port
+                  name = :Port
+                when :binding
+                  name = :Host
+                when :dev_caching
+                  name = :caching
+                when :daemonize
+                  name = :daemon
+                end
+                user_supplied_options << name
+              end
+            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
+
+        def port
+          options[:port] || ENV.fetch("PORT", DEFAULT_PORT).to_i
+        end
+
+        def host
+          if options[:binding]
+            options[:binding]
+          else
+            default_host = environment == "development" ? "localhost" : "0.0.0.0"
+
+            ENV.fetch("BINDING", default_host)
+          end
+        end
+
+        def environment
+          options[:environment] || Rails::Command.environment
+        end
+
+        def restart_command
+          "#{executable} #{@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
+          default_pidfile = environment == "development" ? DEFAULT_PIDFILE : nil
+          pid = options[:pid] || ENV["PIDFILE"] || default_pidfile
+          File.expand_path(pid) if pid
+        end
+
+        def prepare_restart
+          FileUtils.rm_f(pid) if pid && options[:restart]
+        end
+
+        def rack_server_suggestion(server)
+          if server.nil?
+            <<~MSG
+              Could not find a server gem. Maybe you need to add one to the Gemfile?
+
+                gem "#{RECOMMENDED_SERVER}"
+
+              Run `#{executable} --help` for more options.
+            MSG
+          elsif server.in?(RACK_HANDLER_GEMS)
+            <<~MSG
+              Could not load server "#{server}". Maybe you need to the add it to the Gemfile?
+
+                gem "#{server}"
+
+              Run `#{executable} --help` for more options.
+            MSG
+          else
+            error = CorrectableNameError.new("Could not find server '#{server}'.", server, RACK_HANDLERS)
+            <<~MSG
+              #{error.detailed_message}
+              Run `#{executable} --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 `#{executable} --help` for more startup options
+          MSG
+        end
+    end
+  end
+end

data/lib/rails/commands/stats/stats_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class StatsCommand < Base # :nodoc:
+      desc "stats", "Report code statistics (KLOCs, etc) from the application or engine"
+      def perform
+        require "rails/code_statistics"
+        boot_application!
+
+        stat_directories = Rails::CodeStatistics.directories.map do |name, dir|
+          [name, Rails::Command.application_root.join(dir)]
+        end.select { |name, dir| File.directory?(dir) }
+
+        Rails::CodeStatistics.new(*stat_directories).to_s
+      end
+    end
+  end
+end

data/lib/rails/commands/test/USAGE

@@ -0,0 +1,14 @@
+Examples:
+    You can run a single test by appending a line number to a filename:
+
+        <%= executable %> test/models/user_test.rb:27
+
+    You can run multiple tests with in a line range by appending the line range to a filename:
+
+        <%= executable %> test/models/user_test.rb:10-20
+
+    You can run multiple files and directories at the same time:
+
+        <%= executable %> test/controllers test/integration/login_test.rb
+
+    By default test failures and errors are reported inline during a run.

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "rails/command"
+require "rails/commands/rake/rake_command"
+require "rails/test_unit/runner"
+require "rails/test_unit/reporter"
+
+module Rails
+  module Command
+    class TestCommand < Base # :nodoc:
+      def self.executable(*args)
+        args.empty? ? Rails::TestUnitReporter.executable : super
+      end
+
+      no_commands do
+        def help(command_name = nil, *)
+          super
+          if command_name == "test"
+            say ""
+            say self.class.class_usage
+          end
+          say ""
+          Minitest.run(%w(--help))
+        end
+      end
+
+      desc "test [PATHS...]", "Run tests except system tests"
+      def perform(*args)
+        $LOAD_PATH << Rails::Command.root.join("test").to_s
+
+        Rails::TestUnit::Runner.parse_options(args)
+        run_prepare_task if self.args.none?(EXACT_TEST_ARGUMENT_PATTERN)
+        Rails::TestUnit::Runner.run(args)
+      rescue Rails::TestUnit::InvalidTestError => error
+        raise ArgumentError, error.message
+      end
+
+      # Define Thor tasks to avoid going through Rake and booting twice when using bin/rails test:*
+      Rails::TestUnit::Runner::TEST_FOLDERS.each do |name|
+        desc name, "Run tests in test/#{name}"
+        define_method(name) do |*args|
+          perform("test/#{name}", *args)
+        end
+      end
+
+      desc "all", "Run all tests, including system tests"
+      def all(*args)
+        perform("test/**/*_test.rb", *args)
+      end
+
+      desc "functionals", "Run tests in test/controllers, test/mailers, and test/functional"
+      def functionals(*args)
+        perform("test/controllers", "test/mailers", "test/functional", *args)
+      end
+
+      desc "units", "Run tests in test/models, test/helpers, and test/unit"
+      def units(*args)
+        perform("test/models", "test/helpers", "test/unit", *args)
+      end
+
+      desc "system", "Run system tests only"
+      def system(*args)
+        perform("test/system", *args)
+      end
+
+      desc "generators", "Run tests in test/lib/generators"
+      def generators(*args)
+        perform("test/lib/generators", *args)
+      end
+
+      private
+        EXACT_TEST_ARGUMENT_PATTERN = /^-n|^--name\b|#{Rails::TestUnit::Runner::PATH_ARGUMENT_PATTERN}/
+
+        def run_prepare_task
+          Rails::Command::RakeCommand.perform("test:prepare", [], {})
+        rescue UnrecognizedCommandError => error
+          raise unless error.name == "test:prepare"
+        end
+    end
+  end
+end

data/lib/rails/commands/unused_routes/unused_routes_command.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rails/commands/routes/routes_command"
+
+module Rails
+  module Command
+    class UnusedRoutesCommand < Rails::Command::Base # :nodoc:
+      hide_command!
+      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 RouteInfo
+        def initialize(route)
+          requirements = route.requirements
+          @controller_name = requirements[:controller]
+          @action_name = requirements[:action]
+          @controller_class = (@controller_name.to_s.camelize + "Controller").safe_constantize
+        end
+
+        def unused?
+          controller_class_missing? || (action_missing? && template_missing?)
+        end
+
+        private
+          def view_path(root)
+            File.join(root.path, @controller_name, @action_name)
+          end
+
+          def controller_class_missing?
+            @controller_name && @controller_class.nil?
+          end
+
+          def template_missing?
+            @controller_class && @controller_class.try(:view_paths).to_a.flat_map { |path| Dir["#{view_path(path)}.*"] }.none?
+          end
+
+          def action_missing?
+            @controller_class && @controller_class.instance_methods.exclude?(@action_name.to_sym)
+          end
+      end
+
+      def perform(*)
+        boot_application!
+        require "action_dispatch/routing/inspector"
+
+        say(inspector.format(formatter, routes_filter))
+
+        exit(1) if routes.any?
+      end
+
+      private
+        def inspector
+          ActionDispatch::Routing::RoutesInspector.new(routes)
+        end
+
+        def routes
+          @routes ||= begin
+            routes = Rails.application.routes.routes.select do |route|
+              RouteInfo.new(route).unused?
+            end
+
+            ActionDispatch::Journey::Routes.new(routes)
+          end
+        end
+
+        def formatter
+          ActionDispatch::Routing::ConsoleFormatter::Unused.new
+        end
+
+        def routes_filter
+          options.symbolize_keys.slice(:controller, :grep)
+        end
+    end
+  end
+end

data/lib/rails/commands/version/version_command.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class VersionCommand < Base # :nodoc:
+      desc "version", "Show the Rails version"
+      def perform
+        Rails::Command.invoke :application, [ "--version" ]
+      end
+    end
+  end
+end

data/lib/rails/commands.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "rails/command"
+
+aliases = {
+  "g"  => "generate",
+  "d"  => "destroy",
+  "c"  => "console",
+  "s"  => "server",
+  "db" => "dbconsole",
+  "r"  => "runner",
+  "t"  => "test"
+}
+
+command = ARGV.shift
+command = aliases[command] || command
+
+Rails::Command.invoke command, ARGV

data/lib/rails/configuration.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "active_support/ordered_options"
+require "active_support/core_ext/object"
+require "rails/paths"
+require "rails/rack"
+
+module Rails
+  module Configuration
+    # MiddlewareStackProxy is a proxy for the \Rails middleware stack that allows
+    # you to configure middlewares in your application. It works basically as a
+    # command recorder, saving each command to be applied after initialization
+    # over the default middleware stack, so you can add, swap, or remove any
+    # middleware in \Rails.
+    #
+    # You can add your own middlewares by using the +config.middleware.use+ method:
+    #
+    #     config.middleware.use Magical::Unicorns
+    #
+    # This will put the +Magical::Unicorns+ middleware on the end of the stack.
+    # You can use +insert_before+ if you wish to add a middleware before another:
+    #
+    #     config.middleware.insert_before Rack::Head, Magical::Unicorns
+    #
+    # There's also +insert_after+ which will insert a middleware after another:
+    #
+    #     config.middleware.insert_after Rack::Head, Magical::Unicorns
+    #
+    # Middlewares can also be completely swapped out and replaced with others:
+    #
+    #     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 +Magical::Unicorns+ middleware before the
+    # +ActionDispatch::Flash+. 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
+    #
+    class MiddlewareStackProxy
+      def initialize(operations = [], delete_operations = [])
+        @operations = operations
+        @delete_operations = delete_operations
+      end
+
+      def insert_before(...)
+        @operations << -> middleware { middleware.insert_before(...) }
+      end
+
+      alias :insert :insert_before
+
+      def insert_after(...)
+        @operations << -> middleware { middleware.insert_after(...) }
+      end
+
+      def swap(...)
+        @operations << -> middleware { middleware.swap(...) }
+      end
+
+      def use(...)
+        @operations << -> middleware { middleware.use(...) }
+      end
+
+      def delete(...)
+        @delete_operations << -> middleware { middleware.delete(...) }
+      end
+
+      def move_before(...)
+        @delete_operations << -> middleware { middleware.move_before(...) }
+      end
+
+      alias :move :move_before
+
+      def move_after(...)
+        @delete_operations << -> middleware { middleware.move_after(...) }
+      end
+
+      def unshift(...)
+        @operations << -> middleware { middleware.unshift(...) }
+      end
+
+      def merge_into(other) # :nodoc:
+        (@operations + @delete_operations).each do |operation|
+          operation.call(other)
+        end
+
+        other
+      end
+
+      def +(other) # :nodoc:
+        MiddlewareStackProxy.new(@operations + other.operations, @delete_operations + other.delete_operations)
+      end
+
+      protected
+        attr_reader :operations, :delete_operations
+    end
+
+    class Generators # :nodoc:
+      attr_accessor :aliases, :options, :templates, :fallbacks, :colorize_logging, :api_only
+      attr_reader :hidden_namespaces, :after_generate_callbacks
+
+      def initialize
+        @aliases = Hash.new { |h, k| h[k] = {} }
+        @options = Hash.new { |h, k| h[k] = {} }
+        @fallbacks = {}
+        @templates = []
+        @colorize_logging = true
+        @api_only = false
+        @hidden_namespaces = []
+        @after_generate_callbacks = []
+      end
+
+      def initialize_copy(source)
+        @aliases = @aliases.deep_dup
+        @options = @options.deep_dup
+        @fallbacks = @fallbacks.deep_dup
+        @templates = @templates.dup
+      end
+
+      def hide_namespace(namespace)
+        @hidden_namespaces << namespace
+      end
+
+      def after_generate(&block)
+        @after_generate_callbacks << block
+      end
+
+      def apply_rubocop_autocorrect_after_generate!
+        after_generate do |files|
+          parsable_files = files.filter { |file| File.exist?(file) && file.end_with?(".rb") }
+          unless parsable_files.empty?
+            system(RbConfig.ruby, "bin/rubocop", "-A", "--fail-level=E", "--format=quiet", *parsable_files, exception: true)
+          end
+        end
+      end
+
+      def method_missing(method, *args)
+        method = method.name.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
+        else
+          namespace, configuration = args.shift, args.shift
+          namespace = namespace.to_sym if namespace.respond_to?(:to_sym)
+          @options[:rails][method] = namespace
+        end
+
+        if configuration
+          aliases = configuration.delete(:aliases)
+          @aliases[namespace].merge!(aliases) if aliases
+          @options[namespace].merge!(configuration)
+        end
+      end
+    end
+  end
+end

data/lib/rails/console/app.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Rails.deprecator.warn(<<~MSG, caller_locations(0..1))
+`rails/console/app` has been deprecated and will be removed in Rails 8.0.
+Please require `rails/console/methods` instead.
+MSG
+
+require "rails/console/methods"