railties 7.1.3.4 → 7.2.0.beta1

data/lib/rails/generators/rails/app/templates/config/puma.rb.tt

@@ -2,34 +2,53 @@
 # are invoked here are part of Puma's configuration DSL. For more information
 # about methods provided by the DSL, see https://puma.io/puma/Puma/DSL.html.
 
-# Puma can serve each request in a thread from an internal thread pool.
-# The `threads` method setting takes two numbers: a minimum and maximum.
-# Any libraries that use thread pools should be configured to match
-# the maximum value specified for Puma. Default is set to 5 threads for minimum
-# and maximum; this matches the default thread size of Active Record.
-max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
-min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count }
-threads min_threads_count, max_threads_count
+# Puma starts a configurable number of processes (workers) and each process
+# serves each request in a thread from an internal thread pool.
+#
+# The ideal number of threads per worker depends both on how much time the
+# application spends waiting for IO operations and on how much you wish to
+# to prioritize throughput over latency.
+#
+# As a rule of thumb, increasing the number of threads will increase how much
+# traffic a given process can handle (throughput), but due to CRuby's
+# Global VM Lock (GVL) it has diminishing returns and will degrade the
+# response time (latency) of the application.
+#
+# The default is set to 3 threads as it's deemed a decent compromise between
+# throughput and latency for the average Rails application.
+#
+# Any libraries that use a connection pool or another resource pool should
+# be configured to provide at least as many connections as the number of
+# threads. This includes Active Record's `pool` parameter in `database.yml`.
+threads_count = ENV.fetch("RAILS_MAX_THREADS", 3)
+threads threads_count, threads_count
 
-# Specifies that the worker count should equal the number of processors in production.
-if ENV["RAILS_ENV"] == "production"
+# Specifies the `environment` that Puma will run in.
+rails_env = ENV.fetch("RAILS_ENV", "development")
+environment rails_env
+
+case rails_env
+when "production"
+  # If you are running more than 1 thread per process, the workers count
+  # should be equal to the number of processors (CPU cores) in production.
+  #
+  # Automatically detect the number of available processors in production.
   require "concurrent-ruby"
-  worker_count = Integer(ENV.fetch("WEB_CONCURRENCY") { Concurrent.physical_processor_count })
-  workers worker_count if worker_count > 1
-end
+  workers_count = Integer(ENV.fetch("WEB_CONCURRENCY") { Concurrent.available_processor_count })
+  workers workers_count if workers_count > 1
 
-# Specifies the `worker_timeout` threshold that Puma will use to wait before
-# terminating a worker in development environments.
-worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development"
+  preload_app!
+when "development"
+  # Specifies a very generous `worker_timeout` so that the worker
+  # isn't killed by Puma when suspended by a debugger.
+  worker_timeout 3600
+end
 
 # Specifies the `port` that Puma will listen on to receive requests; default is 3000.
-port ENV.fetch("PORT") { 3000 }
-
-# Specifies the `environment` that Puma will run in.
-environment ENV.fetch("RAILS_ENV") { "development" }
-
-# Specifies the `pidfile` that Puma will use.
-pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" }
+port ENV.fetch("PORT", 3000)
 
 # Allow puma to be restarted by `bin/rails restart` command.
 plugin :tmp_restart
+
+# Only use a pidfile when requested
+pidfile ENV["PIDFILE"] if ENV["PIDFILE"]

data/lib/rails/generators/rails/app/templates/config/routes.rb.tt

@@ -5,6 +5,10 @@ Rails.application.routes.draw do
   # Can be used by load balancers and uptime monitors to verify that the app is live.
   get "up" => "rails/health#show", as: :rails_health_check
 
+  # Render dynamic PWA files from app/views/pwa/*
+  get "service-worker" => "rails/pwa#service_worker", as: :pwa_service_worker
+  get "manifest" => "rails/pwa#manifest", as: :pwa_manifest
+
   # Defines the root path route ("/")
   # root "posts#index"
 end

data/lib/rails/generators/rails/app/templates/docker-entrypoint.tt

@@ -1,5 +1,10 @@
 #!/bin/bash -e
 
+# Enable jemalloc for reduced memory usage and latency.
+if [ -z "${LD_PRELOAD+x}" ] && [ -f /usr/lib/*/libjemalloc.so.2 ]; then
+  export LD_PRELOAD="$(echo /usr/lib/*/libjemalloc.so.2)"
+fi
+
 <% unless skip_active_record? -%>
 # If running the rails server then create or migrate existing database
 if [ "${1}" == "./bin/rails" ] && [ "${2}" == "server" ]; then

data/lib/rails/generators/rails/app/templates/dockerignore.tt

@@ -2,6 +2,7 @@
 
 # Ignore git directory.
 /.git/
+/.gitignore
 
 # Ignore bundler config.
 /.bundle
@@ -41,3 +42,15 @@
 !/app/assets/builds/.keep
 /public/assets
 <% end -%>
+<% unless options.skip_ci? -%>
+
+# Ignore CI service files.
+/.github
+<% end -%>
+
+# Ignore development files
+/.devcontainer
+
+# Ignore Docker-related files
+/.dockerignore
+/Dockerfile*

data/lib/rails/generators/rails/app/templates/github/ci.yml.tt

@@ -0,0 +1,138 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [ main ]
+
+jobs:
+<%- unless skip_brakeman? -%>
+  scan_ruby:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Scan for security vulnerabilities in Ruby dependencies
+        run: bin/brakeman --no-pager
+
+<% end -%>
+<%- if options[:javascript] == "importmap" -%>
+  scan_js:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Scan for security vulnerabilities in JavaScript dependencies
+        run: bin/importmap audit
+
+<% end -%>
+<%- unless skip_rubocop? -%>
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Lint code for consistent style
+        run: bin/rubocop -f github
+
+<% end -%>
+<% unless options[:skip_test] -%>
+  test:
+    runs-on: ubuntu-latest
+
+    <%- if options[:database] == "sqlite3" -%>
+    # services:
+    #  redis:
+    #    image: redis
+    #    ports:
+    #      - 6379:6379
+    #    options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+    <%- else -%>
+    services:
+      <%- if options[:database] == "mysql" || options[:database] == "trilogy" -%>
+      mysql:
+        image: mysql
+        env:
+          MYSQL_ALLOW_EMPTY_PASSWORD: true
+        ports:
+          - 3306:3306
+        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
+      <%- elsif options[:database] == "postgresql" -%>
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: --health-cmd="pg_isready" --health-interval=10s --health-timeout=5s --health-retries=3
+      <%- end -%>
+
+      # redis:
+      #   image: redis
+      #   ports:
+      #     - 6379:6379
+      #   options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+
+    <%- end -%>
+    steps:
+      - name: Install packages
+        run: sudo apt-get update && sudo apt-get install --no-install-recommends -y google-chrome-stable <%= (dockerfile_base_packages + [database.base_package]).join(" ") %>
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+      <%- if using_bun? -%>
+
+      - uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: <%= dockerfile_bun_version %>
+      <%- end -%>
+
+      - name: Run tests
+        env:
+          RAILS_ENV: test
+          <%- if options[:database] == "mysql" || options[:database] == "trilogy" -%>
+          DATABASE_URL: mysql2://127.0.0.1:3306
+          <%- elsif options[:database] == "postgresql" -%>
+          DATABASE_URL: postgres://postgres:postgres@localhost:5432
+          <%- end -%>
+          # REDIS_URL: redis://localhost:6379/0
+        run: bin/rails db:test:prepare test test:system
+
+      - name: Keep screenshots from failed system tests
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: screenshots
+          path: ${{ github.workspace }}/tmp/screenshots
+          if-no-files-found: ignore
+<% end -%>

data/lib/rails/generators/rails/app/templates/github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

data/lib/rails/generators/rails/app/templates/gitignore.tt

@@ -1,8 +1,8 @@
 # See https://help.github.com/articles/ignoring-files for more about ignoring files.
 #
-# If you find yourself ignoring temporary files generated by your text editor
-# or operating system, you probably want to add a global ignore instead:
-#   git config --global core.excludesfile '~/.gitignore_global'
+# Temporary files generated by your text editor or operating system
+# belong in git's global ignore instead:
+# `$XDG_CONFIG_HOME/git/ignore` or `~/.config/git/ignore`
 
 # Ignore bundler config.
 /.bundle

data/lib/rails/generators/rails/app/templates/public/406-unsupported-browser.html

@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Your browser is not supported (406)</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+  .rails-default-error-page {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+    margin: 0;
+  }
+
+  .rails-default-error-page div.dialog {
+    width: 95%;
+    max-width: 33em;
+    margin: 4em auto 0;
+  }
+
+  .rails-default-error-page div.dialog > div {
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 12% 0;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+
+  .rails-default-error-page h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+
+  .rails-default-error-page div.dialog > p {
+    margin: 0 0 1em;
+    padding: 1em;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+
+<body class="rails-default-error-page">
+  <!-- This file lives in public/406-unsupported-browser.html -->
+  <div class="dialog">
+    <div>
+      <h1>Your browser is not supported.</h1>
+      <p>Please upgrade your browser to continue.</p>
+    </div>
+  </div>
+</body>
+</html>

data/lib/rails/generators/rails/app/templates/public/icon.svg

@@ -0,0 +1,3 @@
+<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100%" height="100%" fill="red"/>
+</svg>

data/lib/rails/generators/rails/app/templates/rubocop.yml.tt

@@ -0,0 +1,8 @@
+# Omakase Ruby styling for Rails
+inherit_gem: { rubocop-rails-omakase: rubocop.yml }
+
+# Overwrite or add rules to create your own house style
+#
+# # Use `[a, [b, c]]` not `[ a, [ b, c ] ]`
+# Layout/SpaceInsideArrayLiteralBrackets:
+#   Enabled: false

data/lib/rails/generators/rails/app/templates/test/application_system_test_case.rb.tt

@@ -1,5 +1,5 @@
 require "test_helper"
 
 class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
-  driven_by :selenium, using: :chrome, screen_size: [1400, 1400]
+  driven_by :selenium, using: :headless_chrome, screen_size: [ 1400, 1400 ]
 end

data/lib/rails/generators/rails/controller/controller_generator.rb

@@ -17,7 +17,7 @@ module Rails
       def add_routes
         return if options[:skip_routes]
         return if actions.empty?
-        routing_code = actions.map { |action| "get '#{file_name}/#{action}'" }.join("\n")
+        routing_code = actions.map { |action| %(get "#{file_name}/#{action}") }.join("\n")
         route routing_code, namespace: regular_class_path
       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,7 +39,7 @@ 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
@@ -44,27 +48,44 @@ module Rails
             dockerfile_path = File.expand_path("Dockerfile", destination_root)
             return unless File.exist?(dockerfile_path)
 
-            build_name = docker_for_database_build
-            deploy_name = docker_for_database_deploy
-            if build_name
-              gsub_file("Dockerfile", all_docker_builds_regex, build_name)
-            end
-            if deploy_name
-              gsub_file("Dockerfile", all_docker_deploys_regex, deploy_name)
-            end
+            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
-              DATABASES.map { |database| docker_for_database_build(database).nil? ? nil : docker_for_database_build(database) }.compact!
+              Database.all.map { |database| docker_build_packages(database.build_package) }.uniq
             end
 
-            def all_docker_deploys
-              DATABASES.map { |database| docker_for_database_deploy(database).nil? ? nil : docker_for_database_deploy(database) }.compact!
+            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
@@ -72,12 +93,12 @@ module Rails
               /(\b#{all_database_gem_names.join('\b|\b')}\b)/
             end
 
-            def all_docker_builds_regex
-              /(\b#{all_docker_builds.join('\b|\b')}\b)/
+            def all_docker_bases_regex
+              /(\b#{all_docker_bases.join('\b|\b')}\b)/
             end
 
-            def all_docker_deploys_regex
-              /(\b#{all_docker_deploys.join('\b|\b')}\b)/
+            def all_docker_builds_regex
+              /(\b#{all_docker_builds.join('\b|\b')}\b)/
             end
 
             def gem_entry_regex_for(gem_name)
@@ -88,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