railties 7.0.8 → 7.2.0

data/lib/rails/generators/rails/credentials/credentials_generator.rb

@@ -7,49 +7,54 @@ require "active_support/encrypted_configuration"
 module Rails
   module Generators
     class CredentialsGenerator < Base # :nodoc:
+      argument :content_path, default: "config/credentials.yml.enc"
+      argument :key_path, default: "config/master.key"
+      class_option :skip_secret_key_base, type: :boolean
+
       def add_credentials_file
-        unless credentials.content_path.exist?
-          template = credentials_template
+        in_root do
+          return if File.exist?(content_path)
 
-          say "Adding #{credentials.content_path} to store encrypted credentials."
+          say "Adding #{content_path} to store encrypted credentials."
           say ""
+
+          content = render_template_to_encrypted_file
+
           say "The following content has been encrypted with the Rails master key:"
           say ""
-          say template, :on_green
+          say content, :on_green
           say ""
-
-          add_credentials_file_silently(template)
-
           say "You can edit encrypted credentials with `bin/rails credentials:edit`."
           say ""
         end
       end
 
-      def add_credentials_file_silently(template = nil)
-        unless credentials.content_path.exist?
-          credentials.write(credentials_template)
-        end
-      end
-
       private
-        def credentials
+        def encrypted_file
           ActiveSupport::EncryptedConfiguration.new(
-            config_path: "config/credentials.yml.enc",
-            key_path: "config/master.key",
+            config_path: content_path,
+            key_path: key_path,
             env_key: "RAILS_MASTER_KEY",
             raise_if_missing_key: true
           )
         end
 
-        def credentials_template
-          <<~YAML
-            # aws:
-            #   access_key_id: 123
-            #   secret_access_key: 345
+        def secret_key_base
+          @secret_key_base ||= SecureRandom.hex(64)
+        end
+
+        def render_template_to_encrypted_file
+          empty_directory File.dirname(content_path)
+
+          content = nil
+
+          encrypted_file.change do |tmp_path|
+            template("credentials.yml", tmp_path, force: true, verbose: false) do |rendered|
+              content = rendered
+            end
+          end
 
-            # Used as the base secret for all MessageVerifiers in Rails, including the one protecting cookies.
-            secret_key_base: #{SecureRandom.hex(64)}
-          YAML
+          content
         end
     end
   end

data/lib/rails/generators/rails/credentials/templates/credentials.yml.tt

@@ -0,0 +1,8 @@
+# aws:
+#   access_key_id: 123
+#   secret_access_key: 345
+<% unless options.skip_secret_key_base? -%>
+
+# Used as the base secret for all MessageVerifiers in Rails, including the one protecting cookies.
+secret_key_base: <%= secret_key_base %>
+<% end -%>

data/lib/rails/generators/rails/db/system/change/change_generator.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 require "rails/generators/base"
+require "yaml"
+require "json"
 
 module Rails
   module Generators
     module Db
       module System
         class ChangeGenerator < Base # :nodoc:
-          include Database
           include AppName
 
+          BASE_PACKAGES = %w( curl libvips )
+          BUILD_PACKAGES = %w( build-essential git )
+
           class_option :to, required: true,
             desc: "The database system to switch to."
 
@@ -21,8 +25,8 @@ module Rails
           def initialize(*)
             super
 
-            unless DATABASES.include?(options[:to])
-              raise Error, "Invalid value for --to option. Supported preconfigurations are: #{DATABASES.join(", ")}."
+            unless Database::DATABASES.include?(options[:to])
+              raise Error, "Invalid value for --to option. Supported preconfigurations are: #{Database::DATABASES.join(", ")}."
             end
 
             opt = options.dup
@@ -35,14 +39,53 @@ module Rails
           end
 
           def edit_gemfile
-            name, version = gem_for_database
+            name, version = database.gem
             gsub_file("Gemfile", all_database_gems_regex, name)
             gsub_file("Gemfile", gem_entry_regex_for(name), gem_entry_for(name, *version))
           end
 
+          def edit_dockerfile
+            dockerfile_path = File.expand_path("Dockerfile", destination_root)
+            return unless File.exist?(dockerfile_path)
+
+            gsub_file("Dockerfile", all_docker_bases_regex, docker_base_packages(database.base_package))
+            gsub_file("Dockerfile", all_docker_builds_regex, docker_build_packages(database.build_package))
+          end
+
+          def edit_devcontainer_files
+            return unless devcontainer?
+
+            edit_devcontainer_json
+            edit_compose_yaml
+          end
+
           private
             def all_database_gems
-              DATABASES.map { |database| gem_for_database(database) }
+              Database.all.map { |database| database.gem }
+            end
+
+            def all_docker_bases
+              Database.all.map { |database| docker_base_packages(database.base_package) }.uniq
+            end
+
+            def docker_base_packages(database_package)
+              if database_package
+                [database_package].concat(BASE_PACKAGES).sort
+              else
+                BASE_PACKAGES
+              end.join("\s")
+            end
+
+            def all_docker_builds
+              Database.all.map { |database| docker_build_packages(database.build_package) }.uniq
+            end
+
+            def docker_build_packages(database_package)
+              if database_package
+                [database_package].concat(BUILD_PACKAGES).sort
+              else
+                BUILD_PACKAGES
+              end.join("\s")
             end
 
             def all_database_gems_regex
@@ -50,6 +93,14 @@ module Rails
               /(\b#{all_database_gem_names.join('\b|\b')}\b)/
             end
 
+            def all_docker_bases_regex
+              /(\b#{all_docker_bases.join('\b|\b')}\b)/
+            end
+
+            def all_docker_builds_regex
+              /(\b#{all_docker_builds.join('\b|\b')}\b)/
+            end
+
             def gem_entry_regex_for(gem_name)
               /^gem.*\b#{gem_name}\b.*/
             end
@@ -58,6 +109,96 @@ module Rails
               gem_name_and_version.map! { |segment| "\"#{segment}\"" }
               "gem #{gem_name_and_version.join(", ")}"
             end
+
+            def edit_devcontainer_json
+              return unless devcontainer_json
+
+              update_devcontainer_db_host
+              update_devcontainer_db_feature
+            end
+
+            def edit_compose_yaml
+              compose_yaml_path = File.expand_path(".devcontainer/compose.yaml", destination_root)
+              return unless File.exist?(compose_yaml_path)
+
+              compose_config = YAML.load_file(compose_yaml_path)
+
+              Database.all.each do |database|
+                compose_config["services"].delete(database.name)
+                compose_config["volumes"]&.delete(database.volume)
+                compose_config["services"]["rails-app"]["depends_on"]&.delete(database.name)
+              end
+
+              if database.service
+                compose_config["services"][database.name] = database.service
+                compose_config["volumes"] = { database.volume => nil }.merge(compose_config["volumes"] || {})
+                compose_config["services"]["rails-app"]["depends_on"] = [
+                  database.name,
+                  compose_config["services"]["rails-app"]["depends_on"]
+                ].flatten.compact
+              end
+
+              compose_config.delete("volumes") unless compose_config["volumes"]&.any?
+              compose_config["services"]["rails-app"].delete("depends_on") unless compose_config["services"]["rails-app"]["depends_on"]&.any?
+
+              File.write(compose_yaml_path, compose_config.to_yaml)
+            end
+
+            def update_devcontainer_db_host
+              container_env = devcontainer_json["containerEnv"]
+              db_name = database.name
+
+              if container_env["DB_HOST"]
+                if database.service
+                  container_env["DB_HOST"] = db_name
+                else
+                  container_env.delete("DB_HOST")
+                end
+              else
+                if database.service
+                  container_env["DB_HOST"] = db_name
+                end
+              end
+
+              new_json = JSON.pretty_generate(container_env, indent: "  ", object_nl: "\n  ")
+
+              gsub_file(".devcontainer/devcontainer.json", /("containerEnv"\s*:\s*)(.|\n)*?(^\s{2}})/, "\\1#{new_json}")
+            end
+
+            def update_devcontainer_db_feature
+              features = devcontainer_json["features"]
+              db_feature = database.feature
+
+              Database.all.each do |database|
+                features.delete(database.feature_name)
+              end
+
+              features.merge!(db_feature) if db_feature
+
+              new_json = JSON.pretty_generate(features, indent: "  ", object_nl: "\n  ")
+
+              gsub_file(".devcontainer/devcontainer.json", /("features"\s*:\s*)(.|\n)*?(^\s{2}})/, "\\1#{new_json}")
+            end
+
+            def devcontainer_json
+              return unless File.exist?(devcontainer_json_path)
+
+              @devcontainer_json ||= JSON.parse(File.read(devcontainer_json_path))
+            end
+
+            def devcontainer_json_path
+              File.expand_path(".devcontainer/devcontainer.json", destination_root)
+            end
+
+            def database
+              @database ||= Database.build(options[:database])
+            end
+
+            def devcontainer?
+              return @devcontainer if defined?(@devcontainer)
+
+              @devcontainer = File.exist?(File.expand_path(".devcontainer", destination_root))
+            end
         end
       end
     end

data/lib/rails/generators/rails/devcontainer/devcontainer_generator.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Rails
+  module Generators
+    class DevcontainerGenerator < Base # :nodoc:
+      class_option :app_name, type: :string, default: "rails_app",
+                   desc: "Name of the app"
+
+      class_option :database, enum: Database::DATABASES, type: :string, default: "sqlite3",
+                   desc: "Include configuration for selected database"
+
+      class_option :redis, type: :boolean, default: true,
+                   desc: "Include configuration for Redis"
+
+      class_option :system_test, type: :boolean, default: true,
+                   desc: "Include configuration for System Tests"
+
+      class_option :active_storage, type: :boolean, default: true,
+                   desc: "Include configuration for Active Storage"
+
+      class_option :node, type: :boolean, default: false,
+                   desc: "Include configuration for Node"
+
+      class_option :dev, type: :boolean, default: false,
+                    desc: "For applications pointing to a local Rails checkout"
+
+      source_paths << File.expand_path(File.join(base_name, "app", "templates"), base_root)
+
+      def create_devcontainer
+        empty_directory ".devcontainer"
+
+        template "devcontainer/devcontainer.json", ".devcontainer/devcontainer.json"
+        template "devcontainer/Dockerfile", ".devcontainer/Dockerfile"
+        template "devcontainer/compose.yaml", ".devcontainer/compose.yaml"
+      end
+
+      def update_application_system_test_case
+        return unless options[:system_test]
+        return unless File.exist?("test/application_system_test_case.rb")
+
+        gsub_file("test/application_system_test_case.rb", /^\s*driven_by\b.*/, system_test_configuration)
+      end
+
+      def update_database_yml
+        # Only postgresql has devcontainer specific configuration, so only update database.yml if we are using postgres
+        return unless options[:database] == "postgresql"
+
+        template("config/databases/#{options[:database]}.yml", "config/database.yml")
+      end
+
+      private
+        def devcontainer?
+          true
+        end
+
+        def app_name
+          options[:app_name]
+        end
+
+        def dependencies
+          return @dependencies if @dependencies
+
+          @dependencies = []
+
+          @dependencies << "selenium" if options[:system_test]
+          @dependencies << "redis" if options[:redis]
+          @dependencies << database.name if database.service
+          @dependencies
+        end
+
+        def container_env
+          return @container_env if @container_env
+
+          @container_env = {}
+
+          @container_env["CAPYBARA_SERVER_PORT"] = "45678" if options[:system_test]
+          @container_env["SELENIUM_HOST"] = "selenium" if options[:system_test]
+          @container_env["REDIS_URL"] = "redis://redis:6379/1" if options[:redis]
+          @container_env["DB_HOST"] = database.name if database.service
+
+          @container_env
+        end
+
+        def volumes
+          return @volumes if @volumes
+
+          @volumes = []
+
+          @volumes << "redis-data" if options[:redis]
+          @volumes << database.volume if database.volume
+
+          @volumes
+        end
+
+        def features
+          return @features if @features
+
+          @features = {
+            "ghcr.io/devcontainers/features/github-cli:1" => {}
+          }
+
+          @features["ghcr.io/rails/devcontainer/features/activestorage"] = {} if options[:active_storage]
+          @features["ghcr.io/devcontainers/features/node:1"] = {} if options[:node]
+
+          @features.merge!(database.feature) if database.feature
+
+          @features
+        end
+
+        def mounts
+          return @mounts if @mounts
+
+          @mounts = []
+
+          @mounts << local_rails_mount if options[:dev]
+
+          @mounts
+        end
+
+        def forward_ports
+          return @forward_ports if @forward_ports
+
+          @forward_ports = [3000]
+          @forward_ports << database.port if database.port
+          @forward_ports << 6379 if options[:redis]
+
+          @forward_ports
+        end
+
+        def database
+          @database ||= Database.build(options[:database])
+        end
+
+        def devcontainer_db_service_yaml(**options)
+          return unless service = database.service
+
+          { database.name => service }.to_yaml(**options)[4..-1]
+        end
+
+        def local_rails_mount
+          {
+            type: "bind",
+            source: Rails::Generators::RAILS_DEV_PATH,
+            target: Rails::Generators::RAILS_DEV_PATH
+          }
+        end
+
+        def system_test_configuration
+          optimize_indentation(<<-'RUBY', 2)
+            if ENV["CAPYBARA_SERVER_PORT"]
+              served_by host: "rails-app", port: ENV["CAPYBARA_SERVER_PORT"]
+
+              driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ], options: {
+                browser: :remote,
+                url: "http://#{ENV["SELENIUM_HOST"]}:4444"
+              }
+            else
+              driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
+            end
+          RUBY
+        end
+    end
+  end
+end

data/lib/rails/generators/rails/devcontainer/templates/devcontainer/Dockerfile.tt

@@ -0,0 +1,3 @@
+# Make sure RUBY_VERSION matches the Ruby version in .ruby-version
+ARG RUBY_VERSION=<%= gem_ruby_version %>
+FROM ghcr.io/rails/devcontainer/images/ruby:$RUBY_VERSION

data/lib/rails/generators/rails/devcontainer/templates/devcontainer/compose.yaml.tt

@@ -0,0 +1,47 @@
+name: "<%= options[:app_name] %>"
+
+services:
+  rails-app:
+    build:
+      context: ..
+      dockerfile: .devcontainer/Dockerfile
+
+    volumes:
+    - ../..:/workspaces:cached
+
+    # Overrides default command so things don't shut down after the process ends.
+    command: sleep infinity
+
+    # Uncomment the next line to use a non-root user for all processes.
+    # user: vscode
+
+    # Use "forwardPorts" in **devcontainer.json** to forward an app port locally.
+    # (Adding the "ports" property to this file will not forward from a Codespace.)
+<%- if !dependencies.empty? -%>
+    depends_on:
+<%- dependencies.each do |dependency| -%>
+    - <%= dependency %>
+<%- end -%>
+<%- end -%>
+<%- if options[:system_test] -%>
+
+  selenium:
+    image: selenium/standalone-chromium
+    restart: unless-stopped
+<%- end -%>
+
+<%- if options[:redis] -%>
+  redis:
+    image: redis:7.2
+    restart: unless-stopped
+    volumes:
+    - redis-data:/data
+
+<%- end -%>
+  <%= devcontainer_db_service_yaml(indentation: 4) %>
+<%- if !volumes.empty? -%>
+volumes:
+<%- volumes.each do |volume| -%>
+  <%= volume %>:
+<%- end -%>
+<%- end -%>

data/lib/rails/generators/rails/devcontainer/templates/devcontainer/devcontainer.json.tt

@@ -0,0 +1,37 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/ruby
+{
+  "name": "<%= options[:app_name] %>",
+  "dockerComposeFile": "compose.yaml",
+  "service": "rails-app",
+  "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
+
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  "features": {
+    <%= features.map { |key, value| "\"#{key}\": #{value.as_json}" }.join(",\n    ") %>
+  },
+
+<%- if !container_env.empty? -%>
+  "containerEnv": {
+    <%= container_env.map { |key, value| "\"#{key}\": \"#{value}\"" }.join(",\n    ") %>
+  },
+<%- end -%>
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  "forwardPorts": <%= forward_ports.as_json %>,
+
+  // Configure tool-specific properties.
+  // "customizations": {},
+
+  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+  // "remoteUser": "root",
+
+<%- if !mounts.empty? -%>
+  "mounts": [
+    <%= mounts.map { |mount| "{\n      " + mount.map { |key, value| "\"#{key}\": \"#{value}\"" }.join(",\n      ") + "\n    }" }.join(",\n    ") %>
+  ],
+<%- end -%>
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  "postCreateCommand": "bin/setup"
+}

data/lib/rails/generators/rails/encryption_key_file/encryption_key_file_generator.rb

@@ -26,8 +26,7 @@ module Rails
       end
 
       def add_key_file_silently(key_path, key = nil)
-        create_file key_path, key || ActiveSupport::EncryptedFile.generate_key
-        key_path.chmod 0600
+        create_file key_path, key || ActiveSupport::EncryptedFile.generate_key, perm: 0600
       end
 
       def ignore_key_file(key_path, ignore: key_ignore(key_path))

data/lib/rails/generators/rails/migration/USAGE

@@ -5,31 +5,41 @@ Description:
     A migration class is generated in db/migrate prefixed by a timestamp of the current date and time.
 
     You can name your migration in either of these formats to generate add/remove
-    column lines from supplied attributes: AddColumnsToTable or RemoveColumnsFromTable
+    column lines from supplied attributes: add_{columns}_to_{table} or remove_{columns}_from_{table}.
 
-Example:
-    `bin/rails generate migration AddSslFlag`
+    A migration name containing JoinTable will generate join tables for use with
+    has_and_belongs_to_many associations.
+
+    You can also name your migration create_{table} along with any attributes to generate a regular table.
+
+Examples:
+    `bin/rails generate migration add_ssl_flag`
 
     If the current date is May 14, 2008 and the current time 09:09:12, this creates the AddSslFlag migration
     db/migrate/20080514090912_add_ssl_flag.rb
 
-    `bin/rails generate migration AddTitleBodyToPost title:string body:text published:boolean`
+    `bin/rails generate migration add_title_body_published_to_post title:string body:text published:boolean`
 
-    This will create the AddTitleBodyToPost in db/migrate/20080514090912_add_title_body_to_post.rb with this in the Change migration:
+    This will create db/migrate/20080514090912_add_title_body_published_to_post.rb with this in the migration:
 
       add_column :posts, :title, :string
       add_column :posts, :body, :text
       add_column :posts, :published, :boolean
 
-Migration names containing JoinTable will generate join tables for use with
-has_and_belongs_to_many associations.
+    `bin/rails generate migration create_media_join_table artists musics:uniq`
 
-Example:
-    `bin/rails g migration CreateMediaJoinTable artists musics:uniq`
-
-    will create the migration
+    This will create a join table migration:
 
     create_join_table :artists, :musics do |t|
       # t.index [:artist_id, :music_id]
       t.index [:music_id, :artist_id], unique: true
     end
+
+    `bin/rails generate migration create_users email:string`
+
+    This will create the migration:
+
+    create_table :users do |t|
+      t.string :email
+      t.timestamps
+    end

data/lib/rails/generators/rails/migration/migration_generator.rb

@@ -5,6 +5,10 @@ module Rails
     class MigrationGenerator < NamedBase # :nodoc:
       argument :attributes, type: :array, default: [], banner: "field[:type][:index] field[:type][:index]"
       hook_for :orm, required: true, desc: "ORM to be invoked"
+
+      def self.exit_on_failure? # :nodoc:
+        true
+      end
     end
   end
 end

data/lib/rails/generators/rails/model/model_generator.rb

@@ -9,6 +9,10 @@ module Rails
 
       argument :attributes, type: :array, default: [], banner: "field[:type][:index] field[:type][:index]"
       hook_for :orm, required: true, desc: "ORM to be invoked"
+
+      class << self
+        delegate(:desc, to: :orm_generator)
+      end
     end
   end
 end

data/lib/rails/generators/rails/plugin/USAGE

@@ -1,10 +1,21 @@
 Description:
-    The 'rails plugin new' command creates a skeleton for developing any
-    kind of Rails extension with ability to run tests using dummy Rails
-    application.
+    The `rails plugin new` command creates a Rails plugin with the ability
+    to run tests using a dummy Rails application. A plugin is a gem with
+    either a railtie or an engine.
 
-Example:
-    rails plugin new ~/Code/Ruby/blog
+Examples:
+    `rails plugin new ~/Code/Ruby/blog`
 
-    This generates a skeletal Rails plugin in ~/Code/Ruby/blog.
+    This generates a Rails railtie gem in ~/Code/Ruby/blog.
     See the README in the newly created plugin to get going.
+
+    `rails plugin new blog --full`
+
+    This generates a full Rails engine gem in ./blog. The `--mountable`
+    option may also be used to generate a mountable, namespace-isolated
+    engine with assets and layouts.
+
+    `rails plugin new blog --mountable --skip-asset-pipeline`
+
+    This generates a mountable Rails engine gem at ./blog without an asset
+    pipeline. Any part of Rails can be skipped during plugin generation.