omg-railties 8.0.0.alpha3

data/lib/rails/commands/console/irb_console.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "irb/helper_method"
+require "irb/command"
+
+module Rails
+  class Console
+    class RailsHelperBase < IRB::HelperMethod::Base
+      include ConsoleMethods
+    end
+
+    class ControllerHelper < RailsHelperBase
+      description "Gets helper methods available to ApplicationController."
+
+      # This method assumes an +ApplicationController+ exists, and that it extends ActionController::Base.
+      def execute
+        ApplicationController.helpers
+      end
+    end
+
+    class ControllerInstance < RailsHelperBase
+      description "Gets a new instance of ApplicationController."
+
+      # This method assumes an +ApplicationController+ exists, and that it extends ActionController::Base.
+      def execute
+        @controller ||= ApplicationController.new
+      end
+    end
+
+    class NewSession < RailsHelperBase
+      description "[Deprecated] Please use `app(true)` instead."
+
+      def execute(*)
+        app = Rails.application
+        session = ActionDispatch::Integration::Session.new(app)
+
+        # This makes app.url_for and app.foo_path available in the console
+        session.extend(app.routes.url_helpers)
+        session.extend(app.routes.mounted_helpers)
+
+        session
+      end
+    end
+
+    class AppInstance < NewSession
+      description "Creates a new ActionDispatch::Integration::Session and memoizes it. Use `app(true)` to create a new instance."
+
+      def execute(create = false)
+        @app_integration_instance = nil if create
+        @app_integration_instance ||= super
+      end
+    end
+
+    class Reloader < IRB::Command::Base
+      include ConsoleMethods
+
+      category "Rails console"
+      description "Reloads the Rails application."
+
+      def execute(*)
+        puts "Reloading..."
+        Rails.application.reloader.reload!
+      end
+    end
+
+    IRB::HelperMethod.register(:helper, ControllerHelper)
+    IRB::HelperMethod.register(:controller, ControllerInstance)
+    IRB::HelperMethod.register(:new_session, NewSession)
+    IRB::HelperMethod.register(:app, AppInstance)
+    IRB::Command.register(:reload!, Reloader)
+
+    class IRBConsole
+      def initialize(app)
+        @app = app
+
+        require "irb"
+        require "irb/completion"
+      end
+
+      def name
+        "IRB"
+      end
+
+      def start
+        IRB.setup(nil)
+
+        if !Rails.env.local? && !ENV.key?("IRB_USE_AUTOCOMPLETE")
+          IRB.conf[:USE_AUTOCOMPLETE] = false
+        end
+
+        env = colorized_env
+        prompt_prefix = "%N(#{env})"
+        IRB.conf[:IRB_NAME] = @app.name
+
+        IRB.conf[:PROMPT][:RAILS_PROMPT] = {
+          PROMPT_I: "#{prompt_prefix}> ",
+          PROMPT_S: "#{prompt_prefix}%l ",
+          PROMPT_C: "#{prompt_prefix}* ",
+          RETURN: "=> %s\n"
+        }
+
+        if current_filter = IRB.conf[:BACKTRACE_FILTER]
+          IRB.conf[:BACKTRACE_FILTER] = -> (backtrace) do
+            backtrace = current_filter.call(backtrace)
+            Rails.backtrace_cleaner.filter(backtrace)
+          end
+        else
+          IRB.conf[:BACKTRACE_FILTER] = -> (backtrace) do
+            Rails.backtrace_cleaner.filter(backtrace)
+          end
+        end
+
+        # Because some users/libs use Rails::ConsoleMethods to extend Rails console,
+        # we still include it for backward compatibility.
+        IRB::ExtendCommandBundle.include ConsoleMethods
+
+        # Respect user's choice of prompt mode.
+        IRB.conf[:PROMPT_MODE] = :RAILS_PROMPT if IRB.conf[:PROMPT_MODE] == :DEFAULT
+        IRB::Irb.new.run(IRB.conf)
+      end
+
+      def colorized_env
+        case Rails.env
+        when "development"
+          IRB::Color.colorize("dev", [:BLUE])
+        when "test"
+          IRB::Color.colorize("test", [:BLUE])
+        when "production"
+          IRB::Color.colorize("prod", [:RED])
+        else
+          Rails.env
+        end
+      end
+    end
+  end
+end

data/lib/rails/commands/credentials/USAGE

@@ -0,0 +1,73 @@
+Description:
+    The Rails `credentials` commands provide access to encrypted credentials,
+    so you can safely store access tokens, database passwords, and the like
+    safely inside the app without relying on a mess of ENVs.
+
+    This also allows for atomic deploys: no need to coordinate key changes
+    to get everything working as the keys are shipped with the code.
+
+Setup:
+    Applications after Rails 5.2 automatically have a basic credentials file generated
+    that just contains the secret_key_base used by MessageVerifiers/MessageEncryptors, like the ones
+    signing and encrypting cookies.
+
+    For applications created prior to Rails 5.2, we'll automatically generate a new
+    credentials file in `config/credentials.yml.enc` the first time you run `<%= executable(:edit) %>`.
+    If you didn't have a master key saved in `config/master.key`, that'll be created too.
+
+    Don't lose this master key! Put it in a password manager your team can access.
+    Should you lose it no one, including you, will be able to access any encrypted
+    credentials.
+
+    Don't commit the key! Add `config/master.key` to your source control's
+    ignore file. If you use Git, Rails handles this for you.
+
+    Rails also looks for the master key in `ENV["RAILS_MASTER_KEY"]`, in case that
+    is easier to manage. You could set `RAILS_MASTER_KEY` in a deployment
+    configuration, or you could prepend it to your server's start command like so:
+
+        RAILS_MASTER_KEY="very-secret-and-secure" bin/rails server
+
+    If `ENV["RAILS_MASTER_KEY"]` is present, it takes precedence over
+    `config/master.key`.
+
+Set up Git to Diff Credentials:
+    Rails provides `<%= executable(:diff) %> --enroll` to instruct Git to call
+    `<%= executable(:diff) %>` when `git diff` is run on a credentials file.
+
+    Running the command enrolls the project such that all credentials files use the
+    "rails_credentials" diff driver in .gitattributes.
+
+    Additionally, since Git requires the driver itself to be set up in a config file
+    that isn't tracked, Rails automatically ensures it's configured when running
+    `<%= executable(:edit) %>`.
+
+    Otherwise each co-worker would have to run enable manually, including on each new
+    repo clone.
+
+    To disenroll from this feature, run `<%= executable(:diff) %> --disenroll`.
+
+Editing Credentials:
+    `<%= executable(:edit) %>` will open a temporary file in `$VISUAL` or `$EDITOR`
+    with the decrypted contents to edit the encrypted credentials.
+
+    When the temporary file is next saved the contents are encrypted and written to
+    `config/credentials.yml.enc` while the file itself is destroyed to prevent credentials
+    from leaking.
+
+Environment Specific Credentials:
+    The `credentials` command supports passing an `--environment` option to create an
+    environment specific override. That override will take precedence over the
+    global `config/credentials.yml.enc` file when running in that environment. So:
+
+        <%= executable(:edit) %> --environment development
+
+    will create `config/credentials/development.yml.enc` with the corresponding
+    encryption key in `config/credentials/development.key` if the credentials file
+    doesn't exist.
+
+    In addition to that, the default credentials lookup paths can be overridden through
+    `config.credentials.content_path` and `config.credentials.key_path`.
+
+    Just as with `config/master.key`, `ENV["RAILS_MASTER_KEY"]` takes precedence
+    over any environment specific or specially configured key files.

data/lib/rails/commands/credentials/credentials_command/diffing.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Rails::Command::CredentialsCommand::Diffing # :nodoc:
+  GITATTRIBUTES_ENTRY = <<~END
+    config/credentials/*.yml.enc diff=rails_credentials
+    config/credentials.yml.enc diff=rails_credentials
+  END
+
+  def enroll_project_in_credentials_diffing
+    if enrolled_in_credentials_diffing?
+      say "Project is already enrolled in credentials file diffing."
+    else
+      gitattributes.write(GITATTRIBUTES_ENTRY, mode: "a")
+
+      say "Enrolled project in credentials file diffing!"
+      say ""
+      say "Rails will configure the Git diff driver for credentials when running `#{executable(:edit)}`. See `#{executable(:help)}` for more information."
+    end
+  end
+
+  def disenroll_project_from_credentials_diffing
+    if enrolled_in_credentials_diffing?
+      gitattributes.write(gitattributes.read.gsub(GITATTRIBUTES_ENTRY, ""))
+      gitattributes.delete if gitattributes.empty?
+
+      say "Disenrolled project from credentials file diffing!"
+    else
+      say "Project is not enrolled in credentials file diffing."
+    end
+  end
+
+  def ensure_diffing_driver_is_configured
+    configure_diffing_driver if enrolled_in_credentials_diffing? && !diffing_driver_configured?
+  end
+
+  private
+    def enrolled_in_credentials_diffing?
+      gitattributes.file? && gitattributes.read.include?(GITATTRIBUTES_ENTRY)
+    end
+
+    def diffing_driver_configured?
+      system "git config --get diff.rails_credentials.textconv", out: File::NULL
+    end
+
+    def configure_diffing_driver
+      system "git config diff.rails_credentials.textconv '#{executable(:diff)}'"
+      say "Configured Git diff driver for credentials."
+    end
+
+    def gitattributes
+      @gitattributes ||= (Rails::Command.root || Pathname.pwd).join(".gitattributes")
+    end
+end

data/lib/rails/commands/credentials/credentials_command.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "active_support"
+require "rails/command/helpers/editor"
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class CredentialsCommand < Rails::Command::Base # :nodoc:
+      include Helpers::Editor
+      include EnvironmentArgument
+
+      require_relative "credentials_command/diffing"
+      include Diffing
+
+      desc "edit", "Open the decrypted credentials in `$VISUAL` or `$EDITOR` for editing"
+      def edit
+        load_environment_config!
+        load_generators
+
+        if environment_specified?
+          @content_path = "config/credentials/#{environment}.yml.enc" unless config.overridden?(:content_path)
+          @key_path = "config/credentials/#{environment}.key" unless config.overridden?(:key_path)
+        end
+
+        ensure_encryption_key_has_been_added
+        ensure_credentials_have_been_added
+        ensure_diffing_driver_is_configured
+
+        change_credentials_in_system_editor
+      end
+
+      desc "show", "Show the decrypted credentials"
+      def show
+        load_environment_config!
+
+        say credentials.read.presence || missing_credentials_message
+      end
+
+      desc "diff", "Enroll/disenroll in decrypted diffs of credentials using git"
+      option :enroll, type: :boolean, default: false,
+        desc: "Enroll project in credentials file diffing with `git diff`"
+      option :disenroll, type: :boolean, default: false,
+        desc: "Disenroll project from credentials file diffing"
+      def diff(content_path = nil)
+        if @content_path = content_path
+          self.environment = extract_environment_from_path(content_path)
+          load_environment_config!
+
+          say credentials.read.presence || credentials.content_path.read
+        else
+          disenroll_project_from_credentials_diffing if options[:disenroll]
+          enroll_project_in_credentials_diffing if options[:enroll]
+        end
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        say credentials.content_path.read
+      end
+
+      private
+        def config
+          Rails.application.config.credentials
+        end
+
+        def content_path
+          @content_path ||= relative_path(config.content_path)
+        end
+
+        def key_path
+          @key_path ||= relative_path(config.key_path)
+        end
+
+        def credentials
+          @credentials ||= Rails.application.encrypted(content_path, key_path: key_path)
+        end
+
+        def ensure_encryption_key_has_been_added
+          return if credentials.key?
+
+          require "rails/generators/rails/encryption_key_file/encryption_key_file_generator"
+
+          encryption_key_file_generator = Rails::Generators::EncryptionKeyFileGenerator.new
+          encryption_key_file_generator.add_key_file(key_path)
+          encryption_key_file_generator.ignore_key_file(key_path)
+        end
+
+        def ensure_credentials_have_been_added
+          require "rails/generators/rails/credentials/credentials_generator"
+
+          Rails::Generators::CredentialsGenerator.new(
+            [content_path, key_path],
+            skip_secret_key_base: environment_specified? && %w[development test].include?(environment),
+            quiet: true
+          ).invoke_all
+        end
+
+        def change_credentials_in_system_editor
+          using_system_editor do
+            say "Editing #{content_path}..."
+            credentials.change { |tmp_path| system_editor(tmp_path) }
+            say "File encrypted and saved."
+            warn_if_credentials_are_invalid
+          end
+        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
+          say error.message
+        rescue ActiveSupport::MessageEncryptor::InvalidMessage
+          say "Couldn't decrypt #{content_path}. Perhaps you passed the wrong key?"
+        end
+
+        def warn_if_credentials_are_invalid
+          credentials.validate!
+        rescue ActiveSupport::EncryptedConfiguration::InvalidContentError => error
+          say "WARNING: #{error.message}", :red
+          say ""
+          say "Your application will not be able to load '#{content_path}' until the error has been fixed.", :red
+        end
+
+        def missing_credentials_message
+          if !credentials.key?
+            "Missing '#{key_path}' to decrypt credentials. See `#{executable(:help)}`."
+          else
+            "File '#{content_path}' does not exist. Use `#{executable(:edit)}` to change that."
+          end
+        end
+
+        def relative_path(path)
+          Rails.root.join(path).relative_path_from(Rails.root).to_s
+        end
+
+        def extract_environment_from_path(path)
+          available_environments.find { |env| path.end_with?("#{env}.yml.enc") } || extract_custom_environment(path)
+        end
+
+        def extract_custom_environment(path)
+          path =~ %r{config/credentials/(.+)\.yml\.enc} && $1
+        end
+    end
+  end
+end

data/lib/rails/commands/db/system/change/change_command.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/db/system/change/change_generator"
+
+module Rails
+  module Command
+    module Db
+      module System
+        class ChangeCommand < Base # :nodoc:
+          class_option :to, desc: "The database system to switch to."
+
+          def initialize(positional_args, option_args, *)
+            @argv = positional_args + option_args
+            super
+          end
+
+          desc "change", "Change `config/database.yml` and your database gem to the target database"
+          def perform(*)
+            Rails::Generators::Db::System::ChangeGenerator.start(@argv)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/commands/dbconsole/dbconsole_command.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
+require "rails/command/environment_argument"
+
+module Rails
+  class DBConsole
+    def self.start(*args)
+      new(*args).start
+    end
+
+    def initialize(options = {})
+      @options = options
+      @options[:environment] ||= Rails::Command.environment
+    end
+
+    def start
+      adapter_class.dbconsole(db_config, @options)
+    rescue NotImplementedError, ActiveRecord::AdapterNotFound, LoadError => error
+      abort error.message
+    end
+
+    def db_config
+      @db_config ||= begin
+        # If the user provided a database, use that. Otherwise find
+        # the first config in the database.yml
+        config = if database
+          @db_config = configurations.configs_for(env_name: environment, name: database, include_hidden: true)
+        else
+          @db_config = configurations.find_db_config(environment)
+        end
+
+        unless config
+          missing_db = database ? "'#{database}' database is not" : "No databases are"
+          raise ActiveRecord::AdapterNotSpecified,
+            "#{missing_db} configured for '#{environment}'. Available configuration: #{configurations.inspect}"
+        end
+
+        config.validate!
+        config
+      end
+    end
+
+    def database
+      @options[:database]
+    end
+
+    def environment
+      @options[:environment]
+    end
+
+    private
+      def adapter_class
+        ActiveRecord::ConnectionAdapters.resolve(db_config.adapter)
+      rescue LoadError
+        ActiveRecord::ConnectionAdapters::AbstractAdapter
+      end
+
+      def configurations # :doc:
+        require APP_PATH
+        ActiveRecord::Base.configurations = Rails.application.config.database_configuration
+        ActiveRecord::Base.configurations
+      end
+  end
+
+  module Command
+    class DbconsoleCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      class_option :include_password, aliases: "-p", type: :boolean,
+        desc: "Automatically provide the password from database.yml"
+
+      class_option :mode, enum: %w( html list line column ), type: :string,
+        desc: "Automatically put the sqlite3 database in the specified mode"
+
+      class_option :header, type: :boolean
+
+      class_option :database, aliases: "--db", type: :string,
+        desc: "Specify the database to use."
+
+      desc "dbconsole", "Start a console for the database specified in config/database.yml"
+      def perform
+        boot_application!
+        Rails::DBConsole.start(options)
+      end
+    end
+  end
+end

data/lib/rails/commands/destroy/destroy_command.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Rails
+  module Command
+    class DestroyCommand < Base # :nodoc:
+      no_commands do
+        def help
+          boot_application!
+          load_generators
+
+          Rails::Generators.help self.class.command_name
+        end
+      end
+
+      desc "destroy GENERATOR", "Remove code generated by `bin/rails generate`"
+      def perform(*)
+        generator = args.shift
+        return help unless generator
+
+        boot_application!
+        load_generators
+
+        Rails::Generators.invoke generator, args, behavior: :revoke, destination_root: Rails::Command.root
+      end
+    end
+  end
+end

data/lib/rails/commands/dev/dev_command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/dev_caching"
+
+module Rails
+  module Command
+    class DevCommand < Base # :nodoc:
+      desc "cache", "Toggle Action Controller development mode caching on/off"
+      def cache
+        Rails::DevCaching.enable_by_file
+      end
+    end
+  end
+end

data/lib/rails/commands/devcontainer/devcontainer_command.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/devcontainer/devcontainer_generator"
+
+module Rails
+  module Command
+    class DevcontainerCommand < Base # :nodoc:
+      desc "devcontainer", "Generate a Dev Container setup based on current application configuration"
+      def perform(*)
+        boot_application!
+
+        say "Generating Dev Container with the following options:"
+        devcontainer_options.each do |option, value|
+          say "#{option}: #{value}"
+        end
+
+        Rails::Generators::DevcontainerGenerator.new([], devcontainer_options).invoke_all
+      end
+
+      private
+        def devcontainer_options
+          @devcontainer_options ||= {
+            app_name: Rails.application.railtie_name.chomp("_application"),
+            database: !!defined?(ActiveRecord) && database,
+            active_storage: !!defined?(ActiveStorage),
+            redis: !!((defined?(ActionCable) && !defined?(SolidCable)) || (defined?(ActiveJob) && !defined?(SolidQueue))),
+            system_test: File.exist?("test/application_system_test_case.rb"),
+            node: File.exist?(".node-version"),
+          }
+        end
+
+        def database
+          adapter = ActiveRecord::Base.connection_db_config.adapter
+          adapter == "mysql2" ? "mysql" : adapter
+        end
+    end
+  end
+end

data/lib/rails/commands/encrypted/USAGE

@@ -0,0 +1,23 @@
+Description: 
+    The Rails `encrypted` commands provide access to encrypted files or configurations.
+    See the `Rails.application.encrypted` documentation for using them in your app.
+
+Encryption Keys:
+    By default, Rails looks for the encryption key in `ENV["RAILS_MASTER_KEY"]` or
+    `config/master.key`, but that lookup can be overridden with `--key`:
+
+        <%= executable(:edit) %> config/encrypted_file.yml.enc --key config/encrypted_file.key
+
+    Don't commit the key! Add it to your source control's ignore file. If you use
+    Git, Rails handles this for you.
+
+Examples:
+    To edit or create an encrypted file use:
+
+        <%= executable(:edit) %> config/encrypted_file.yml.enc
+
+    This opens a temporary file in `$VISUAL` or `$EDITOR` with the decrypted contents for editing.
+
+    To print the decrypted contents of an encrypted file use:
+
+        <%= executable(:show) %> config/encrypted_file.yml.enc