opinionated_rails 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f673ffcd0b2ce9c01e2528eaaff216a26160aec73b40fa535c1eac444914cf7a
+  data.tar.gz: 45bab309fd8f83547bc56f930203c035ef9969b9bdc2eebcc05ff661004fb4a2
+SHA512:
+  metadata.gz: 94af0313d580ce866f84628f371832cfb46c1d2fe0e9a14b20ebadac61e7b006e9f1e663cfa32b6c7c39381bcfe0a60fd5fe521d80663887dd6638b6fa363c62
+  data.tar.gz: c4cfd132d350b83bda4ff6d5ad24f0cb1f9d4a2ad098d70267e992e61060dc363e1bd67618dc33868f887ef686a0136ee1423b09213200a532942088ec4183f5

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## 0.1.4 (2026-10-10)
+
+The first published release. Versions 0.1.0 to 0.1.3 were tagged but never published: 0.1.0 and 0.1.1 were missing the MySQL and bun fixes below, the release of 0.1.2 was refused because its tag did not match the gem version, and the release of 0.1.3 failed because the publish job did not install Ruby.
+
+- `opinionated_rails new [APP_NAME]` generates a Rails 8 app by running `rails new` and layering independent steps on top: database, app type, test framework, frontend (Stimulus or React with esbuild, bun or webpack), RuboCop, background jobs/cache/cable (Solid or Redis + Sidekiq), pagination, staging environment, application services, secrets handling, authentication (Rails 8 built-in or Devise), VCR, JS linting, Docker and Kamal, GitHub Actions CI, and mailers.
+- Non-interactive use: `--database/-d`, `--javascript/-j`, `--config FILE` (YAML answers) and `--yes`.
+- `opinionated_rails list` and `opinionated_rails info STEP_ID`.
+- Checks for required tools (yarn or bun for React) before generating, and refuses to overwrite an existing directory.
+- Final `bundle install`, JavaScript install and RuboCop autocorrect so a generated app boots and passes its own `bin/rubocop`, Brakeman and bundler-audit.
+- Complete Kamal config (`config/deploy.yml`, `.kamal/secrets`), staging that cannot send production email, ESLint 9 flat config, Redis fail-fast in production, and warnings when an expected Rails edit cannot be made.
+- Requires Rails 8.1 or newer in the 8.x series.
+- Authentication is skipped for API-only apps (Rails' generator and Devise both assume browser sessions).
+
+### Fixed since the 0.1.0 tag
+
+- `--database mysql` failed in `rails new`, because Rails 8.1 accepts `mysql` and the tool passed `mysql2`.
+- React with bun failed to build: Rails' `bun.config.js` pointed at `application.js`, but the React step writes `application.jsx`. The entry point is now set to `application.jsx`, with a warning if Rails' file has changed.
+- Added a RubyGems release workflow (trusted publishing, triggered by a version tag).
+
+## 0.1.0 to 0.1.3 (tagged, not published)
+
+Superseded by 0.1.4.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brolin Remunyanga
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,59 @@
+# opinionated_rails
+
+Generate a Rails 8 app by choosing from independent, opinionated options. The tool runs `rails new`, then layers on exactly the pieces you picked (database, tests, frontend, background jobs, authentication, CI, deployment and more) and checks that the result boots and passes its own RuboCop, Brakeman and bundler-audit.
+
+**Documentation: <https://brolinr.github.io/opinionated_rails/>**
+
+## Quick start
+
+```bash
+gem install opinionated_rails        # needs Rails 8.1+ (gem install rails)
+
+opinionated_rails new my_app         # answer the prompts; enter accepts a default
+
+# or script it
+opinionated_rails new my_app --database postgresql --javascript esbuild --yes
+opinionated_rails new my_app --config answers.yml --yes
+```
+
+For React you also need `yarn` (esbuild, webpack) or `bun`. The tool checks before generating anything.
+
+## What it can do
+
+| Area | Options |
+| --- | --- |
+| Database | SQLite, PostgreSQL, MySQL |
+| App type | Full-stack, API-only |
+| Tests | Minitest, RSpec (FactoryBot or fixtures), VCR |
+| Frontend | Stimulus + Hotwire, or React with esbuild, bun or webpack; Tailwind CSS; ESLint 9 |
+| Jobs, cache, cable | Solid Trifecta, or Redis + Sidekiq |
+| Authentication | Rails 8 built-in or Devise (full-stack apps) |
+| Also | Pagination (pagy or geared_pagination), staging environment, application services, dotenv or Rails credentials, mailers, GitHub Actions CI, Docker and Kamal deployment |
+
+Every choice has a flag or a [config file](https://brolinr.github.io/opinionated_rails/config-file.html) key, and values are validated before anything is generated.
+
+## Documentation
+
+- [Getting started](https://brolinr.github.io/opinionated_rails/getting-started.html)
+- [Command line](https://brolinr.github.io/opinionated_rails/command-line.html) and [config file](https://brolinr.github.io/opinionated_rails/config-file.html)
+- [Every option](https://brolinr.github.io/opinionated_rails/options.html) and [the generated app](https://brolinr.github.io/opinionated_rails/generated-app.html)
+- [Deploying with Kamal](https://brolinr.github.io/opinionated_rails/deploying.html)
+- [Troubleshooting](https://brolinr.github.io/opinionated_rails/troubleshooting.html)
+- [Contributing](https://brolinr.github.io/opinionated_rails/contributing/): architecture, writing a step, testing, releasing
+
+The sources are in [`docs/`](docs/). `opinionated_rails list` and `opinionated_rails info STEP_ID` show the steps in your terminal.
+
+## Development
+
+```bash
+bin/setup
+bundle exec rspec                          # fast suite
+bundle exec rubocop
+RUN_INTEGRATION_SPECS=1 bundle exec rspec  # also generates real apps for every combo (slow, needs network)
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md), [STYLE.md](STYLE.md) and the [contributing guide](docs/contributing/).
+
+## License
+
+Released under the [MIT License](LICENSE.txt).

data/exe/opinionated_rails

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "opinionated_rails"
+require "opinionated_rails/cli"
+
+OpinionatedRails::CLI.start(ARGV)

data/lib/opinionated_rails/answer_shell.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  # Wraps the interactive shell so prompts can be answered from flags or a config file.
+  # Unanswered prompts fall through to the wrapped shell, or take their default with `yes: true`.
+  # A preset answer that a step rejects raises instead of re-prompting forever.
+  class AnswerShell
+    # config key => text found in the prompt label (the part before "(default")
+    LABELS = {
+      "app_name" => "App name",
+      "database" => "Database",
+      "app_type" => "App type",
+      "test_framework" => "Test framework",
+      "frontend" => "Frontend",
+      "bundler" => "Bundler",
+      "rubocop" => "RuboCop style",
+      "stack" => "Stack",
+      "pagination" => "Pagination",
+      "staging" => "staging environment",
+      "services" => "application service",
+      "secrets" => "Secrets handling",
+      "auth_model" => "User model name",
+      "auth" => "Authentication",
+      "factory" => "Factory strategy",
+      "vcr" => "VCR",
+      "js_lint" => "JS linting",
+      "kamal" => "Kamal",
+      "ci" => "CI workflow",
+      "mailer" => "mailer"
+    }.freeze
+
+    VALUE_ALIASES = {
+      "database" => { "sqlite3" => "sqlite", "postgres" => "postgresql", "pg" => "postgresql", "mysql2" => "mysql" },
+      "secrets" => { "credentials" => "rails_credentials" }
+    }.freeze
+
+    YES_NO = %w[ yes y no n ].freeze
+
+    # Accepted values per key, checked before anything is generated so a typo fails immediately
+    # instead of after `rails new` has already run. A spec keeps this in step with the steps' prompts.
+    CHOICES = {
+      "database" => %w[ sqlite postgresql mysql ],
+      "app_type" => %w[ full-stack api-only ],
+      "test_framework" => %w[ minitest rspec ],
+      "frontend" => %w[ stimulus stimulus+hotwire react ],
+      "bundler" => %w[ esbuild bun webpack ],
+      "rubocop" => %w[ omakase custom ],
+      "stack" => %w[ solid redis ],
+      "pagination" => %w[ pagy geared_pagination ],
+      "secrets" => %w[ rails_credentials rails\ credentials dotenv ],
+      "auth" => %w[ none rails8 devise ],
+      "factory" => %w[ factorybot factory_bot fixtures ],
+      "staging" => YES_NO, "services" => YES_NO, "vcr" => YES_NO, "js_lint" => YES_NO,
+      "kamal" => YES_NO, "ci" => YES_NO, "mailer" => YES_NO
+    }.freeze
+
+    MODEL_NAME = /\A[A-Z][A-Za-z0-9]*\z/
+
+    attr_reader :used
+
+    def initialize(base, answers: {}, yes: false)
+      @base = base
+      @yes = yes
+      @answers = normalize(answers)
+      @used = Hash.new(0)
+    end
+
+    def ask(prompt = nil, *args)
+      key = key_for(prompt)
+
+      if key && @answers.key?(key)
+        @used[key] += 1
+        raise Error, invalid_message(key, prompt) if @used[key] > 1
+
+        return @answers[key]
+      end
+
+      return "" if @yes
+
+      @base.ask(prompt, *args)
+    end
+
+    # Config keys that no prompt consumed (e.g. `bundler` for a Stimulus app).
+    def unused_keys
+      @answers.keys - @used.keys
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @base.respond_to?(name, include_private) || super
+    end
+
+    def method_missing(name, *args, &block)
+      return super unless @base.respond_to?(name)
+
+      @base.public_send(name, *args, &block)
+    end
+
+    private
+
+    def key_for(prompt)
+      label = prompt.to_s.split("(default").first.downcase
+      LABELS.find { |_, text| label.include?(text.downcase) }&.first
+    end
+
+    def normalize(answers)
+      unknown = answers.keys.map(&:to_s) - LABELS.keys
+      raise Error, "Unknown option(s): #{unknown.join(', ')}. Valid keys: #{LABELS.keys.join(', ')}" unless unknown.empty?
+
+      answers.each_with_object({}) do |(key, value), result|
+        key = key.to_s
+        value = value == true ? "yes" : value == false ? "no" : value.to_s.strip
+        result[key] = VALUE_ALIASES.fetch(key, {}).fetch(value.downcase, value)
+        validate_value!(key, result[key])
+      end
+    end
+
+    def validate_value!(key, value)
+      choices = CHOICES[key]
+      if choices && !choices.include?(value.downcase)
+        raise Error, "Invalid value #{value.inspect} for `#{key}`. Choose one of: #{choices.join(', ')}"
+      end
+      return unless key == "auth_model" && !MODEL_NAME.match?(value)
+
+      raise Error, "Invalid value #{value.inspect} for `auth_model`. Use a CamelCase constant such as User or Account."
+    end
+
+    def invalid_message(key, prompt)
+      "Invalid value #{@answers[key].inspect} for `#{key}` (#{prompt.to_s.strip})"
+    end
+  end
+end

data/lib/opinionated_rails/cli.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module OpinionatedRails
+  class CLI < Thor
+    class UnknownStepError < Thor::Error; end
+
+    def self.exit_on_failure? = true
+
+    # The database steps use the adapter name (:mysql2), but `rails new --database` wants "mysql".
+    RAILS_DATABASE_FLAGS = { sqlite3: "sqlite3", postgresql: "postgresql", mysql2: "mysql" }.freeze
+
+    # Steps `new` runs after `rails new`, in declaration order (StepGraph sorts by dependency).
+    def self.generated_steps
+      [
+          Steps::Core::TestingStep,
+          Steps::Core::FrontendStep,
+          Steps::Core::DatabaseStep,
+          Steps::Addons::JsLintStep,
+          Steps::Addons::DocsStep,
+          Steps::Addons::SpaControllerStep,
+          Steps::Addons::TailwindStep,
+          Steps::Addons::FactoryOrFixturesStep,
+          Steps::Addons::VcrStep,
+          Steps::Addons::RubocopStep,
+          Steps::Addons::CiStep,
+          Steps::Addons::FakerStep,
+          Steps::Addons::PrIssueTemplatesStep,
+          Steps::Addons::SolidStackStep,
+          Steps::Addons::PaginationStep,
+          Steps::Addons::StagingEnvStep,
+          Steps::Addons::ServicesStep,
+          Steps::Addons::SecretsHandlingStep,
+          Steps::Addons::AuthStep,
+          Steps::Addons::MailerStep,
+          Steps::Addons::DockerKamalStep
+      ]
+    end
+
+    desc "new [APP_NAME]", "Generate a new Rails app"
+    method_option :skip_bundle_install, type: :boolean, default: false, desc: "Skip bundle install"
+    method_option :database, aliases: "-d", type: :string, desc: "sqlite3, postgresql or mysql (skips the prompt)"
+    method_option :javascript, aliases: "-j", type: :string,
+                               desc: "Use React with this bundler: esbuild, bun or webpack (skips the prompts)"
+    method_option :config, aliases: "-c", type: :string, desc: "YAML file of answers; see the README for keys"
+    method_option :yes, aliases: "-y", type: :boolean, default: false, desc: "Accept the default for every unanswered prompt"
+    def new(app_name = nil)
+      RailsVersionGuard.check_installed!
+      answers = preset_answers(app_name)
+      shell = AnswerShell.new(Thor::Shell::Basic.new, answers: answers, yes: options[:yes])
+      context = OpinionatedRails::Context.new(
+        app_path: Dir.pwd,
+        shell: shell,
+        skip_bundle_install: options[:skip_bundle_install]
+      )
+
+      context.answer(:app_name_input, app_name) if app_name
+      prompt_and_generate(context, Steps::Core::AppNameStep)
+      chosen_name = context.output(:app_name, :app_name)
+      if chosen_name && File.exist?(File.join(Dir.pwd, chosen_name))
+        raise OpinionatedRails::Error, "Directory #{chosen_name} already exists"
+      end
+      prompt_and_generate(context, Steps::Core::DatabaseStep)
+      prompt_and_generate(context, Steps::Core::AppTypeStep)
+
+      testing_step = Steps::Core::TestingStep.new
+      testing_step.prompt(context) if testing_step.if_condition(context)
+
+      frontend_step = Steps::Core::FrontendStep.new
+      frontend_step.prompt(context) if frontend_step.if_condition(context)
+
+      app_name = context.output(:app_name, :app_name)
+      raise OpinionatedRails::Error, "No app name captured" unless app_name
+
+      Prerequisites.check!(context)
+
+      flags = build_rails_new_flags(context)
+      context.app_path = File.join(Dir.pwd, app_name)
+
+      OpinionatedRails::Generators::RailsNewInvoker.new(
+        app_name,
+        flags: flags,
+        skip_bundle_install: context.skip_bundle_install
+      ).invoke
+
+      prompted = [ :testing, :frontend, :database ]
+      selected_steps = self.class.generated_steps.map(&:new)
+
+      StepGraph.new(selected_steps).sorted.each do |step|
+        run_step(context, step, prompted)
+      end
+
+      finish_app(context)
+
+      unused = shell.unused_keys
+      shell.say("Ignored options (their prompt did not apply): #{unused.join(', ')}", :yellow) unless unused.empty?
+    end
+
+    desc "add STEP_ID", "Add a step to an existing app"
+    def add(_step_id)
+      raise NotImplementedError, "OpinionatedRails::CLI#add not yet implemented"
+    end
+
+    desc "list", "List all supported steps"
+    method_option :tier, type: :string, enum: %w[ core addon ], desc: "Filter by tier"
+    def list
+      steps = step_classes
+      steps = steps.select { |step_class| step_class.tier.to_s == options[:tier] } if options[:tier]
+
+      steps.each do |step_class|
+        puts "#{step_class.id} (#{step_class.tier}) — #{step_class.summary}"
+      end
+    end
+
+    desc "info STEP_ID", "Show details for a step"
+    def info(step_id)
+      step_id = step_id.to_sym
+      step_class = step_classes.find { |klass| klass.id == step_id }
+      raise UnknownStepError, "Unknown step: #{step_id.inspect}" unless step_class
+
+      puts "id:          #{step_class.id}"
+      puts "tier:        #{step_class.tier}"
+      puts "summary:     #{step_class.summary}"
+      puts "description: #{step_class.description}"
+      puts "needs:       #{format_needs(step_class)}"
+      puts "prompts for: #{format_prompts(step_class)}"
+      puts "outputs:     #{safe_outputs(step_class)}"
+    end
+
+    private
+
+    def run_step(context, step, prompted)
+      unless prompted.include?(step.class.id)
+        step.prompt(context) if step.if_condition(context)
+        prompted << step.class.id
+      end
+
+      step.generate(context)
+    rescue StandardError => e
+      raise_with_recovery_hint(context, step.class.id, e)
+    end
+
+    def finish_app(context)
+      { "bundle install" => -> { install_bundle(context) },
+        "JavaScript install" => -> { install_javascript_packages(context) },
+        "Tailwind build" => -> { build_tailwind_css(context) },
+        "RuboCop autocorrect" => -> { autocorrect_style(context) } }.each do |name, action|
+        action.call
+      rescue StandardError => e
+        raise_with_recovery_hint(context, name, e)
+      end
+    end
+
+    # A failure after `rails new` leaves a half-built app. Say which step failed and where it is,
+    # rather than leaving the user with only the underlying error.
+    def raise_with_recovery_hint(context, step_name, error)
+      raise OpinionatedRails::Error,
+            "Step `#{step_name}` failed: #{error.message}\n" \
+            "The partially generated app is in #{context.app_path}. Fix the problem above, then delete " \
+            "that directory and run the command again (re-running over it is not supported)."
+    end
+
+    # Answers from --config, overridden by --database / --javascript. The APP_NAME argument wins
+    # over a config app_name.
+    def preset_answers(app_name)
+      answers = load_config(options[:config])
+      answers.delete("app_name") if app_name
+      answers["database"] = options[:database] if options[:database]
+
+      if options[:javascript]
+        answers["frontend"] = "react"
+        answers["bundler"] = options[:javascript]
+      end
+
+      answers
+    end
+
+    def load_config(path)
+      return {} unless path
+
+      raise OpinionatedRails::Error, "Config file not found: #{path}" unless File.file?(path)
+
+      data = YAML.safe_load_file(path) || {}
+      raise OpinionatedRails::Error, "Config file must be a YAML mapping of answers: #{path}" unless data.is_a?(Hash)
+
+      data.transform_keys(&:to_s)
+    rescue Psych::SyntaxError => e
+      raise OpinionatedRails::Error, "Config file is not valid YAML (#{path}): #{e.message}"
+    end
+
+    # Steps append gems to the Gemfile after the last mid-run `bundle install`,
+    # so resolve and install them once everything has been generated.
+    def install_bundle(context)
+      return if context.skip_bundle_install
+
+      success = Dir.chdir(context.app_path) do
+        Bundler.with_unbundled_env { system("bundle", "install", "--quiet") }
+      end
+      success || raise(OpinionatedRails::Error, "final bundle install failed")
+    end
+
+    # Steps add React, ESLint and Tailwind to package.json after jsbundling's own install ran, so
+    # install them, then run the build scripts: without the built assets the first page load fails
+    # with a missing-asset error, and a broken JS pipeline should surface here, not later.
+    def install_javascript_packages(context)
+      return if context.skip_bundle_install
+      return unless File.exist?(File.join(context.app_path, "package.json"))
+
+      runner = context.get(:bundler) == :bun ? "bun" : "yarn"
+      unless Prerequisites.available?(runner)
+        context.shell.say("Warning: #{runner} not found; run `#{runner} install` and its build scripts in the app.", :yellow)
+        return
+      end
+
+      scripts = JSON.parse(File.read(File.join(context.app_path, "package.json"))).fetch("scripts", {})
+      commands = [ [ runner, "install" ] ] + %w[ build build:css ].select { |name| scripts.key?(name) }.map { |name| [ runner, "run", name ] }
+
+      commands.each do |command|
+        success = Dir.chdir(context.app_path) { Bundler.with_unbundled_env { system(*command) } }
+        success || raise(OpinionatedRails::Error, "#{command.join(' ')} failed")
+      end
+    end
+
+    # tailwindcss-rails only builds the CSS through rake hooks, so a fresh app's first `bin/rails test`
+    # (which renders the layout) fails on the missing tailwind.css until it has been built once.
+    def build_tailwind_css(context)
+      return if context.skip_bundle_install
+
+      gemfile = File.join(context.app_path, "Gemfile")
+      return unless File.exist?(gemfile) && File.read(gemfile).include?("tailwindcss-rails")
+
+      success = Dir.chdir(context.app_path) { Bundler.with_unbundled_env { system("bin/rails", "tailwindcss:build") } }
+      success || raise(OpinionatedRails::Error, "bin/rails tailwindcss:build failed")
+    end
+
+    # Generators we don't own (Devise, dockerfile-rails, ...) emit code that fails the app's own
+    # RuboCop config, which would turn the generated CI red on the first push.
+    def autocorrect_style(context)
+      return if context.skip_bundle_install
+      return unless File.exist?(File.join(context.app_path, "bin/rubocop"))
+
+      clean = Dir.chdir(context.app_path) do
+        Bundler.with_unbundled_env { system("bin/rubocop", "-a", "--format", "quiet") }
+      end
+      return if clean
+
+      context.shell.say("Warning: bin/rubocop still reports offenses in the generated app; run it to review.", :yellow)
+    end
+
+    def prompt_and_generate(context, step_class)
+      step = step_class.new
+      step.prompt(context)
+      step.generate(context)
+    end
+
+    def build_rails_new_flags(context)
+      flags = []
+      database = context.output(:database, :database)
+      flags << "--database=#{RAILS_DATABASE_FLAGS.fetch(database, database)}"
+      flags << "--api" if context.output(:app_type, :app_type) == :api_only
+      flags << "--skip-test" if context.get(:testing) == :rspec
+      flags << "--javascript=#{context.get(:bundler)}" if context.get(:frontend) == :react && context.get(:bundler)
+      flags << "--skip-docker"
+      flags << "--skip-kamal"
+      flags << "--skip-ci"
+      flags
+    end
+
+    def step_classes
+      OpinionatedRails.step_classes
+    end
+
+    def format_needs(step_class)
+      return "none" if step_class.needs.empty?
+
+      step_class.needs.join(", ")
+    end
+
+    def format_prompts(step_class)
+      step_class.respond_to?(:prompts) ? step_class.prompts : "not yet implemented"
+    end
+
+    def safe_outputs(step_class)
+      step = step_class.new
+      step.outputs(OpinionatedRails::Context.new(app_path: Dir.pwd))
+    rescue NotImplementedError
+      "not yet implemented"
+    end
+  end
+end

data/lib/opinionated_rails/context.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module OpinionatedRails
+  class Context
+    attr_accessor :app_path, :shell, :skip_bundle_install
+    attr_reader :answers, :outputs
+
+    def initialize(app_path:, shell: Thor::Shell::Basic.new, skip_bundle_install: false)
+      @app_path = app_path
+      @answers = {}
+      @outputs = {}
+      @shell = shell
+      @skip_bundle_install = skip_bundle_install
+    end
+
+    def answer(key, value)
+      @answers[key] = value
+    end
+
+    def get(key)
+      @answers[key]
+    end
+
+    def selected?(step_id)
+      !!@answers[step_id]
+    end
+
+    def set_output(step_id, data)
+      @outputs[step_id] = data
+    end
+
+    def output(step_id, key = nil)
+      step = @outputs.fetch(step_id, {})
+      key ? step[key] : step
+    end
+  end
+end

data/lib/opinionated_rails/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  # Thor::Error makes the CLI print the message and exit non-zero instead of dumping a backtrace.
+  class Error < Thor::Error; end
+end

data/lib/opinionated_rails/generators/file_writer.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module OpinionatedRails
+  module Generators
+    class FileWriter
+      def write(path, content)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+      end
+    end
+  end
+end

data/lib/opinionated_rails/generators/rails_new_invoker.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Generators
+    class RailsNewInvoker
+      def initialize(app_name, flags: [], skip_bundle_install: false)
+        @app_name = app_name
+        @flags = flags
+        @skip_bundle_install = skip_bundle_install
+      end
+
+      def invoke
+        command = [ "rails", "new", @app_name, *@flags ]
+        command << "--skip-bundle" if @skip_bundle_install
+
+        success = if defined?(Bundler)
+                    Bundler.with_unbundled_env { system(*command) }
+        else
+                    system(*command)
+        end
+
+        success || raise(OpinionatedRails::Error, "rails new failed")
+      end
+    end
+  end
+end