opinionated_rails 0.1.4

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class JsLintStep < Step
+        def self.id = :js_lint
+        def self.tier = :addon
+        def self.needs = [ :frontend ]
+        def self.summary = "Configure JavaScript linting"
+        def self.description = "Installs ESLint and writes an ESLint 9 flat config (eslint.config.js) for the chosen frontend stack."
+        def self.prompts = "Enable JS linting? (default: yes)"
+
+        def if_condition(context)
+          context.output(:frontend, :frontend) != :none
+        end
+
+        def prompt(context)
+          shell = context.shell
+          choice = shell.ask("Enable JS linting? (default: yes):").to_s.strip
+          choice = "yes" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "yes", "y"
+              context.answer(:js_lint, true)
+              break
+            when "no", "n"
+              context.answer(:js_lint, false)
+              break
+            else
+              shell.say("Invalid. Enter 'yes' or 'no'.", :red)
+              choice = shell.ask("Enable JS linting? (default: yes):").to_s.strip
+              choice = "yes" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          enabled = if if_condition(context)
+                      context.get(:js_lint) != false
+          else
+                      false
+          end
+
+          data = { js_lint: enabled }
+          data[:js_lint_tool] = :eslint if enabled
+
+          context.set_output(:js_lint, data)
+
+          return unless enabled
+
+          write_eslint_config(context)
+          update_package_json(context)
+        end
+
+        def outputs(context)
+          context.output(:js_lint)
+        end
+
+        private
+
+        # ESLint 9 flat config. `files` names .jsx explicitly: ESLint lints only .js unless told otherwise,
+        # which previously left every React component unlinted.
+        PLAIN_ESLINT_CONFIG = <<~JS
+          const js = require("@eslint/js")
+          const globals = require("globals")
+
+          module.exports = [
+            { ignores: ["app/assets/builds/**", "node_modules/**"] },
+            js.configs.recommended,
+            {
+              files: ["**/*.js"],
+              languageOptions: {
+                ecmaVersion: "latest",
+                sourceType: "module",
+                globals: { ...globals.browser }
+              }
+            }
+          ]
+        JS
+
+        REACT_ESLINT_CONFIG = <<~JS
+          const js = require("@eslint/js")
+          const globals = require("globals")
+          const react = require("eslint-plugin-react")
+          const reactHooks = require("eslint-plugin-react-hooks")
+
+          module.exports = [
+            { ignores: ["app/assets/builds/**", "node_modules/**"] },
+            js.configs.recommended,
+            { ...react.configs.flat.recommended, files: ["**/*.{js,jsx}"] },
+            reactHooks.configs.flat.recommended,
+            {
+              files: ["**/*.{js,jsx}"],
+              languageOptions: {
+                ecmaVersion: "latest",
+                sourceType: "module",
+                globals: { ...globals.browser }
+              },
+              settings: { react: { version: "detect" } }
+            }
+          ]
+        JS
+
+        def write_eslint_config(context)
+          react = context.output(:frontend, :frontend) == :react
+          File.write(File.join(context.app_path, "eslint.config.js"), react ? REACT_ESLINT_CONFIG : PLAIN_ESLINT_CONFIG)
+          FileUtils.rm_f(File.join(context.app_path, ".eslintrc.json")) # ESLint 8 format, ignored by ESLint 9
+        end
+
+        def update_package_json(context)
+          package_json_path = File.join(context.app_path, "package.json")
+          package = File.exist?(package_json_path) ? JSON.parse(File.read(package_json_path)) : {}
+          package["scripts"] ||= {}
+          package["scripts"]["lint:js"] = "eslint app/javascript"
+          package["devDependencies"] ||= {}
+          package["devDependencies"]["eslint"] = "9.39.5"
+          package["devDependencies"]["@eslint/js"] = "9.39.5"
+          package["devDependencies"]["globals"] = "17.13.0"
+
+          if context.output(:frontend, :frontend) == :react
+            package["devDependencies"]["eslint-plugin-react"] = "7.37.5"
+            package["devDependencies"]["eslint-plugin-react-hooks"] = "7.1.1"
+          end
+
+          File.write(package_json_path, JSON.pretty_generate(package))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class MailerStep < Step
+        def self.id = :mailer
+        def self.tier = :addon
+        def self.needs = [ :secrets_handling ]
+        def self.summary = "Configure mailers"
+        def self.description = "Sets up Letter Opener in development and Postmark in production."
+        def self.prompts = "Enable mailer setup (Letter Opener dev / Postmark production)? (default: yes)"
+
+        LETTER_OPENER_VERSION = "1.10.0".freeze
+        POSTMARK_RAILS_VERSION = "0.22.1".freeze
+
+        DEVELOPMENT_ANCHOR = 'config.action_mailer.default_url_options = { host: "localhost", port: 3000 }'
+        DEVELOPMENT_LINE = "config.action_mailer.delivery_method = :letter_opener"
+
+        PRODUCTION_ANCHOR = 'config.action_mailer.default_url_options = { host: "example.com" }'
+
+        POSTMARK_ENV_VAR_LINE = "POSTMARK_API_TOKEN="
+
+        def if_condition(_context) = true
+
+        def prompt(context)
+          shell = context.shell
+          choice = shell.ask("Enable mailer setup (Letter Opener dev / Postmark production)? (default: yes):").to_s.strip
+          choice = "yes" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "yes", "y"
+              context.answer(:mailer, true)
+              break
+            when "no", "n"
+              context.answer(:mailer, false)
+              break
+            else
+              shell.say("Invalid. Enter 'yes' or 'no'.", :red)
+              choice = shell.ask("Enable mailer setup (Letter Opener dev / Postmark production)? (default: yes):").to_s.strip
+              choice = "yes" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          enabled = context.get(:mailer) != false
+
+          if enabled
+            add_development_group_gem(context, "gem \"letter_opener\", \"#{LETTER_OPENER_VERSION}\"")
+            add_top_level_gem(context, "gem \"postmark-rails\", \"#{POSTMARK_RAILS_VERSION}\"")
+            configure_development(context)
+            configure_production(context)
+            ensure_application_mailer(context)
+          end
+
+          context.set_output(:mailer, { mailer: enabled })
+        end
+
+        def outputs(context)
+          context.output(:mailer)
+        end
+
+        private
+
+        def configure_development(context)
+          insert_after_anchor(
+            context,
+            File.join(context.app_path, "config/environments/development.rb"),
+            DEVELOPMENT_ANCHOR,
+            [ DEVELOPMENT_LINE ]
+          )
+        end
+
+        def configure_production(context)
+          insert_after_anchor(
+            context,
+            File.join(context.app_path, "config/environments/production.rb"),
+            PRODUCTION_ANCHOR,
+            production_lines(context)
+          )
+        end
+
+        def production_lines(context)
+          secrets_handling = context.output(:secrets_handling, :secrets_handling) || :rails_credentials
+
+          api_token_line = case secrets_handling
+          when :dotenv
+            append_env_placeholder(context)
+            'config.action_mailer.postmark_settings = { api_token: ENV["POSTMARK_API_TOKEN"] }'
+          else
+            "config.action_mailer.postmark_settings = { api_token: Rails.application.credentials.dig(:postmark, :api_token) }"
+          end
+
+          [ "config.action_mailer.delivery_method = :postmark", api_token_line ]
+        end
+
+        def append_env_placeholder(context)
+          path = File.join(context.app_path, ".env.example")
+          return unless File.exist?(path)
+
+          content = File.read(path)
+          return if content.include?(POSTMARK_ENV_VAR_LINE)
+
+          File.open(path, "a") { |f| f.puts(POSTMARK_ENV_VAR_LINE) }
+        end
+
+        # A Rails release that rewords the anchor must not silently leave mail unconfigured.
+        def insert_after_anchor(context, path, anchor, new_lines)
+          relative = path.delete_prefix("#{context.app_path}/")
+          unless File.exist?(path)
+            context.shell.say("Warning: #{relative} not found; mailer settings were not added.", :yellow)
+            return
+          end
+
+          content = File.read(path)
+          return if new_lines.all? { |line| content.include?(line) }
+
+          lines = content.lines
+          anchor_index = lines.index { |line| line.include?(anchor) }
+          unless anchor_index
+            context.shell.say(
+              "Warning: could not find `#{anchor}` in #{relative}; add these lines yourself:\n  #{new_lines.join("\n  ")}",
+              :yellow
+            )
+            return
+          end
+
+          indent = lines[anchor_index][/\A\s*/]
+          insertion = new_lines.map { |line| "#{indent}#{line}\n" }
+          lines.insert(anchor_index + 1, *insertion)
+
+          File.write(path, lines.join)
+        end
+
+        def ensure_application_mailer(context)
+          path = File.join(context.app_path, "app/mailers/application_mailer.rb")
+          return if File.exist?(path)
+
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, <<~RUBY)
+            class ApplicationMailer < ActionMailer::Base
+              default from: "from@example.com"
+              layout "mailer"
+            end
+          RUBY
+        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/pagination_step.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class PaginationStep < Step
+        def self.id = :pagination
+        def self.tier = :addon
+        def self.needs = []
+        def self.summary = "Configure pagination"
+        def self.description = "Installs geared_pagination or pagy for paginated collections."
+        def self.prompts = "Pagination: geared_pagination or pagy (default: pagy)"
+
+        GEARED_PAGINATION_VERSION = "1.2.0".freeze
+        PAGY_VERSION = "43.6.1".freeze
+
+        PAGY_INITIALIZER = <<~RUBY
+          # frozen_string_literal: true
+
+          # Pagy initializer — see https://ddnexus.github.io/pagy/toolbox/configuration/initializer/
+          # for the full list of available options.
+
+          Pagy::OPTIONS.freeze
+        RUBY
+
+        def if_condition(_context) = true
+
+        def prompt(context)
+          shell = context.shell
+          shell.say("Choose a pagination library:")
+          shell.say("  1. geared_pagination")
+          shell.say("  2. pagy (default)")
+
+          choice = shell.ask("Pagination (default: pagy):").to_s.strip
+          choice = "2" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "geared_pagination", "1"
+              context.answer(:pagination, :geared_pagination)
+              break
+            when "pagy", "2"
+              context.answer(:pagination, :pagy)
+              break
+            else
+              shell.say("Invalid. Enter 'geared_pagination', 'pagy', 1, or 2.", :red)
+              choice = shell.ask("Pagination (default: pagy):").to_s.strip
+              choice = "2" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          strategy = context.get(:pagination) || :pagy
+
+          if strategy == :pagy
+            install_pagy(context)
+          else
+            install_geared_pagination(context)
+          end
+
+          context.set_output(:pagination, { pagination: strategy })
+        end
+
+        def outputs(context)
+          context.output(:pagination)
+        end
+
+        private
+
+        def install_geared_pagination(context)
+          add_top_level_gem(context, "gem \"geared_pagination\", \"#{GEARED_PAGINATION_VERSION}\"")
+        end
+
+        def install_pagy(context)
+          add_top_level_gem(context, "gem \"pagy\", \"#{PAGY_VERSION}\"")
+          write_pagy_initializer(context)
+          # Pagy 43 replaced Backend/Frontend with Pagy::Method (controller only); view helpers live on @pagy.
+          include_module(context, "app/controllers/application_controller.rb", "ApplicationController", "Pagy::Method")
+        end
+
+        def write_pagy_initializer(context)
+          path = File.join(context.app_path, "config/initializers/pagy.rb")
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, PAGY_INITIALIZER)
+        end
+
+        def include_module(context, relative_path, class_or_module_name, module_to_include)
+          path = File.join(context.app_path, relative_path)
+          return unless File.exist?(path)
+
+          content = File.read(path)
+          include_line = "include #{module_to_include}"
+          return if content.include?(include_line)
+
+          lines = content.lines
+          open_index = lines.index { |line| line.match?(/\A(class|module)\s+#{Regexp.escape(class_or_module_name)}\b/) }
+          return unless open_index
+
+          lines.insert(open_index + 1, "  #{include_line}\n")
+          File.write(path, lines.join)
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class PrIssueTemplatesStep < Step
+        def self.id = :pr_issue_templates
+        def self.tier = :addon
+        def self.needs = []
+        def self.summary = "Generate GitHub templates"
+        def self.description = "Adds default pull request and issue templates."
+        def self.prompts = "None"
+
+        TEMPLATES_DIR = File.expand_path("../../templates/github", __dir__)
+
+        FILES = {
+          "PULL_REQUEST_TEMPLATE.md" => ".github/PULL_REQUEST_TEMPLATE.md",
+          "ISSUE_TEMPLATE/bug_report.md" => ".github/ISSUE_TEMPLATE/bug_report.md",
+          "ISSUE_TEMPLATE/feature_request.md" => ".github/ISSUE_TEMPLATE/feature_request.md"
+        }.freeze
+
+        def if_condition(_context) = true
+
+        def prompt(_context); end
+
+        def generate(context)
+          writer = OpinionatedRails::Generators::FileWriter.new
+
+          FILES.each do |source, destination|
+            content = File.read(File.join(TEMPLATES_DIR, source))
+            writer.write(File.join(context.app_path, destination), content)
+          end
+
+          context.set_output(:pr_issue_templates, { pr_issue_templates: true })
+        end
+
+        def outputs(context)
+          context.output(:pr_issue_templates)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module OpinionatedRails
+  module Steps
+    module Addons
+      class RubocopStep < Step
+        def self.id = :rubocop
+        def self.tier = :addon
+        def self.needs = []
+        def self.summary = "Configure RuboCop"
+        def self.description = "Installs and configures RuboCop with Omakase defaults or a custom setup."
+        def self.prompts = "RuboCop style: Omakase or Custom (default: Omakase)"
+
+        RUBOCOP_OMAKASE_VERSION = "1.1.0".freeze
+        UNPINNED_GEM_LINE = 'gem "rubocop-rails-omakase", require: false'
+        CUSTOM_OVERRIDES_TEMPLATE = File.expand_path("../../templates/rubocop/custom_overrides.yml", __dir__)
+
+        def if_condition(_context) = true
+
+        def prompt(context)
+          shell = context.shell
+          shell.say("Choose a RuboCop style:")
+          shell.say("  1. Omakase (default)")
+          shell.say("  2. Custom")
+
+          choice = shell.ask("RuboCop style (default: Omakase):").to_s.strip
+          choice = "1" if choice.empty?
+
+          loop do
+            case choice.downcase
+            when "omakase", "1"
+              context.answer(:rubocop, :omakase)
+              break
+            when "custom", "2"
+              context.answer(:rubocop, :custom)
+              break
+            else
+              shell.say("Invalid. Enter 'Omakase', 'Custom', 1, or 2.", :red)
+              choice = shell.ask("RuboCop style (default: Omakase):").to_s.strip
+              choice = "1" if choice.empty?
+            end
+          end
+        end
+
+        def generate(context)
+          style = context.get(:rubocop) || :omakase
+
+          pin_rubocop_gem(context)
+          write_custom_overrides(context) if style == :custom
+
+          context.set_output(:rubocop, { rubocop: style })
+        end
+
+        def outputs(context)
+          context.output(:rubocop)
+        end
+
+        private
+
+        def pin_rubocop_gem(context)
+          gemfile_path = File.join(context.app_path, "Gemfile")
+          return unless File.exist?(gemfile_path)
+
+          pinned_line = "gem \"rubocop-rails-omakase\", \"#{RUBOCOP_OMAKASE_VERSION}\", require: false"
+          content = File.read(gemfile_path)
+          return if content.include?(pinned_line)
+
+          if content.include?(UNPINNED_GEM_LINE)
+            File.write(gemfile_path, content.sub(UNPINNED_GEM_LINE, pinned_line))
+          else
+            add_dev_test_group_gem(context, pinned_line)
+          end
+        end
+
+        def add_dev_test_group_gem(context, gem_line)
+          gemfile_path = File.join(context.app_path, "Gemfile")
+          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
+
+        def write_custom_overrides(context)
+          rubocop_yml_path = File.join(context.app_path, ".rubocop.yml")
+          overrides = File.read(CUSTOM_OVERRIDES_TEMPLATE)
+
+          content = <<~YAML
+            # Omakase Ruby styling for Rails
+            inherit_gem: { rubocop-rails-omakase: rubocop.yml }
+
+            # --- user overrides below ---
+            #{overrides}
+          YAML
+
+          File.write(rubocop_yml_path, content)
+        end
+      end
+    end
+  end
+end