opinionated_rails 0.1.4

data/lib/opinionated_rails/steps/addons/ci_step.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class CiStep < Step
+        def self.id = :ci
+        def self.tier = :addon
+        def self.needs = [ :rubocop, :testing ]
+        def self.summary = "Configure CI"
+        def self.description = "Generates a GitHub Actions workflow for tests, RuboCop, security scans and JS lint."
+        def self.prompts = "Enable CI workflow? (default: yes)"
+
+        POSTGRES_SERVICE = <<~YAML.gsub(/^/, "      ")
+          postgres:
+            image: postgres:16
+            env:
+              POSTGRES_USER: postgres
+              POSTGRES_PASSWORD: postgres
+            ports: [ "5432:5432" ]
+            options: >-
+              --health-cmd="pg_isready" --health-interval=10s --health-timeout=5s --health-retries=5
+        YAML
+
+        MYSQL_SERVICE = <<~YAML.gsub(/^/, "      ")
+          mysql:
+            image: mysql:8.4
+            env:
+              MYSQL_ALLOW_EMPTY_PASSWORD: "true"
+            ports: [ "3306:3306" ]
+            options: >-
+              --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=5
+        YAML
+
+        REDIS_SERVICE = <<~YAML.gsub(/^/, "      ")
+          redis:
+            image: redis:7
+            ports: [ "6379:6379" ]
+            options: >-
+              --health-cmd="redis-cli ping" --health-interval=10s --health-timeout=5s --health-retries=5
+        YAML
+
+        def if_condition(_context) = true
+
+        def prompt(context)
+          shell = context.shell
+          choice = shell.ask("Enable CI workflow? (default: yes):").to_s.strip
+          choice = "yes" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "yes", "y"
+              context.answer(:ci, true)
+              break
+            when "no", "n"
+              context.answer(:ci, false)
+              break
+            else
+              shell.say("Invalid. Enter 'yes' or 'no'.", :red)
+              choice = shell.ask("Enable CI workflow? (default: yes):").to_s.strip
+              choice = "yes" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          enabled = context.get(:ci) != false
+
+          write_workflow(context) if enabled
+
+          context.set_output(:ci, { ci: enabled })
+        end
+
+        def outputs(context)
+          context.output(:ci)
+        end
+
+        private
+
+        def write_workflow(context)
+          path = File.join(context.app_path, ".github/workflows/ci.yml")
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, workflow_content(context))
+        end
+
+        def workflow_content(context)
+          jobs = [ security_job(context), test_job(context), rubocop_job ]
+          jobs << js_lint_job(context) if context.output(:js_lint, :js_lint) || false
+
+          <<~YAML + jobs.compact.join("\n")
+            name: CI
+
+            on:
+              pull_request:
+              push:
+                branches: [ main ]
+
+            permissions:
+              contents: read
+
+            concurrency:
+              group: ci-${{ github.workflow }}-${{ github.ref }}
+              cancel-in-progress: true
+
+            jobs:
+          YAML
+        end
+
+        CHECKOUT_AND_RUBY = <<~YAML.gsub(/^/, "      ")
+          - uses: actions/checkout@v4
+          - uses: ruby/setup-ruby@v1
+            with:
+              bundler-cache: true
+        YAML
+
+        # `rails new --skip-ci` drops Rails' own scan job, so keep the same scans here.
+        def security_job(context)
+          scans = %w[ brakeman bundler-audit ].select { |tool| File.exist?(File.join(context.app_path, "bin", tool)) }
+          return if scans.empty?
+
+          steps = scans.map { |tool| "      - name: Run #{tool}\n        run: bin/#{tool}#{' --no-pager' if tool == 'brakeman'}\n" }
+
+          <<~YAML.chomp + "\n" + CHECKOUT_AND_RUBY + steps.join
+            \x20\x20security:
+                runs-on: ubuntu-latest
+                timeout-minutes: 15
+                steps:
+          YAML
+        end
+
+        def test_job(context)
+          header = <<~YAML.chomp
+            \x20\x20test:
+                runs-on: ubuntu-latest
+                timeout-minutes: 15
+          YAML
+
+          setup = []
+          setup << "      - uses: actions/setup-node@v4\n        with:\n          node-version: lts/*\n" if react?(context)
+          setup << "      - uses: oven-sh/setup-bun@v2\n" if react?(context) && js_runner(context) == "bun"
+          setup << "      - name: Install system libraries\n        run: sudo apt-get update && sudo apt-get install --no-install-recommends -y libmysqlclient-dev\n" if database(context) == :mysql2
+
+          steps = CHECKOUT_AND_RUBY + setup.join
+          steps += react_build_steps(context) if react?(context)
+          # db:migrate first because a fresh app has migrations but no schema.rb yet; db:test:prepare then
+          # loads it and triggers the Tailwind/JS build hooks. DATABASE_URL carries a database name because
+          # dockerfile-rails' database.yml appends "_cache" to its path.
+          steps += "      - name: Set up database\n        run: bin/rails db:create db:migrate db:test:prepare\n"
+          steps += "      - name: Run tests\n        run: #{test_command(context)}\n"
+
+          "#{header}\n#{services_and_env(context)}    steps:\n#{steps}"
+        end
+
+        def services_and_env(context)
+          services = []
+          env = [ "RAILS_ENV: test" ]
+
+          case database(context)
+          when :postgresql
+            services << POSTGRES_SERVICE
+            env << "DATABASE_URL: postgres://postgres:postgres@localhost:5432/ci_test"
+          when :mysql2
+            services << MYSQL_SERVICE
+            env << "DATABASE_URL: mysql2://root@127.0.0.1:3306/ci_test"
+          end
+
+          if context.output(:solid_stack, :solid_stack) == :redis
+            services << REDIS_SERVICE
+            env << "REDIS_URL: redis://localhost:6379/1"
+          end
+
+          block = +""
+          block << "    services:\n#{services.join}" unless services.empty?
+          block << "    env:\n#{env.map { |line| "      #{line}\n" }.join}"
+          block
+        end
+
+        def database(context) = context.output(:database, :database)
+
+        # The app is installed with yarn (or bun); npm would ignore its lockfile.
+        def js_runner(context) = context.get(:bundler) == :bun ? "bun" : "yarn"
+
+        def react_build_steps(context)
+          runner = js_runner(context)
+          "      - run: #{runner} install\n" \
+            "      - name: Build JavaScript and CSS\n        run: #{runner} run build && #{runner} run build:css\n"
+        end
+
+        def react?(context) = context.output(:frontend, :frontend) == :react
+
+        def rubocop_job
+          <<~YAML.chomp + "\n" + CHECKOUT_AND_RUBY + "      - name: Run RuboCop\n        run: bin/rubocop -f github\n"
+            \x20\x20rubocop:
+                runs-on: ubuntu-latest
+                timeout-minutes: 15
+                steps:
+          YAML
+        end
+
+        def test_command(context)
+          if context.output(:testing, :test_framework) == :rspec
+            "bundle exec rspec"
+          else
+            "bin/rails test"
+          end
+        end
+
+        def js_lint_job(context)
+          runner = js_runner(context)
+          bun_setup = runner == "bun" ? "      - uses: oven-sh/setup-bun@v2\n" : ""
+
+          <<~YAML.chomp + "\n" + bun_setup + "      - run: #{runner} install\n      - name: Run JS lint\n        run: #{runner} run lint:js\n"
+            \x20\x20js_lint:
+                runs-on: ubuntu-latest
+                timeout-minutes: 15
+                steps:
+                  - uses: actions/checkout@v4
+                  - uses: actions/setup-node@v4
+                    with:
+                      node-version: lts/*
+          YAML
+        end
+      end
+    end
+  end
+end

data/lib/opinionated_rails/steps/addons/docker_kamal_step.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class DockerKamalStep < Step
+        def self.id = :docker_kamal
+        def self.tier = :addon
+        def self.needs = [ :database, :frontend, :solid_stack ]
+        def self.summary = "Configure Docker and Kamal"
+        def self.description = "Generates a Dockerfile and optional Kamal deployment files."
+        def self.prompts = "Enable Kamal deployment? (default: no) — Docker itself is always generated"
+
+        DOCKERFILE_RAILS_VERSION = "1.7.10".freeze
+        KAMAL_VERSION = "2.12.0".freeze
+
+        def if_condition(_context) = true
+
+        def prompt(context)
+          shell = context.shell
+          choice = shell.ask("Enable Kamal deployment? (default: no):").to_s.strip
+          choice = "no" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "yes", "y"
+              context.answer(:docker_kamal, true)
+              break
+            when "no", "n"
+              context.answer(:docker_kamal, false)
+              break
+            else
+              shell.say("Invalid. Enter 'yes' or 'no'.", :red)
+              choice = shell.ask("Enable Kamal deployment? (default: no):").to_s.strip
+              choice = "no" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          kamal_enabled = context.get(:docker_kamal) == true
+
+          install_dockerfile_rails(context)
+          install_kamal(context) if kamal_enabled
+
+          context.set_output(:docker_kamal, { docker: true, kamal: kamal_enabled })
+        end
+
+        def outputs(context)
+          context.output(:docker_kamal)
+        end
+
+        private
+
+        def install_dockerfile_rails(context)
+          add_development_group_gem(context, "gem \"dockerfile-rails\", \"#{DOCKERFILE_RAILS_VERSION}\"")
+
+          return if context.skip_bundle_install
+
+          run_in_app(context, "bundle", "install", "--quiet") ||
+            raise(OpinionatedRails::Error, "bundle install failed")
+          run_in_app(context, "bundle", "exec", "rails", "generate", "dockerfile", "--force") ||
+            raise(OpinionatedRails::Error, "rails generate dockerfile failed")
+        end
+
+        def install_kamal(context)
+          add_top_level_gem(context, "gem \"kamal\", \"#{KAMAL_VERSION}\", require: false")
+
+          return if context.skip_bundle_install
+
+          run_in_app(context, "bundle", "install", "--quiet") ||
+            raise(OpinionatedRails::Error, "bundle install failed")
+          run_in_app(context, "bundle", "exec", "kamal", "init") ||
+            raise(OpinionatedRails::Error, "kamal init failed")
+
+          write_kamal_files(context)
+        end
+
+        # Replace `kamal init`'s commented-out templates with files complete for the chosen stack.
+        def write_kamal_files(context)
+          database = context.output(:database, :database)
+          stack = context.output(:solid_stack, :solid_stack)
+          app_name = context.output(:app_name, :app_name) || File.basename(context.app_path)
+
+          File.write(File.join(context.app_path, "config/deploy.yml"),
+                     KamalConfig.deploy_yml(app_name: app_name, database: database, stack: stack))
+          File.write(File.join(context.app_path, ".kamal/secrets"), KamalConfig.secrets(database: database))
+        end
+
+        def run_in_app(context, *command)
+          Dir.chdir(context.app_path) do
+            if defined?(Bundler)
+              Bundler.with_unbundled_env { system(*command) }
+            else
+              system(*command)
+            end
+          end
+        end
+
+        def add_top_level_gem(context, gem_line)
+          gemfile_path = File.join(context.app_path, "Gemfile")
+          return unless File.exist?(gemfile_path)
+
+          content = File.read(gemfile_path)
+          return if content.include?(gem_line)
+
+          File.open(gemfile_path, "a") { |f| f.puts(gem_line) }
+        end
+
+        def add_development_group_gem(context, gem_line)
+          gemfile_path = File.join(context.app_path, "Gemfile")
+          return unless File.exist?(gemfile_path)
+
+          content = File.read(gemfile_path)
+          return if content.include?(gem_line)
+
+          lines = content.lines
+          group_start = lines.index { |line| line.strip == "group :development do" }
+
+          if group_start
+            end_index = (group_start + 1...lines.size).find { |i| lines[i].strip == "end" }
+            lines.insert(end_index, "  #{gem_line}\n")
+          else
+            lines << "\n" unless lines.last.nil? || lines.last.end_with?("\n")
+            lines << "\ngroup :development do\n  #{gem_line}\nend\n"
+          end
+
+          File.write(gemfile_path, lines.join)
+        end
+      end
+    end
+  end
+end

data/lib/opinionated_rails/steps/addons/docs_step.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class DocsStep < Step
+        def self.id = :docs
+        def self.tier = :addon
+        def self.needs = []
+        def self.summary = "Generate project documentation"
+        def self.description = "Creates AGENT.md and STYLE.md files."
+        def self.prompts = "None"
+
+        AGENT_TEXT = "Read STYLE.md before making any changes to this codebase."
+        STYLE_TEMPLATE = File.expand_path("../../templates/docs/STYLE.md", __dir__)
+
+        def if_condition(_context) = true
+
+        def prompt(_context); end
+
+        def generate(context)
+          writer = OpinionatedRails::Generators::FileWriter.new
+          writer.write(File.join(context.app_path, "AGENT.md"), AGENT_TEXT)
+          writer.write(File.join(context.app_path, "STYLE.md"), File.read(STYLE_TEMPLATE))
+
+          context.set_output(:docs, { docs: true })
+        end
+
+        def outputs(context)
+          context.output(:docs)
+        end
+      end
+    end
+  end
+end

data/lib/opinionated_rails/steps/addons/factory_or_fixtures_step.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class FactoryOrFixturesStep < Step
+        def self.id = :factory_or_fixtures
+        def self.tier = :addon
+        def self.needs = [ :testing ]
+        def self.summary = "Configure factories or fixtures"
+        def self.description = "Adds FactoryBot for RSpec or keeps Minitest fixtures."
+        def self.prompts = "FactoryBot or Fixtures for RSpec (default: FactoryBot)"
+
+        FACTORY_BOT_VERSION = "6.4.3".freeze
+
+        MINIMAL_RAILS_HELPER = <<~RUBY
+          require 'spec_helper'
+          ENV['RAILS_ENV'] ||= 'test'
+          require_relative '../config/environment'
+          require 'rspec/rails'
+
+          RSpec.configure do |config|
+            config.fixture_paths = [
+              Rails.root.join('spec/fixtures')
+            ]
+            config.use_transactional_fixtures = true
+          end
+        RUBY
+
+        def if_condition(context)
+          context.output(:testing, :test_framework) == :rspec
+        end
+
+        def prompt(context)
+          shell = context.shell
+          shell.say("Choose a factory/fixture strategy for RSpec:")
+          shell.say("  1. FactoryBot (default)")
+          shell.say("  2. Fixtures")
+
+          choice = shell.ask("Factory strategy (default: FactoryBot):").to_s.strip
+          choice = "1" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "factorybot", "factory_bot", "1"
+              context.answer(:factory_or_fixtures, :factory_bot)
+              break
+            when "fixtures", "2"
+              context.answer(:factory_or_fixtures, :fixtures)
+              break
+            else
+              shell.say("Invalid. Enter 'FactoryBot', 'Fixtures', 1, or 2.", :red)
+              choice = shell.ask("Factory strategy (default: FactoryBot):").to_s.strip
+              choice = "1" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          unless if_condition(context)
+            context.set_output(:factory_or_fixtures, nil)
+            return
+          end
+
+          strategy = context.get(:factory_or_fixtures) || :factory_bot
+          install_factory_bot(context) if strategy == :factory_bot
+
+          context.set_output(:factory_or_fixtures, { factory_or_fixtures: strategy })
+        end
+
+        def outputs(context)
+          context.output(:factory_or_fixtures)
+        end
+
+        private
+
+        def install_factory_bot(context)
+          add_test_group_gem(context, "gem \"factory_bot_rails\", \"#{FACTORY_BOT_VERSION}\"")
+          FileUtils.mkdir_p(File.join(context.app_path, "spec/factories"))
+          ensure_rails_helper(context)
+          include_factory_bot_syntax(context)
+        end
+
+        def add_test_group_gem(context, gem_line)
+          gemfile_path = File.join(context.app_path, "Gemfile")
+          return unless File.exist?(gemfile_path)
+
+          content = File.read(gemfile_path)
+          return if content.include?(gem_line)
+
+          lines = content.lines
+          group_start = lines.index { |line| line.strip == "group :test do" }
+
+          if group_start
+            end_index = (group_start + 1...lines.size).find { |i| lines[i].strip == "end" }
+            lines.insert(end_index, "  #{gem_line}\n")
+          else
+            lines << "\n" unless lines.last.nil? || lines.last.end_with?("\n")
+            lines << "\ngroup :test do\n  #{gem_line}\nend\n"
+          end
+
+          File.write(gemfile_path, lines.join)
+        end
+
+        def ensure_rails_helper(context)
+          rails_helper_path = File.join(context.app_path, "spec/rails_helper.rb")
+          return if File.exist?(rails_helper_path)
+
+          FileUtils.mkdir_p(File.dirname(rails_helper_path))
+          File.write(rails_helper_path, MINIMAL_RAILS_HELPER)
+        end
+
+        def include_factory_bot_syntax(context)
+          rails_helper_path = File.join(context.app_path, "spec/rails_helper.rb")
+          content = File.read(rails_helper_path)
+          return if content.include?("FactoryBot::Syntax::Methods")
+
+          lines = content.lines
+          end_index = lines.rindex { |line| line.strip == "end" }
+          return unless end_index
+
+          lines.insert(end_index, "  config.include FactoryBot::Syntax::Methods\n")
+          File.write(rails_helper_path, lines.join)
+        end
+      end
+    end
+  end
+end

data/lib/opinionated_rails/steps/addons/faker_step.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class FakerStep < Step
+        def self.id = :faker
+        def self.tier = :addon
+        def self.needs = []
+        def self.summary = "Add Faker"
+        def self.description = "Adds the Faker gem for generating fake data."
+        def self.prompts = "None"
+
+        FAKER_VERSION = "3.8.0".freeze
+
+        def if_condition(_context) = true
+
+        def prompt(_context); end
+
+        def generate(context)
+          add_dev_test_group_gem(context, "gem \"faker\", \"#{FAKER_VERSION}\"")
+
+          context.set_output(:faker, { faker: true })
+        end
+
+        def outputs(context)
+          context.output(:faker)
+        end
+
+        private
+
+        def add_dev_test_group_gem(context, gem_line)
+          gemfile_path = File.join(context.app_path, "Gemfile")
+          return unless File.exist?(gemfile_path)
+
+          content = File.read(gemfile_path)
+          return if content.include?(gem_line)
+
+          lines = content.lines
+          group_start = lines.index { |line| line.strip == "group :development, :test do" }
+
+          if group_start
+            end_index = (group_start + 1...lines.size).find { |i| lines[i].strip == "end" }
+            lines.insert(end_index, "  #{gem_line}\n")
+          else
+            lines << "\n" unless lines.last.nil? || lines.last.end_with?("\n")
+            lines << "\ngroup :development, :test do\n  #{gem_line}\nend\n"
+          end
+
+          File.write(gemfile_path, lines.join)
+        end
+      end
+    end
+  end
+end