constable-rails 0.1.0

data/lib/generators/constable/generator/generator_generator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate generator Awesome`.
+    #
+    #   test/cases/generators/awesome_generator_case.rb   class AwesomeGeneratorCase < UnitCase
+    class GeneratorGenerator < Base
+      check_class_collision suffix: "GeneratorCase"
+
+      class_option :namespace, type: :boolean, default: true,
+                               desc: "Namespace generator under lib/generators/name"
+
+      def create_case_file
+        template "generator_case.rb.tt", case_path("generators", class_path, "#{file_name}_generator_case.rb")
+      end
+
+      private
+
+      def generator_path
+        if options[:namespace]
+          File.join("generators", regular_class_path, file_name, "#{file_name}_generator")
+        else
+          File.join("generators", regular_class_path, "#{file_name}_generator")
+        end
+      end
+    end
+  end
+end

data/lib/generators/constable/generator/templates/generator_case.rb.tt

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "case_helper"
+require "<%= generator_path %>"
+
+<% module_namespacing do -%>
+class <%= class_name %>GeneratorCase < UnitCase
+  # Rails' generator harness is a module, so it composes into a case rather than needing
+  # a base class of its own. Wire it up here:
+  #
+  #   include Rails::Generators::Testing::Behaviour
+  #   include FileUtils
+  #
+  #   self.generator_class  = <%= class_name %>Generator
+  #   self.destination_root = Rails.root.join("tmp/generators")
+  #
+  #   briefing { prepare_destination }
+  #
+  # A generator is one of the few things whose test is genuinely about files on disk, so
+  # assert on what it wrote and on what is inside it:
+  #
+  #   investigate "writes the file it promises" do
+  #     run_generator ["Post"]
+  #
+  #     attest(File.read(File.join(destination_root, "app/post.rb"))).to include("class Post")
+  #   end
+end
+<% end -%>

data/lib/generators/constable/helper/helper_generator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate helper Posts` (and by `rails generate controller`, which
+    # hooks the helper generator alongside the test framework).
+    #
+    #   test/cases/helpers/posts_helper_case.rb   class PostsHelperCase < UnitCase
+    #
+    # Rails' own test_unit generator writes nothing here at all. A helper is the cheapest
+    # thing in a Rails app to test -- a module, a method, a return value -- so the file is
+    # worth having, even when it starts out with the module included and nothing to call.
+    class HelperGenerator < Base
+      check_class_collision suffix: "HelperCase"
+
+      def create_case_file
+        template "helper_case.rb.tt", case_path("helpers", class_path, "#{file_name}_helper_case.rb")
+      end
+    end
+  end
+end

data/lib/generators/constable/helper/templates/helper_case.rb.tt

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>HelperCase < UnitCase
+  # A helper is a plain module, so a helper case is a plain unit case: include it and call
+  # the method. No request, no database, no browser -- which is why this is the fastest
+  # tier and the one where a helper belongs.
+  include <%= class_name %>Helper
+
+  # `rails generate helper <%= name %>` writes an empty module, so there is nothing to
+  # call yet. The first method it gains gets an investigation like this:
+  #
+  #   investigate "formats a badge number" do
+  #     attest(badge_number(1)).to eq("No. 1")
+  #   end
+end
+<% end -%>

data/lib/generators/constable/import_generator.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "constable"
+
+module Constable
+  module Generators
+    # `rails generate constable:import --from=rspec`
+    #
+    # A thin front door onto Constable::Importer, for people who reach for
+    # `rails generate` before `constable import`. The two are the same operation;
+    # this one exists so the install step and the import step are spelled the
+    # same way.
+    #
+    # The default strategy is "reopen": files become Constable::ColdCase::*
+    # subclasses (a superclass swap, or a zero-file-change glob in config) and run
+    # immediately, verbatim, through their own engine. Nothing is rewritten and
+    # nothing can be broken by a bad conversion. The AST rewrite into the native
+    # DSL is a separate, opt-in step -- `constable modernize PATH` -- taken one
+    # file at a time once the suite is already green under Constable.
+    class ImportGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      SOURCES    = %w[rspec minitest].freeze
+      STRATEGIES = %w[reopen modernize].freeze
+
+      desc <<~DESC
+        Imports an existing RSpec or Minitest suite as cold cases. The default "reopen"
+        strategy changes no test code: files run verbatim through their own engine, with
+        pass/fail/timing merged into Constable's reporting, flake history and CI gate.
+
+        Run with --dry-run first to see exactly which files would be touched.
+      DESC
+
+      class_option :from, type: :string, default: "rspec",
+                          desc: "Which suite to import: #{SOURCES.join(" | ")}"
+      class_option :strategy, type: :string, default: "reopen",
+                              desc: "#{STRATEGIES.join(" | ")} -- reopen is verbatim, modernize rewrites"
+      class_option :dry_run, type: :boolean, default: false,
+                             desc: "Report what would happen without writing anything"
+
+      def import
+        validate_options!
+        report(invoke_importer)
+      end
+
+      private
+
+      def validate_options!
+        unless SOURCES.include?(options[:from])
+          raise Thor::Error, "--from must be one of #{SOURCES.join(", ")} (got #{options[:from].inspect})"
+        end
+
+        return if STRATEGIES.include?(options[:strategy])
+
+        raise Thor::Error, "--strategy must be one of #{STRATEGIES.join(", ")} (got #{options[:strategy].inspect})"
+      end
+
+      def importer_arguments
+        {
+          from: options[:from].to_sym,
+          config: Constable.config,
+          dry_run: options[:dry_run],
+          strategy: options[:strategy].to_sym
+        }
+      end
+
+      # The importer is built independently of this generator, so the call site
+      # checks the contract instead of assuming it. A signature that has drifted
+      # should read as "the importer changed shape, here is how" -- not as an
+      # ArgumentError from three frames down with no indication of whose fault
+      # it is.
+      def invoke_importer
+        importer = load_importer!
+        assert_signature!(importer)
+        importer.run(**importer_arguments)
+      rescue ArgumentError => e
+        raise Thor::Error, <<~MSG.chomp
+          Constable::Importer.run rejected the arguments this generator passes
+          (#{importer_arguments.keys.map(&:inspect).join(", ")}): #{e.message}
+
+          The generator and the importer have drifted apart. Fix the call in
+          lib/generators/constable/import_generator.rb to match Importer.run.
+        MSG
+      end
+
+      def load_importer!
+        importer = Constable::Importer
+        return importer if importer.respond_to?(:run)
+
+        raise Thor::Error, "Constable::Importer does not respond to .run -- this build of the gem is incomplete."
+      rescue LoadError, NameError => e
+        raise Thor::Error, "Constable::Importer could not be loaded (#{e.class}: #{e.message})."
+      end
+
+      def assert_signature!(importer)
+        parameters = importer.method(:run).parameters
+        return if parameters.any? { |type, _| type == :keyrest } # **opts swallows anything
+
+        accepted = parameters.filter_map { |type, name| name if %i[key keyreq].include?(type) }
+        missing  = importer_arguments.keys - accepted
+        required = parameters.filter_map { |type, name| name if type == :keyreq }
+        unfilled = required - importer_arguments.keys
+
+        return if missing.empty? && unfilled.empty?
+
+        lines = ["Constable::Importer.run has a different signature than this generator expects.",
+                 "  generator passes: #{importer_arguments.keys.map(&:inspect).join(", ")}",
+                 "  importer accepts: #{accepted.map(&:inspect).join(", ")}"]
+        lines << "  not accepted:     #{missing.map(&:inspect).join(", ")}" unless missing.empty?
+        lines << "  required, unset:  #{unfilled.map(&:inspect).join(", ")}" unless unfilled.empty?
+        lines << "Fix the call in lib/generators/constable/import_generator.rb to match Importer.run."
+
+        raise Thor::Error, lines.join("\n")
+      end
+
+      # The importer owns the detail of what it did; this only makes sure the run
+      # says something, since a generator that prints nothing reads as a generator
+      # that did nothing.
+      def report(result)
+        return if options[:quiet]
+
+        say ""
+        if options[:dry_run]
+          say "  Dry run -- nothing was written.", :yellow
+        else
+          say "  Imported #{options[:from]} as cold cases (strategy: #{options[:strategy]}).", :green
+        end
+        say "  #{result}" if result.is_a?(String) && !result.empty?
+        say ""
+        say "  Every cold-case file is reported as a warning on every run -- one per file,"
+        say "  not one per test -- until it is either modernized or deliberately kept."
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/constable/install_generator.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+# Rails generator machinery is required *here*, not from lib/constable.rb.
+# `require "constable"` has to work in a process with no Rails app at all --
+# that is the entire point of the :unit tier -- so railties is only ever pulled
+# in by the two files that genuinely cannot exist without it.
+require "rails/generators/base"
+require "constable"
+
+module Constable
+  module Generators
+    # `rails generate constable:install`
+    #
+    # Writes the six things a Constable suite needs to run, and nothing else:
+    #
+    #   test/case_helper.rb          the boot file + per-tier base classes
+    #   test/support/matchers.rb     custom matcher examples
+    #   test/support/authenticatable.rb  the "shared behavior is a module" example
+    #   test/cases/example_case.rb   a worked case so `constable test` does something
+    #   .constable/config.yml        every setting, at its default, as a reference
+    #   .rubocop.yml                 the linter, merged into yours if you have one
+    #
+    # Plus the optional :cold_case Gemfile group, but only when there is actually
+    # an RSpec or Minitest suite in the repo to import. Installing the gem into a
+    # greenfield app shouldn't add two dependencies for a migration that will
+    # never happen.
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc <<~DESC
+        Sets up Constable: test/case_helper.rb with the per-tier base classes, test/support/
+        with matcher and shared-module examples, an example case, the full .constable/config.yml
+        reference, a .rubocop.yml wired to rubocop-constable, and -- only when this repo already
+        has RSpec or Minitest files to import -- the optional :cold_case Gemfile group.
+
+        --force, --pretend, --quiet and --skip come from Rails and behave as they do everywhere.
+      DESC
+
+      class_option :skip_gemfile, type: :boolean, default: false,
+                                  desc: "Don't append the optional :cold_case group to the Gemfile"
+      class_option :skip_rubocop, type: :boolean, default: false,
+                                  desc: "Don't create or modify .rubocop.yml"
+      class_option :skip_example, type: :boolean, default: false,
+                                  desc: "Don't write the example case under test/cases/"
+      class_option :skip_support, type: :boolean, default: false,
+                                  desc: "Don't write the example files under test/support/"
+
+      COLD_CASE_GROUP = <<~RUBY
+        # Cold cases: your existing RSpec/Minitest files, run verbatim through their own
+        # real engine, with results merged into Constable's reporting and CI gate. These
+        # two gems are needed only for as long as cold cases exist -- delete the group
+        # once the suite is fully modernized and both dependencies drop out with it.
+        group :cold_case do
+          gem "rspec-rails"
+          gem "minitest"
+        end
+      RUBY
+
+      RUBOCOP_EXTENSION = "rubocop-constable"
+
+      def create_case_helper
+        template "case_helper.rb.tt", "test/case_helper.rb"
+      end
+
+      def create_support_files
+        return if options[:skip_support]
+
+        template "matchers.rb.tt", "test/support/matchers.rb"
+        template "authenticatable.rb.tt", "test/support/authenticatable.rb"
+      end
+
+      def create_config
+        template "config.yml.tt", ".constable/config.yml"
+      end
+
+      def create_example_case
+        return if options[:skip_example]
+
+        template "example_case.rb.tt", "test/cases/example_case.rb"
+      end
+
+      # The :cold_case group is appended only when there is something to import,
+      # and only once no matter how many times the generator runs. Re-running an
+      # installer is normal (a new option, a regenerated helper) and must never
+      # leave a Gemfile with the same group in it twice.
+      def add_cold_case_gemfile_group
+        return if options[:skip_gemfile]
+
+        unless File.exist?(File.join(destination_root, "Gemfile"))
+          say_status :skip, "Gemfile not found -- add the :cold_case group by hand before importing", :yellow
+          return
+        end
+
+        unless legacy_suite_present?
+          say_status :skip, "Gemfile (no RSpec or Minitest files here to import as cold cases)", :blue
+          return
+        end
+
+        if gemfile_contents.match?(/^\s*group\s+:cold_case\b/)
+          say_status :identical, "Gemfile (:cold_case group already present)", :blue
+          return
+        end
+
+        append_to_file "Gemfile", "\n#{COLD_CASE_GROUP}"
+      end
+
+      # An app that already lints has opinions in .rubocop.yml worth more than
+      # ours. Merge into it; never clobber it.
+      def configure_rubocop
+        return if options[:skip_rubocop]
+
+        path = File.join(destination_root, ".rubocop.yml")
+        return template("rubocop.yml.tt", ".rubocop.yml") unless File.exist?(path)
+
+        existing = File.read(path)
+        if existing.include?(RUBOCOP_EXTENSION)
+          say_status :identical, ".rubocop.yml (already requires #{RUBOCOP_EXTENSION})", :blue
+          return
+        end
+
+        create_file ".rubocop.yml", merge_rubocop(existing), force: true
+      end
+
+      def print_next_steps
+        return if options[:quiet]
+
+        say ""
+        say "  Constable is installed.", :green
+        say ""
+        say "    constable test          run everything changed since the merge-base"
+        say "    constable test --full   run the whole suite (this is what CI does)"
+        say ""
+        say "  test/case_helper.rb is worth reading before you write a case -- it explains"
+        say "  the tier base classes, and the two things Constable deliberately doesn't have."
+        say ""
+      end
+
+      private
+
+      def gemfile_contents
+        File.read(File.join(destination_root, "Gemfile"))
+      end
+
+      # "Is there anything here to import?" -- any RSpec or Minitest file at all.
+      # Native Constable cases are named *_case.rb, so the example this generator
+      # just wrote can never be mistaken for a legacy suite.
+      def legacy_suite_present?
+        Dir.glob(File.join(destination_root, "{spec,test}/**/*_{spec,test}.rb")).any?
+      end
+
+      # A textual merge, not a YAML round trip: parsing and re-emitting someone's
+      # .rubocop.yml would silently eat every comment in it, and comments in a
+      # lint config are usually the reason a rule is there at all.
+      def merge_rubocop(existing)
+        lines = existing.lines
+
+        # `require:` heading an indented list -- append one more item to the end
+        # of it, so load order for everything already there is unchanged.
+        index = lines.index { |line| line.match?(/\Arequire:[ \t]*(#.*)?$/) }
+        if index
+          last   = index
+          indent = "  "
+          ((index + 1)...lines.length).each do |i|
+            item = lines[i].match(/\A([ \t]+)-[ \t]/)
+            break unless item || lines[i].match?(/\A[ \t]*#/)
+            next unless item
+
+            last   = i
+            indent = item[1]
+          end
+          lines.insert(last + 1, "#{indent}- #{RUBOCOP_EXTENSION}\n")
+          return lines.join
+        end
+
+        # `require: some-extension` on one line -- promote it to a list of both.
+        index = lines.index { |line| line.match?(/\Arequire:[ \t]*[^\s#]/) }
+        if index
+          current = lines[index].sub(/\Arequire:[ \t]*/, "").sub(/[ \t]*#.*\z/m, "").strip
+          lines[index] = "require:\n  - #{current}\n  - #{RUBOCOP_EXTENSION}\n"
+          return lines.join
+        end
+
+        # No `require:` at all -- append the whole snippet, existing file intact.
+        "#{existing.chomp}\n\n#{File.read(File.join(self.class.source_root, "rubocop.yml.tt"))}"
+      end
+    end
+  end
+end

data/lib/generators/constable/integration/integration_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate integration_test Checkout`, which hooks :integration_tool
+    # as :integration -- so the command Rails calls integration_test resolves to a
+    # generator that has to be called IntegrationGenerator.
+    #
+    #   test/cases/controllers/checkout_case.rb   class CheckoutCase < IntegrationCase
+    #
+    # It lands under test/cases/controllers because that is the directory the `tiers:`
+    # globs in Constable::Config::DEFAULTS map to :integration. A request case is exactly
+    # what that directory is for -- driving the real stack from the outside, which is the
+    # level Constable's own spec example works at.
+    class IntegrationGenerator < Base
+      check_class_collision suffix: "Case"
+
+      strips_suffix(/_test\z/i)
+
+      def create_case_file
+        template "request_case.rb.tt", case_path("controllers", class_path, "#{file_name}_case.rb")
+      end
+    end
+  end
+end

data/lib/generators/constable/integration/templates/request_case.rb.tt

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>Case < IntegrationCase
+  # A request case drives the whole stack from the outside -- routes, middleware,
+  # controller, view -- which is why it is :integration tier and gets a transaction rolled
+  # back around every investigation.
+  #
+  # The generator does not know which route this covers. Once you do, it reads like this:
+  #
+  #   witness(:<%= singular_name %>) { <%= class_name.singularize %>.create!(name: "MyString") }
+  #
+  #   investigate "GET /<%= plural_file_name %> lists every <%= singular_name %>" do
+  #     get <%= plural_file_name %>_url
+  #
+  #     attest(response).to have_http_status(:ok)
+  #     attest(response.body).to include(<%= singular_name %>.name)
+  #   end
+end
+<% end -%>

data/lib/generators/constable/job/job_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate job CleanUp`.
+    #
+    #   test/cases/jobs/clean_up_job_case.rb   class CleanUpJobCase < IntegrationCase
+    class JobGenerator < Base
+      check_class_collision suffix: "JobCase"
+
+      strips_suffix(/_job\z/i)
+
+      def create_case_file
+        template "job_case.rb.tt", case_path("jobs", class_path, "#{file_name}_job_case.rb")
+      end
+    end
+  end
+end

data/lib/generators/constable/job/templates/job_case.rb.tt

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>JobCase < IntegrationCase
+  # `rails generate job <%= name %>` writes an empty #perform, so there is nothing to
+  # assert on yet. When there is, a job has two halves worth testing and they are two
+  # different investigations.
+  #
+  # What perform actually does -- run it directly, assert on the effect:
+  #
+  #   investigate "marks the record as processed" do
+  #     record = <%= class_name %>.create!
+  #
+  #     <%= class_name %>Job.perform_now(record)
+  #
+  #     attest(record.reload).to be_processed
+  #   end
+  #
+  # That it gets enqueued at all -- this one needs ActiveJob's test adapter, which is a
+  # line in the IntegrationCase base class in test/case_helper.rb (or here, if only jobs
+  # want it):
+  #
+  #   include ActiveJob::TestHelper
+  #
+  #   investigate "goes on the queue it declares" do
+  #     assert_difference("enqueued_jobs.size", 1) do
+  #       <%= class_name %>Job.perform_later
+  #     end
+  #   end
+end
+<% end -%>

data/lib/generators/constable/mailbox/mailbox_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate mailbox Forwards`.
+    #
+    #   test/cases/mailboxes/forwards_mailbox_case.rb   class ForwardsMailboxCase < IntegrationCase
+    class MailboxGenerator < Base
+      check_class_collision suffix: "MailboxCase"
+
+      strips_suffix(/_mailbox\z/i)
+
+      def create_case_file
+        template "mailbox_case.rb.tt", case_path("mailboxes", class_path, "#{file_name}_mailbox_case.rb")
+      end
+    end
+  end
+end

data/lib/generators/constable/mailbox/templates/mailbox_case.rb.tt

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>MailboxCase < IntegrationCase
+  # ActionMailbox's helpers for building an inbound email are a plain module, so they
+  # compose into a case like any other shared behavior. One line, here or in the
+  # IntegrationCase base class in test/case_helper.rb:
+  #
+  #   include ActionMailbox::TestHelper
+  #
+  # Then the investigation worth writing is about what the mailbox did with the message,
+  # not that it received one:
+  #
+  #   witness(:inbound) do
+  #     create_inbound_email_from_mail(to: "<%= file_name %>@example.com", subject: "Hello")
+  #   end
+  #
+  #   investigate "files the message against its sender" do
+  #     inbound.route
+  #
+  #     attest(inbound.reload).to be_delivered
+  #   end
+end
+<% end -%>

data/lib/generators/constable/mailer/mailer_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "generators/constable/base"
+
+module Constable
+  module Generators
+    # Invoked by `rails generate mailer Notifier welcome`.
+    #
+    #   test/cases/mailers/notifier_mailer_case.rb        class NotifierMailerCase < IntegrationCase
+    #   test/mailers/previews/notifier_mailer_preview.rb  the /rails/mailers preview
+    class MailerGenerator < Base
+      argument :actions, type: :array, default: [], banner: "method method"
+
+      strips_suffix(/_mailer\z/i)
+
+      def check_class_collision
+        class_collisions "#{class_name}MailerCase", "#{class_name}MailerPreview"
+      end
+
+      def create_case_file
+        template "mailer_case.rb.tt", case_path("mailers", class_path, "#{file_name}_mailer_case.rb")
+      end
+
+      # A preview is a development tool, not a case, and ActionMailer looks for it under
+      # test/mailers/previews by default. Moving it somewhere more Constable-shaped would
+      # buy nothing and break /rails/mailers, so it stays exactly where Rails put it.
+      def create_preview_file
+        template "preview.rb.tt", File.join("test/mailers/previews", class_path, "#{file_name}_mailer_preview.rb")
+      end
+    end
+  end
+end

data/lib/generators/constable/mailer/templates/mailer_case.rb.tt

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "case_helper"
+
+<% module_namespacing do -%>
+class <%= class_name %>MailerCase < IntegrationCase
+<% if actions.empty? -%>
+  # `rails generate mailer <%= name %>` ran with no methods, so there is nothing to send
+  # yet. When there is, an investigation reads like this:
+  #
+  #   investigate "welcome" do
+  #     mail = <%= class_name %>Mailer.welcome
+  #
+  #     attest(mail.subject).to eq("Welcome")
+  #     attest(mail.to).to eq(["to@example.org"])
+  #     attest(mail.body.encoded).to include("Hi")
+  #   end
+<% else -%>
+  # Rails wrote these headers into the generated views; they are placeholders and every
+  # one of these assertions is meant to be rewritten as the mailer becomes real.
+<% actions.each_with_index do |action, index| -%>
+<%= "\n" unless index.zero? -%>
+  investigate "<%= action %>" do
+    mail = <%= class_name %>Mailer.<%= action %>
+
+    attest(mail.subject).to eq(<%= action.to_s.humanize.inspect %>)
+    attest(mail.to).to eq(["to@example.org"])
+    attest(mail.from).to eq(["from@example.com"])
+    attest(mail.body.encoded).to include("Hi")
+  end
+<% end -%>
+<% end -%>
+end
+<% end -%>

data/lib/generators/constable/mailer/templates/preview.rb.tt

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+# Preview all emails at http://localhost:3000/rails/mailers/<%= file_path %>_mailer
+class <%= class_name %>MailerPreview < ActionMailer::Preview
+<% actions.each_with_index do |action, index| -%>
+<%= "\n" unless index.zero? -%>
+  # Preview this email at http://localhost:3000/rails/mailers/<%= file_path %>_mailer/<%= action %>
+  def <%= action %>
+    <%= class_name %>Mailer.<%= action %>
+  end
+<% end -%>
+end
+<% end -%>