Class: Rails::Generators::AppBase

# File 'railties/lib/rails/generators/app_base.rb', line 116

def self.edge_branch # :nodoc:
  Rails.gem_version.prerelease? ? "main" : [*Rails.gem_version.segments.first(2), "stable"].join("-")
end

# File 'railties/lib/rails/generators/app_base.rb', line 26

def self.strict_args_position
  false
end

# File 'railties/lib/rails/generators/app_base.rb', line 649

def depend_on_bootsnap?
  !options[:skip_bootsnap] && !options[:dev] && !defined?(JRUBY_VERSION)
end

# File 'railties/lib/rails/generators/app_base.rb', line 645

def depends_on_system_test?
  !(options[:skip_system_test] || options[:skip_test] || options[:api])
end

# File 'railties/lib/rails/generators/app_base.rb', line 299

def include_all_railties? # :doc:
  required_railties.values.all?
end

# File 'railties/lib/rails/generators/app_base.rb', line 332

def keeps? # :doc:
  !options[:skip_keeps]
end

# File 'railties/lib/rails/generators/app_base.rb', line 417

def rails_prerelease?
  options.dev? || options.edge? || options.main?
end

# File 'railties/lib/rails/generators/app_base.rb', line 21

attr_accessor :rails_template

# File 'railties/lib/rails/generators/app_base.rb', line 348

def skip_action_cable? # :doc:
  options[:skip_action_cable]
end

# File 'railties/lib/rails/generators/app_base.rb', line 356

def skip_action_mailbox? # :doc:
  options[:skip_action_mailbox]
end

# File 'railties/lib/rails/generators/app_base.rb', line 352

def skip_action_mailer? # :doc:
  options[:skip_action_mailer]
end

# File 'railties/lib/rails/generators/app_base.rb', line 360

def skip_action_text? # :doc:
  options[:skip_action_text]
end

# File 'railties/lib/rails/generators/app_base.rb', line 340

def skip_active_record? # :doc:
  options[:skip_active_record]
end

# File 'railties/lib/rails/generators/app_base.rb', line 344

def skip_active_storage? # :doc:
  options[:skip_active_storage]
end

# File 'railties/lib/rails/generators/app_base.rb', line 364

def skip_asset_pipeline? # :doc:
  options[:skip_asset_pipeline]
end

# File 'railties/lib/rails/generators/app_base.rb', line 372

def skip_propshaft?
  skip_asset_pipeline? || options[:asset_pipeline] != "propshaft"
end

# File 'railties/lib/rails/generators/app_base.rb', line 368

def skip_sprockets?
  skip_asset_pipeline? || options[:asset_pipeline] != "sprockets"
end

# File 'railties/lib/rails/generators/app_base.rb', line 336

def sqlite3? # :doc:
  !skip_active_record? && options[:database] == "sqlite3"
end

# File 'railties/lib/rails/generators/app_base.rb', line 483

def using_bun?
  using_js_runtime? && %w[bun].include?(options[:javascript])
end

# File 'railties/lib/rails/generators/app_base.rb', line 474

def using_js_runtime?
  (options[:javascript] && !%w[importmap].include?(options[:javascript])) ||
    (options[:css] && !%w[tailwind sass].include?(options[:css]))
end

# File 'railties/lib/rails/generators/app_base.rb', line 479

def using_node?
  using_js_runtime? && !%w[bun].include?(options[:javascript])
end

# File 'railties/lib/rails/generators/app_base.rb', line 243

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

# File 'railties/lib/rails/generators/app_base.rb', line 272

def asset_pipeline_gemfile_entry
  return if skip_asset_pipeline?

  if options[:asset_pipeline] == "sprockets"
    GemfileEntry.floats "sprockets-rails",
      "The original asset pipeline for Rails [https://github.com/rails/sprockets-rails]"
  elsif options[:asset_pipeline] == "propshaft"
    GemfileEntry.floats "propshaft", "The modern asset pipeline for Rails [https://github.com/rails/propshaft]"
  end
end

# File 'railties/lib/rails/generators/app_base.rb', line 149

def build(meth, *args) # :doc:
  builder.public_send(meth, *args) if builder.respond_to?(meth)
end

# File 'railties/lib/rails/generators/app_base.rb', line 141

def builder # :doc:
  @builder ||= begin
    builder_class = get_builder_class
    builder_class.include(ActionMethods)
    builder_class.new(self)
  end
end

# File 'railties/lib/rails/generators/app_base.rb', line 611

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

# File 'railties/lib/rails/generators/app_base.rb', line 641

def bundler_windows_platforms
  Gem.rubygems_version >= Gem::Version.new("3.3.22") ? "windows" : "mswin mswin64 mingw x64_mingw"
end

# File 'railties/lib/rails/generators/app_base.rb', line 604

def cable_gemfile_entry
  return if options[:skip_action_cable]

  comment = "Use Redis adapter to run Action Cable in production"
  GemfileEntry.new("redis", ">= 4.0.1", comment, {}, true)
end

# File 'railties/lib/rails/generators/app_base.rb', line 319

def comment_if(value) # :doc:
  question = "#{value}?"

  comment =
    if respond_to?(question, true)
      send(question)
    else
      options[value]
    end

  comment ? "# " : ""
end

# File 'railties/lib/rails/generators/app_base.rb', line 236

def create_root # :doc:
  valid_const?

  empty_directory "."
  FileUtils.cd(destination_root) unless options[:pretend]
end

# File 'railties/lib/rails/generators/app_base.rb', line 592

def css_gemfile_entry
  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

# File 'railties/lib/rails/generators/app_base.rb', line 260

def database_gemfile_entry # :doc:
  return if options[:skip_active_record]

  gem_name, gem_version = gem_for_database
  GemfileEntry.version gem_name, gem_version,
    "Use #{options[:database]} as the database for Active Record"
end

# File 'railties/lib/rails/generators/app_base.rb', line 153

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

# File 'railties/lib/rails/generators/app_base.rb', line 509

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

# File 'railties/lib/rails/generators/app_base.rb', line 538

def dockerfile_build_packages
  # start with the essentials
  packages = %w(build-essential git pkg-config)

  # add database support
  packages << build_package_for_database unless skip_active_record?

  # ActiveStorage preview support
  packages << "libvips" unless skip_active_storage?

  packages << "curl" if using_js_runtime?

  packages << "unzip" if using_bun?

  # node support, including support for building native modules
  if using_node?
    packages << "node-gyp" # pkg-config already listed above

    # module build process depends on Python, and debian changed
    # how python is installed with the bullseye release.  Below
    # is based on debian release included with the Ruby images on
    # Dockerhub.
    case Gem.ruby_version.to_s
    when /^2\.7/
      bullseye = Gem.ruby_version >= Gem::Version.new("2.7.4")
    when /^3\.0/
      bullseye = Gem.ruby_version >= Gem::Version.new("3.0.2")
    else
      bullseye = true
    end

    if bullseye
      packages << "python-is-python3"
    else
      packages << "python"
    end
  end

  packages.compact.sort
end

# File 'railties/lib/rails/generators/app_base.rb', line 503

def dockerfile_bun_version
  using_bun? and `bun --version`[/\d\.\d\.\d+/]
rescue
  BUN_VERSION
end

# File 'railties/lib/rails/generators/app_base.rb', line 752

def dockerfile_chown_directories
  directories = %w(log tmp)

  directories << "storage" unless skip_active_storage? && !sqlite3?
  directories << "db" unless skip_active_record?

  directories.sort
end

# File 'railties/lib/rails/generators/app_base.rb', line 579

def dockerfile_deploy_packages
  # Add curl to work with the default healthcheck strategy in Kamal
  packages = ["curl"]

  # ActiveRecord databases
  packages << deploy_package_for_database unless skip_active_record?

  # ActiveStorage preview support
  packages << "libvips" unless skip_active_storage?

  packages.compact.sort
end

# File 'railties/lib/rails/generators/app_base.rb', line 497

def dockerfile_yarn_version
  using_node? and `yarn --version`[/\d\.\d\.\d+/]
rescue
  "latest"
end

# File 'railties/lib/rails/generators/app_base.rb', line 748

def edge_branch
  self.class.edge_branch
end

# File 'railties/lib/rails/generators/app_base.rb', line 723

def empty_directory_with_keep_file(destination, config = {})
  empty_directory(destination, config)
  keep_file(destination)
end

# File 'railties/lib/rails/generators/app_base.rb', line 628

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

# File 'railties/lib/rails/generators/app_base.rb', line 413

def gem_ruby_version
  Gem::Version.new(Gem::VERSION) >= Gem::Version.new("3.3.13") ? Gem.ruby_version : RUBY_VERSION
end

# File 'railties/lib/rails/generators/app_base.rb', line 127

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

# File 'railties/lib/rails/generators/app_base.rb', line 717

def generate_bundler_binstub
  if bundle_install?
    bundle_command("binstubs bundler")
  end
end

# File 'railties/lib/rails/generators/app_base.rb', line 736

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

# File 'railties/lib/rails/generators/app_base.rb', line 462

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

# File 'railties/lib/rails/generators/app_base.rb', line 206

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

# File 'railties/lib/rails/generators/app_base.rb', line 452

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

# File 'railties/lib/rails/generators/app_base.rb', line 447

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

# File 'railties/lib/rails/generators/app_base.rb', line 728

def keep_file(destination)
  create_file("#{destination}/.keep") if keeps?
end

# File 'railties/lib/rails/generators/app_base.rb', line 487

def node_version
  if using_node?
    ENV.fetch("NODE_VERSION") do
      `node --version`[/\d\.\d\.\d+/]
    rescue
      NODE_LTS_VERSION
    end
  end
end

# File 'railties/lib/rails/generators/app_base.rb', line 421

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

# File 'railties/lib/rails/generators/app_base.rb', line 303

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

# File 'railties/lib/rails/generators/app_base.rb', line 434

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

# File 'railties/lib/rails/generators/app_base.rb', line 219

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

# File 'railties/lib/rails/generators/app_base.rb', line 283

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

# File 'railties/lib/rails/generators/app_base.rb', line 676

def run_bundle
  bundle_command("install", "BUNDLE_IGNORE_MESSAGES" => "1") if bundle_install?
end

# File 'railties/lib/rails/generators/app_base.rb', line 695

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

# File 'railties/lib/rails/generators/app_base.rb', line 689

def run_hotwire
  return if options[:skip_hotwire] || !bundle_install?

  rails_command "turbo:install stimulus:install"
end

# File 'railties/lib/rails/generators/app_base.rb', line 680

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

# File 'railties/lib/rails/generators/app_base.rb', line 249

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

# File 'railties/lib/rails/generators/app_base.rb', line 653

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"
      git_source(:github) { |repo| "https://github.com/\#{repo}.git" }
      #{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

# File 'railties/lib/rails/generators/app_base.rb', line 732

def user_default_branch
  @user_default_branch ||= `git config init.defaultbranch`
end

# File 'railties/lib/rails/generators/app_base.rb', line 268

def web_server_gemfile_entry # :doc:
  GemfileEntry.new "puma", ">= 5.0", "Use the Puma web server [https://github.com/puma/puma]"
end