# frozen_string_literal: true
require "fileutils"
require "digest/md5"
require "rails/version" unless defined?(Rails::VERSION)
require "open-uri"
require "tsort"
require "uri"
require "rails/generators"
require "active_support/core_ext/array/extract_options"
module Rails
module Generators
class AppBase < Base # :nodoc:
include AppName
NODE_LTS_VERSION = "20.11.1"
BUN_VERSION = "1.0.1"
JAVASCRIPT_OPTIONS = %w( importmap bun webpack esbuild rollup )
CSS_OPTIONS = %w( tailwind bootstrap bulma postcss sass )
attr_accessor :rails_template
add_shebang_option!
argument :app_path, type: :string
def self.strict_args_position
false
end
def self.add_shared_options_for(name)
class_option :name, type: :string, aliases: "-n",
desc: "Name of the app"
class_option :template, type: :string, aliases: "-m",
desc: "Path to some #{name} template (can be a filesystem path or URL)"
class_option :database, type: :string, aliases: "-d", default: "sqlite3",
enum: Database::DATABASES,
desc: "Preconfigure for selected database"
class_option :skip_git, type: :boolean, aliases: "-G", default: nil,
desc: "Skip git init, .gitignore and .gitattributes"
class_option :skip_docker, type: :boolean, default: nil,
desc: "Skip Dockerfile, .dockerignore and bin/docker-entrypoint"
class_option :skip_keeps, type: :boolean, default: nil,
desc: "Skip source control .keep files"
class_option :skip_action_mailer, type: :boolean, aliases: "-M",
default: nil,
desc: "Skip Action Mailer files"
class_option :skip_action_mailbox, type: :boolean, default: nil,
desc: "Skip Action Mailbox gem"
class_option :skip_action_text, type: :boolean, default: nil,
desc: "Skip Action Text gem"
class_option :skip_active_record, type: :boolean, aliases: "-O", default: nil,
desc: "Skip Active Record files"
class_option :skip_active_job, type: :boolean, default: nil,
desc: "Skip Active Job"
class_option :skip_active_storage, type: :boolean, default: nil,
desc: "Skip Active Storage files"
class_option :skip_action_cable, type: :boolean, aliases: "-C", default: nil,
desc: "Skip Action Cable files"
class_option :skip_asset_pipeline, type: :boolean, aliases: "-A", default: nil
class_option :skip_javascript, type: :boolean, aliases: ["-J", "--skip-js"], default: (true if name == "plugin"),
desc: "Skip JavaScript files"
class_option :skip_hotwire, type: :boolean, default: nil,
desc: "Skip Hotwire integration"
class_option :skip_jbuilder, type: :boolean, default: nil,
desc: "Skip jbuilder gem"
class_option :skip_test, type: :boolean, aliases: "-T", default: nil,
desc: "Skip test files"
class_option :skip_system_test, type: :boolean, default: nil,
desc: "Skip system test files"
class_option :skip_bootsnap, type: :boolean, default: nil,
desc: "Skip bootsnap gem"
class_option :skip_dev_gems, type: :boolean, default: nil,
desc: "Skip development gems (e.g., web-console)"
class_option :skip_thruster, type: :boolean, default: nil,
desc: "Skip Thruster setup"
class_option :skip_rubocop, type: :boolean, default: nil,
desc: "Skip RuboCop setup"
class_option :skip_brakeman, type: :boolean, default: nil,
desc: "Skip brakeman setup"
class_option :skip_ci, type: :boolean, default: nil,
desc: "Skip GitHub CI files"
class_option :skip_kamal, type: :boolean, default: nil,
desc: "Skip Kamal setup"
class_option :skip_solid, type: :boolean, default: nil,
desc: "Skip Solid Cache, Queue, and Cable setup"
class_option :dev, type: :boolean, default: nil,
desc: "Set up the #{name} with Gemfile pointing to your Rails checkout"
class_option :devcontainer, type: :boolean, default: nil,
desc: "Generate devcontainer files"
class_option :edge, type: :boolean, default: nil,
desc: "Set up the #{name} with a Gemfile pointing to the #{edge_branch} branch on the Rails repository"
class_option :main, type: :boolean, default: nil, aliases: "--master",
desc: "Set up the #{name} with Gemfile pointing to Rails repository main branch"
class_option :rc, type: :string, default: nil,
desc: "Path to file containing extra configuration options for rails command"
class_option :no_rc, type: :boolean, default: nil,
desc: "Skip loading of extra configuration options from .railsrc file"
class_option :help, type: :boolean, aliases: "-h", group: :rails,
desc: "Show this help message and quit"
end
def self.edge_branch # :nodoc:
Rails.gem_version.prerelease? ? "main" : [*Rails.gem_version.segments.first(2), "stable"].join("-")
end
def initialize(positional_argv, option_argv, *)
@argv = [*positional_argv, *option_argv]
@gem_filter = lambda { |gem| true }
super
end
private
def gemfile_entries # :doc:
[
rails_gemfile_entry,
asset_pipeline_gemfile_entry,
database_gemfile_entry,
web_server_gemfile_entry,
javascript_gemfile_entry,
hotwire_gemfile_entry,
css_gemfile_entry,
jbuilder_gemfile_entry,
cable_gemfile_entry,
].flatten.compact.select(&@gem_filter)
end
def builder # :doc:
@builder ||= begin
builder_class = get_builder_class
builder_class.include(ActionMethods)
builder_class.new(self)
end
end
def build(meth, *args) # :doc:
builder.public_send(meth, *args) if builder.respond_to?(meth)
end
def deduce_implied_options(options, option_reasons, meta_options)
active = options.transform_values { |value| [] if value }.compact
irrevocable = (active.keys - meta_options).to_set
deduction_order = TSort.tsort(
->(&block) { option_reasons.each_key(&block) },
->(key, &block) { option_reasons[key]&.each(&block) }
)
deduction_order.each do |name|
active_reasons = option_reasons[name].to_a.select(&active)
active[name] ||= active_reasons if active_reasons.any?
irrevocable << name if active_reasons.any?(irrevocable)
end
revoked = options.select { |name, value| value == false }.keys.to_set - irrevocable
deduction_order.reverse_each do |name|
revoked += option_reasons[name].to_a if revoked.include?(name)
end
revoked -= meta_options
active.filter_map do |name, reasons|
unless revoked.include?(name) || reasons.all?(revoked)
[name, reasons - revoked.to_a]
end
end.to_h
end
OPTION_IMPLICATIONS = { # :nodoc:
skip_active_job: [:skip_action_mailer, :skip_active_storage],
skip_active_record: [:skip_active_storage, :skip_solid],
skip_active_storage: [:skip_action_mailbox, :skip_action_text],
skip_javascript: [:skip_hotwire],
}
# ==== Options
#
# [+:meta_options+]
# A list of generator options which only serve to trigger other options.
# These options should have no other effects, and will be treated
# transparently when revoking other options.
#
# For example: --minimal implies both --skip-active-job and
# --skip-active-storage. Also, --skip-active-job by itself implies
# --skip-active-storage. If --skip-active-job is explicitly
# specified, --no-skip-active-storage should raise an error. But, if
# only --minimal is specified, --no-skip-active-storage should "undo"
# the implied --skip-active-job. This can be accomplished by passing
# <tt>meta_options: [:minimal]</tt>.
#
# In contrast, --api is not a meta option because it does other things
# besides implying options such as --skip-asset-pipeline. (And so --api
# with --no-skip-asset-pipeline should raise an error.)
def imply_options(option_implications = OPTION_IMPLICATIONS, meta_options: [])
option_reasons = {}
option_implications.each do |reason, implications|
implications.each do |implication|
(option_reasons[implication.to_s] ||= []) << reason.to_s
end
end
@implied_options = deduce_implied_options(options, option_reasons, meta_options.map(&:to_s))
@implied_options_conflicts = @implied_options.keys.select { |name| options[name] == false }
self.options = options.merge(@implied_options.transform_values { true }).freeze
end
def report_implied_options
return if @implied_options.blank?
say "Based on the specified options, the following options will also be activated:"
say ""
@implied_options.each do |name, reasons|
due_to = reasons.map { |reason| "--#{reason.dasherize}" }.join(", ")
say " --#{name.dasherize} [due to #{due_to}]"
if @implied_options_conflicts.include?(name)
say " ERROR: Conflicts with --no-#{name.dasherize}", :red
end
end
say ""
raise "Cannot proceed due to conflicting options" if @implied_options_conflicts.any?
end
def create_root # :doc:
valid_const?
empty_directory "."
FileUtils.cd(destination_root) unless options[:pretend]
end
def apply_rails_template # :doc:
apply rails_template if rails_template
rescue Thor::Error, LoadError, Errno::ENOENT => e
raise Error, "The template [#{rails_template}] could not be loaded. Error: #{e}"
end
def set_default_accessors! # :doc:
self.destination_root = File.expand_path(app_path, destination_root)
if options[:template].is_a?(String) && !options[:template].match?(/^https?:\/\//)
interpolated = options[:template].gsub(/\$(\w+)|\$\{\g<1>\}|%\g<1>%/) { |m| ENV[$1] || m }
self.rails_template = File.expand_path(interpolated)
else
self.rails_template = options[:template]
end
end
def database_gemfile_entry # :doc:
return if options[:skip_active_record]
gem_name, gem_version = database.gem
GemfileEntry.version gem_name, gem_version,
"Use #{options[:database]} as the database for Active Record"
end
def web_server_gemfile_entry # :doc:
GemfileEntry.new "puma", ">= 5.0", "Use the Puma web server [https://github.com/puma/puma]"
end
def asset_pipeline_gemfile_entry
unless skip_asset_pipeline?
GemfileEntry.floats "propshaft", "The modern asset pipeline for Rails [https://github.com/rails/propshaft]"
end
end
def required_railties
@required_railties ||= {
"active_model/railtie" => true,
"active_job/railtie" => !options[:skip_active_job],
"active_record/railtie" => !options[:skip_active_record],
"active_storage/engine" => !options[:skip_active_storage],
"action_controller/railtie" => true,
"action_mailer/railtie" => !options[:skip_action_mailer],
"action_mailbox/engine" => !options[:skip_action_mailbox],
"action_text/engine" => !options[:skip_action_text],
"action_view/railtie" => true,
"action_cable/engine" => !options[:skip_action_cable],
"rails/test_unit/railtie" => !options[:skip_test],
}
end
def include_all_railties? # :doc:
required_railties.values.all?
end
def rails_require_statement
if include_all_railties?
%(require "rails/all")
else
require_statements = required_railties.map do |railtie, required|
%(#{"# " if !required}require "#{railtie}")
end
<<~RUBY.strip
require "rails"
# Pick the frameworks you want:
#{require_statements.join("\n")}
RUBY
end
end
def comment_if(value) # :doc:
question = "#{value}?"
comment =
if respond_to?(question, true)
send(question)
else
options[value]
end
comment ? "# " : ""
end
def keeps? # :doc:
!options[:skip_keeps]
end
def sqlite3? # :doc:
!skip_active_record? && options[:database] == "sqlite3"
end
def skip_active_record? # :doc:
options[:skip_active_record]
end
def skip_active_storage? # :doc:
options[:skip_active_storage]
end
def skip_storage? # :doc:
skip_active_storage? && !sqlite3?
end
def skip_action_cable? # :doc:
options[:skip_action_cable]
end
def skip_action_mailer? # :doc:
options[:skip_action_mailer]
end
def skip_action_mailbox? # :doc:
options[:skip_action_mailbox]
end
def skip_action_text? # :doc:
options[:skip_action_text]
end
def skip_asset_pipeline? # :doc:
options[:skip_asset_pipeline]
end
def skip_thruster?
options[:skip_thruster]
end
def skip_rubocop?
options[:skip_rubocop]
end
def skip_brakeman?
options[:skip_brakeman]
end
def skip_ci?
options[:skip_ci]
end
def skip_devcontainer?
!options[:devcontainer]
end
def devcontainer?
options[:devcontainer]
end
def skip_kamal?
options[:skip_kamal]
end
def skip_solid?
options[:skip_solid]
end
class GemfileEntry < Struct.new(:name, :version, :comment, :options, :commented_out)
def initialize(name, version, comment, options = {}, commented_out = false)
super
end
def self.github(name, github, branch = nil, comment = nil)
if branch
new(name, nil, comment, github: github, branch: branch)
else
new(name, nil, comment, github: github)
end
end
def self.version(name, version, comment = nil)
new(name, version, comment)
end
def self.floats(name, comment = nil)
new(name, nil, comment)
end
def self.path(name, path, comment = nil)
new(name, nil, comment, path: path)
end
def to_s
[
(comment.gsub(/^/, "# ").chomp + "\n" if comment),
("# " if commented_out),
"gem \"#{name}\"",
*Array(version).map { |constraint| ", \"#{constraint}\"" },
*options.map { |key, value| ", #{key}: #{value.inspect}" },
].compact.join
end
end
def rails_prerelease?
options.dev? || options.edge? || options.main?
end
def rails_gemfile_entry
if options.dev?
GemfileEntry.path("rails", Rails::Generators::RAILS_DEV_PATH, "Use local checkout of Rails")
elsif options.edge?
GemfileEntry.github("rails", "rails/rails", edge_branch, "Use specific branch of Rails")
elsif options.main?
GemfileEntry.github("rails", "rails/rails", "main", "Use main development branch of Rails")
else
GemfileEntry.version("rails", rails_version_specifier,
%(Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"))
end
end
def rails_version_specifier(gem_version = Rails.gem_version)
if gem_version.segments.size == 3 || gem_version.release.segments.size == 3
# ~> 1.2.3
# ~> 1.2.3.pre4
"~> #{gem_version}"
else
# ~> 1.2.3, >= 1.2.3.4
# ~> 1.2.3, >= 1.2.3.4.pre5
patch = gem_version.segments[0, 3].join(".")
["~> #{patch}", ">= #{gem_version}"]
end
end
def jbuilder_gemfile_entry
return if options[:skip_jbuilder]
GemfileEntry.new "jbuilder", nil, "Build JSON APIs with ease [https://github.com/rails/jbuilder]", {}, options[:api]
end
def javascript_gemfile_entry
return if options[:skip_javascript]
if options[:javascript] == "importmap"
GemfileEntry.floats "importmap-rails", "Use JavaScript with ESM import maps [https://github.com/rails/importmap-rails]"
else
GemfileEntry.floats "jsbundling-rails", "Bundle and transpile JavaScript [https://github.com/rails/jsbundling-rails]"
end
end
def hotwire_gemfile_entry
return if options[:skip_hotwire]
turbo_rails_entry =
GemfileEntry.floats "turbo-rails", "Hotwire's SPA-like page accelerator [https://turbo.hotwired.dev]"
stimulus_rails_entry =
GemfileEntry.floats "stimulus-rails", "Hotwire's modest JavaScript framework [https://stimulus.hotwired.dev]"
[ turbo_rails_entry, stimulus_rails_entry ]
end
def using_js_runtime?
(options[:javascript] && !%w[importmap].include?(options[:javascript])) ||
(options[:css] && !%w[tailwind sass].include?(options[:css]))
end
def using_node?
using_js_runtime? && !%w[bun].include?(options[:javascript])
end
def using_bun?
using_js_runtime? && %w[bun].include?(options[:javascript])
end
def node_version
if using_node?
ENV.fetch("NODE_VERSION") do
`node --version`[/\d+\.\d+\.\d+/]
rescue
NODE_LTS_VERSION
end
end
end
def dockerfile_yarn_version
using_node? and `yarn --version`[/\d+\.\d+\.\d+/]
rescue
"latest"
end
def dockerfile_bun_version
using_bun? and `bun --version`[/\d+\.\d+\.\d+/]
rescue
BUN_VERSION
end
def dockerfile_binfile_fixups
# binfiles may have OS specific paths to ruby. Normalize them.
shebangs = Dir["bin/*"].map { |file| IO.read(file).lines.first }.join
rubies = shebangs.scan(%r{#!/usr/bin/env (ruby.*)}).flatten.uniq
binfixups = (rubies - %w(ruby)).map do |ruby|
"sed -i 's/#{Regexp.quote(ruby)}$/ruby/' bin/*"
end
# Windows line endings will cause scripts to fail. If any
# or found OR this generation is run on a windows platform
# and there are other binfixups required, then convert
# line endings. This avoids adding unnecessary fixups if
# none are required, but prepares for the need to do the
# fix line endings if other fixups are required.
has_cr = Dir["bin/*"].any? { |file| IO.read(file).include? "\r" }
if has_cr || (Gem.win_platform? && !binfixups.empty?)
binfixups.unshift 'sed -i "s/\r$//g" bin/*'
end
# Windows file systems may not have the concept of executable.
# In such cases, fix up during the build.
unless Dir["bin/*"].all? { |file| File.executable? file }
binfixups.unshift "chmod +x bin/*"
end
binfixups
end
def dockerfile_base_packages
# Add curl to work with the default health check strategy in Kamal
packages = ["curl"]
# ActiveRecord databases
packages << database.base_package unless skip_active_record?
# ActiveStorage preview support
packages << "libvips" unless skip_active_storage?
# jemalloc for memory optimization
packages << "libjemalloc2"
packages.compact.sort
end
def dockerfile_build_packages
# start with the essentials
packages = %w(build-essential git pkg-config)
# add database support
packages << database.build_package unless skip_active_record?
packages << "unzip" if using_bun?
# node support, including support for building native modules
if using_node?
packages << "node-gyp" # pkg-config already listed above
packages << "python-is-python3"
end
packages.compact.sort
end
def css_gemfile_entry
return if options[:api]
return unless options[:css]
if !using_js_runtime? && options[:css] == "tailwind"
GemfileEntry.floats "tailwindcss-rails", "Use Tailwind CSS [https://github.com/rails/tailwindcss-rails]"
elsif !using_js_runtime? && options[:css] == "sass"
GemfileEntry.floats "dartsass-rails", "Use Dart SASS [https://github.com/rails/dartsass-rails]"
else
GemfileEntry.floats "cssbundling-rails", "Bundle and process CSS [https://github.com/rails/cssbundling-rails]"
end
end
def cable_gemfile_entry
if !options[:skip_action_cable] && options[:skip_solid]
comment = "Use Redis adapter to run Action Cable in production"
GemfileEntry.new("redis", ">= 4.0.1", comment, {}, true)
end
end
def bundle_command(command, env = {})
say_status :run, "bundle #{command}"
# We are going to shell out rather than invoking Bundler::CLI.new(command)
# because `rails new` loads the Thor gem and on the other hand bundler uses
# its own vendored Thor, which could be a different version. Running both
# things in the same process is a recipe for a night with paracetamol.
#
# Thanks to James Tucker for the Gem tricks involved in this call.
_bundle_command = Gem.bin_path("bundler", "bundle")
require "bundler"
Bundler.with_original_env do
exec_bundle_command(_bundle_command, command, env)
end
end
def exec_bundle_command(bundle_command, command, env)
full_command = %Q["#{Gem.ruby}" "#{bundle_command}" #{command}]
if options[:quiet]
system(env, full_command, out: File::NULL)
else
system(env, full_command)
end
end
def bundle_install?
!(options[:skip_bundle] || options[:pretend])
end
def depends_on_system_test?
!(options[:skip_system_test] || options[:skip_test] || options[:api])
end
def depend_on_bootsnap?
!options[:skip_bootsnap] && !options[:dev] && !defined?(JRUBY_VERSION)
end
def target_rails_prerelease(self_command = "new")
return unless rails_prerelease? && bundle_install?
if !File.exist?(File.expand_path("Gemfile", destination_root))
create_file("Gemfile", <<~GEMFILE)
source "https://rubygems.org"
#{rails_gemfile_entry}
GEMFILE
run_bundle
@argv.delete_at(@argv.index(app_path))
@argv.unshift(destination_root)
require "shellwords"
bundle_command("exec rails #{self_command} #{Shellwords.join(@argv)}")
exit
else
remove_file("Gemfile")
remove_file("Gemfile.lock")
end
end
def run_bundle
bundle_command("install --quiet", "BUNDLE_IGNORE_MESSAGES" => "1") if bundle_install?
end
def run_javascript
return if options[:skip_javascript] || !bundle_install?
case options[:javascript]
when "importmap" then rails_command "importmap:install"
when "webpack", "bun", "esbuild", "rollup" then rails_command "javascript:install:#{options[:javascript]}"
end
end
def run_hotwire
return if options[:skip_hotwire] || !bundle_install?
rails_command "turbo:install stimulus:install"
end
def run_css
return if !options[:css] || !bundle_install?
if !using_js_runtime? && options[:css] == "tailwind"
rails_command "tailwindcss:install"
elsif !using_js_runtime? && options[:css] == "sass"
rails_command "dartsass:install"
else
rails_command "css:install:#{options[:css]}"
end
end
def run_kamal
return if options[:skip_kamal] || !bundle_install?
bundle_command "binstubs kamal"
bundle_command "exec kamal init"
template "kamal-secrets.tt", ".kamal/secrets", force: true
template "config/deploy.yml", force: true
end
def run_solid
return if skip_solid? || !bundle_install?
commands = "solid_cache:install solid_queue:install"
commands += " solid_cable:install" unless skip_action_cable?
rails_command commands
end
def add_bundler_platforms
if bundle_install?
# The vast majority of Rails apps will be deployed on `x86_64-linux`.
bundle_command("lock --add-platform=x86_64-linux")
# Users that develop on M1 mac may use docker and would need `aarch64-linux` as well.
bundle_command("lock --add-platform=aarch64-linux") if RUBY_PLATFORM.start_with?("arm64")
end
end
def generate_bundler_binstub
if bundle_install?
bundle_command("binstubs bundler")
end
end
def empty_directory_with_keep_file(destination, config = {})
empty_directory(destination, config)
keep_file(destination)
end
def keep_file(destination)
create_file("#{destination}/.keep") if keeps?
end
def user_default_branch
@user_default_branch ||= `git config init.defaultbranch`
end
def git_init_command
return "git init" if user_default_branch.strip.present?
git_version = `git --version`[/\d+\.\d+\.\d+/]
if Gem::Version.new(git_version) >= Gem::Version.new("2.28.0")
"git init -b main"
else
"git init && git symbolic-ref HEAD refs/heads/main"
end
end
def edge_branch
self.class.edge_branch
end
def dockerfile_chown_directories
directories = %w(log tmp)
directories << "storage" unless skip_storage?
directories << "db" unless skip_active_record?
directories.sort
end
def database
@database ||= Database.build(options[:database])
end
end
end
end