phlex-hanami 0.2.0.pre.alpha.1 → 0.2.0.pre.alpha.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d51a4710b34ce6bb8d1a140f7df3fdae00006df8fd23b39c84506297e12f64df
-  data.tar.gz: 18954a7148a4d46c0b3053dadc7ccd534a25c9276eabe317f01274d9a4ce377a
+  metadata.gz: eb2ded5cb201e8636daeba76f21fc25b297899eba517ce428d6fcc41450460f9
+  data.tar.gz: f8935646735d5d5e52faf6c48b5713dae2f4169c02e8162fc4356c32e5cf09bd
 SHA512:
-  metadata.gz: c3a536625ff7017b56129fd4f151d194240e9dfa4427d3f4d774cb1bb68ef3fd61dd069f7f7b7eef347e90f2339b9596da0ce737df90f1451c6ae81096186b3a
-  data.tar.gz: 178cedf68bfaed0844171fbfd6a935b9c931901f296c59ba922e957ba7caabf825bbd052bf3ce384255df4df7f90a4aa7108ed5d60e08d3102c8d646e4d64b87
+  metadata.gz: 396360b1808f053b39c29047103c6f860c46ac6bf436890a483848c63639c1e382fc0ad34eefb61f58335a4d158783349670c2b0ee30a421473737c5111e2abf
+  data.tar.gz: 84fbc91b5c45c6ece40da01070cd64bd9b2702cbc19c10c1ba8eeb3d27cc7aab57e3e60434305b18021dc980cc0a1fff983a051d5cce33b09b200fd87667db52

data/CHANGELOG.md

@@ -7,7 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [v0.2.0-alpha.1] - 2024-10-05
+## [v0.2.0-alpha.2] - 2026-09-05
+
+### Added
+
+- Phlex views for [hanami-mailer]. A mailer renders the Phlex class whose container key matches its own, so
+  `MyApp::Mailers::Welcome` renders `MyApp::Views::Mailers::Welcome` with no configuration.
+- `Phlex::Hanami::Mailer::View` and `Phlex::Hanami::Mailer::Layout`, and `Phlex::Hanami::Mailer::Renderable` for an
+  existing `Phlex::HTML` base class.
+- A plain text alternative part, converted from the rendered HTML by `Phlex::Hanami::Mailer::Text`. Override
+  `text_body` on the view to write it by hand.
+- A mail layout convention: `Views::Mailers::Layout` in a slice wraps that slice's mail views.
+- Usage documentation under [docs/usage](docs/usage/README.md), covering views, layouts, the view context,
+  helpers, mailers and how the gem hooks into Hanami.
+- `Phlex::Hanami::MailerViewError`, raised when a mailer is paired with a Phlex view that is not a mail view,
+  rather than sending a message whose plain text part is markup.
+
+### Changed
+
+- `url` in a view returns a String. Hanami's routes helper returns a `URI`, which Phlex rejects as an attribute
+  value, so `a(href: url(:posts))` raised.
+
+### Fixed
+
+- `path` in a mail view raises `Phlex::Hanami::RelativePathError` instead of writing a relative link an email client
+  cannot follow.
+
+[hanami-mailer]: https://github.com/hanami/mailer
+
+## [v0.2.0-alpha.1] - 2026-09-04
 
 Initial alpha release by the new maintainer [@aaronmallen](https://github.com/aaronmallen).
 
@@ -15,5 +43,7 @@ Initial alpha release by the new maintainer [@aaronmallen](https://github.com/aa
 
 Initial release, by the previous maintainer [@stephannv](https://github.com/stephannv).
 
-[Unreleased]: https://github.com/aaronmallen/phlex-hanami/compare/0.1.0...HEAD
+[Unreleased]: https://github.com/aaronmallen/phlex-hanami/compare/0.2.0-alpha.2...HEAD
+[v0.2.0-alpha.2]: https://github.com/aaronmallen/phlex-hanami/compare/0.2.0-alpha.1...0.2.0-alpha.2
+[v0.2.0-alpha.1]: https://github.com/aaronmallen/phlex-hanami/releases/tag/0.2.0-alpha.1
 [v0.1.0]: https://github.com/stephannv/phlex-hanami/releases/tag/v0.1.0

data/lib/phlex/hanami/errors/mailer_view_error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Hanami
+    # Raised when a mailer's paired Phlex view cannot render a mail message.
+    #
+    # A mailer asks its view for two parts, and an ordinary view answers both with markup — which
+    # would ship an email whose plain text part is HTML. Better to say so than to send it.
+    #
+    # @api public
+    # @since 0.2.0
+    class MailerViewError < Error
+      # @api private
+      # @since 0.2.0
+      def initialize(mailer_class, view_class)
+        super(<<~MESSAGE)
+          #{mailer_class} is paired with #{view_class}, which is not a mail view.
+
+          A mail view renders both parts of the message. Subclass the mail base class:
+
+            class #{view_class} < Phlex::Hanami::Mailer::View
+
+          or include the module into the base class you already have:
+
+            include Phlex::Hanami::Mailer::Renderable
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/phlex/hanami/errors/relative_path_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Hanami
+    # Raised when a mail view asks for a relative path.
+    #
+    # An email is read outside the app, so a relative path in one is a dead link. Mail views raise
+    # rather than render one.
+    #
+    # @api public
+    # @since 0.2.0
+    class RelativePathError < Error
+      # @api private
+      # @since 0.2.0
+      def initialize(view_class)
+        super(<<~MESSAGE)
+          #{view_class} asked for a relative path, and an email needs a full URL.
+
+          Use `url` instead:
+
+            a(href: url(:post, id: @post.id)) { @post.title }
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/phlex/hanami/extensions/mailer.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Hanami
+    module Extensions
+      # Pairs a Hanami mailer with a Phlex view.
+      #
+      # Prepended onto `Hanami::Mailer`, so it sits in front of hanami-mailer's own view handling
+      # and answers first. A mailer's view is any object taking `call(format:, **input)`, which a
+      # {Phlex::Hanami::Mailer::View} already is, so pairing is the whole of the integration:
+      # nothing here teaches hanami-mailer what Phlex is.
+      #
+      # @api private
+      # @since 0.2.0
+      module Mailer
+        # Prepends this onto `Hanami::Mailer`.
+        #
+        # Called from `phlex/hanami.rb` when hanami-mailer is bundled. Zeitwerk keeps the mail
+        # classes unloaded until something names one, but a prepend needs the constant, so the
+        # check belongs at the call site.
+        #
+        # @api private
+        # @since 0.2.0
+        def self.install
+          ::Hanami::Mailer.prepend(self)
+          ::Hanami::Mailer.singleton_class.prepend(ClassMethods)
+        end
+
+        # @api private
+        # @since 0.2.0
+        module ClassMethods
+          # @api private
+          # @since 0.2.0
+          def configure_for_slice(slice)
+            super
+            extend SliceConfigured.new(slice)
+          end
+
+          # The mailer's paired Phlex view, or nil when it has none.
+          #
+          # The key is derived the way hanami-mailer derives a template name: underscore the class
+          # name and drop the slice's own segment, so `MyApp::Mailers::Welcome` looks up
+          # `views.mailers.welcome`. Resolved through the container on every call rather than
+          # memoized, so code reloading is not defeated.
+          #
+          # @return [Class, nil]
+          #
+          # @raise [MailerViewError] when the paired view is a Phlex class that cannot render mail
+          #
+          # @api private
+          # @since 0.2.0
+          def phlex_view
+            mailer_slice = slice
+            return nil unless mailer_slice && name
+
+            key = "views.#{view_name(mailer_slice)}"
+            return nil unless mailer_slice.key?(key)
+
+            view = mailer_slice[key]
+            return nil unless view.is_a?(::Class) && view < ::Phlex::SGML
+            raise MailerViewError.new(self, view) unless view < ::Phlex::Hanami::Mailer::Renderable
+
+            view
+          end
+
+          # The slice this mailer belongs to, or nil when it is defined outside a slice namespace.
+          #
+          # @return [Hanami::Slice, nil]
+          #
+          # @api private
+          # @since 0.2.0
+          def slice
+            nil
+          end
+
+          private
+
+          def view_name(mailer_slice)
+            mailer_slice.inflector
+              .underscore(name)
+              .sub(%r{^#{mailer_slice.slice_name.path}/}, "")
+              .tr("/", ".")
+          end
+        end
+
+        # The view this mailer renders.
+        #
+        # A view passed to the constructor wins, then the paired Phlex view, then whatever
+        # hanami-mailer would have used on its own — so an app can render some of its mail with
+        # Phlex and the rest with templates.
+        #
+        # @return [Object, nil]
+        #
+        # @api private
+        # @since 0.2.0
+        def view
+          @view || self.class.phlex_view || super
+        end
+      end
+    end
+  end
+end

data/lib/phlex/hanami/extensions/slice.rb

@@ -53,7 +53,9 @@ module Phlex
           # Defines `Views::Context` for the slice when nothing else has.
           #
           # Does nothing when hanami-view is bundled, because Hanami defines its own richer context
-          # there, and nothing when the user has defined one themselves.
+          # there, and returns the existing one when the user has defined it themselves.
+          #
+          # @return [Class, nil] the slice's context class
           #
           # @api private
           # @since 0.2.0
@@ -61,7 +63,7 @@ module Phlex
             return if ::Hanami.bundled?("hanami-view")
 
             namespace = views_namespace(slice)
-            return if namespace.const_defined?(:Context, false)
+            return namespace.const_get(:Context, false) if namespace.const_defined?(:Context, false)
 
             # The class is anonymous at this point, so the slice cannot be inferred from its name
             # the way `Hanami::SliceConfigurable` would; configure it explicitly instead.
@@ -83,6 +85,22 @@ module Phlex
             component_dirs.instance = COMPONENT_INSTANCE
           end
 
+          # The class an action's view context is built from, for anything rendering outside a
+          # request that needs the same one.
+          #
+          # Reads the third-party slot `Hanami::Extensions::Action::SliceConfiguredAction` reads,
+          # so a mail view and a request view are given the same class.
+          #
+          # @return [Class]
+          #
+          # @api private
+          # @since 0.2.0
+          def view_context_class(slice)
+            return ::Hanami::Extensions::View::Context.context_class(slice) if ::Hanami.bundled?("hanami-view")
+
+            define_view_context(slice)
+          end
+
           private
 
           def views_namespace(slice)

data/lib/phlex/hanami/mailer/layout.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Hanami
+    module Mailer
+      # The base class for mail layouts.
+      #
+      # Name one `Views::Mailers::Layout` in a slice's namespace and every mail view in that slice
+      # renders inside it. The web layout is never used for mail; set a different one with `layout`,
+      # or opt out with `layout nil`.
+      #
+      # The layout is part of both message parts: the text part is converted from the HTML the
+      # layout produced, so a footer written once appears in both.
+      #
+      # @example
+      #   # app/views/mailers/layout.rb
+      #   module MyApp
+      #     module Views
+      #       module Mailers
+      #         class Layout < Phlex::Hanami::Mailer::Layout
+      #           def view_template
+      #             html do
+      #               body do
+      #                 yield
+      #                 p { "Sent by MyApp" }
+      #               end
+      #             end
+      #           end
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # @api public
+      # @since 0.2.0
+      class Layout < Phlex::HTML
+        include Renderable
+
+        # A layout is never itself wrapped in a layout.
+        layout nil
+      end
+    end
+  end
+end

data/lib/phlex/hanami/mailer/renderable.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Hanami
+    module Mailer
+      # Makes a Phlex class renderable by a Hanami mailer.
+      #
+      # Include this into an existing `Phlex::SGML` subclass, or subclass {View}, which includes it
+      # already. It builds on {Phlex::Hanami::Renderable} and adds the three things mail needs: a
+      # context with no request behind it, a second format for the plain text part, and a layout
+      # convention of its own.
+      #
+      # @example
+      #   module MyApp
+      #     class MailerView < Phlex::HTML
+      #       include Phlex::Hanami::Mailer::Renderable
+      #     end
+      #   end
+      #
+      # @api public
+      # @since 0.2.0
+      module Renderable
+        # @api private
+        # @since 0.2.0
+        def self.included(view_class)
+          view_class.include(::Phlex::Hanami::Renderable)
+
+          # Order matters: a module included later sits higher in the lookup chain, so the mail
+          # methods have to go in after `Renderable`, not alongside them in this module.
+          view_class.include(MailMethods)
+          view_class.extend(ClassMethods)
+        end
+
+        # @api public
+        # @since 0.2.0
+        module ClassMethods
+          # Renders one part of a mail message.
+          #
+          # This is what `Hanami::Mailer#render_view` calls, once per part, with the format naming
+          # the part it wants. Hanami's mailer has no view context to hand over — there is no
+          # request to build one from — so a mail view builds the slice's own context itself.
+          #
+          # @param context [Object, nil] the Hanami view context, built from the slice when omitted
+          # @param format [Symbol] `:html` or `:text`
+          # @param input [Hash] the mailer's exposures
+          #
+          # @return [String] the rendered part
+          #
+          # @api public
+          # @since 0.2.0
+          def call(context: nil, format: :html, **input)
+            html = super(context: context || mail_context, **input)
+            return html unless format.to_s == "text"
+
+            new(**accepted_input(input)).text_body(html)
+          end
+
+          private
+
+          # A slice's conventional mail layout: `Views::Mailers::Layout`, if it defines one.
+          #
+          # The web layout is the wrong one for an email — it carries the stylesheets, scripts and
+          # page chrome no mail client wants — so mail looks for its own, and renders without a
+          # layout when the slice has none.
+          def default_layout
+            return nil unless slice
+            return nil unless slice.namespace.const_defined?(:Views, false)
+
+            views = slice.namespace.const_get(:Views, false)
+            return nil unless views.const_defined?(:Mailers, false)
+
+            mailers = views.const_get(:Mailers, false)
+            mailers.const_get(:Layout, false) if mailers.const_defined?(:Layout, false)
+          end
+
+          # The slice's view context, built without a request.
+          #
+          # The same class an action would be given, so a view reads the same in both places. What
+          # a request would have filled in — `request`, `session`, `flash`, `csrf_token` — is
+          # missing, and the context says so when a view reaches for it.
+          def mail_context
+            return nil unless slice
+
+            Extensions::Slice.view_context_class(slice).new
+          end
+        end
+
+        # What a mail view does differently.
+        #
+        # Included after `Phlex::Hanami::Renderable` so that it wins: a module included later sits
+        # higher in the lookup chain.
+        #
+        # @api private
+        # @since 0.2.0
+        module MailMethods
+          # Raises. An email is read outside the app, so a link in one needs a full URL.
+          #
+          # @raise [RelativePathError]
+          #
+          # @api public
+          # @since 0.2.0
+          def path(*, **)
+            raise RelativePathError, self.class
+          end
+
+          # The plain text part of the message.
+          #
+          # Called with the rendered HTML, layout and all, and converts it by default. Override it
+          # to write the text part by hand; the view's own state is there to read.
+          #
+          # @example
+          #   def text_body(_html)
+          #     "Welcome, #{@user.name}. Get started: #{url(:root)}"
+          #   end
+          #
+          # @param html [String] the rendered HTML part
+          #
+          # @return [String] the text part
+          #
+          # @api public
+          # @since 0.2.0
+          def text_body(html)
+            Text.call(html)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlex/hanami/mailer/text.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Hanami
+    module Mailer
+      # Turns the HTML part of a message into its plain text alternative.
+      #
+      # This is regex over markup Phlex has just produced, not a general HTML parser. It knows the
+      # handful of things that matter in an email — anchors, lists, line breaks, block elements and
+      # the entities Phlex escapes — and leaves everything else on the floor. Markup from somewhere
+      # else, pasted into a view with `raw`, may not come out well.
+      #
+      # {Renderable#text_body} calls this. Override that method to write the text part by hand.
+      #
+      # @api public
+      # @since 0.2.0
+      class Text
+        # Elements that end a line of text, and so become a blank line.
+        #
+        # @api private
+        # @since 0.2.0
+        BLOCK_ELEMENTS = %w[
+          article blockquote div footer h1 h2 h3 h4 h5 h6 header hr li ol p section table td tr ul
+        ].freeze
+
+        # @api private
+        # @since 0.2.0
+        BLOCK_PATTERN = %r{</?(?:#{BLOCK_ELEMENTS.join('|')})\b[^>]*>}i
+
+        # The entities Phlex escapes, and the characters they stand for.
+        #
+        # @api private
+        # @since 0.2.0
+        ENTITIES = {
+          "&#39;" => "'",
+          "&amp;" => "&",
+          "&apos;" => "'",
+          "&gt;" => ">",
+          "&lt;" => "<",
+          "&nbsp;" => " ",
+          "&quot;" => '"',
+        }.freeze
+
+        # @api private
+        # @since 0.2.0
+        ENTITY_PATTERN = /&(?:amp|apos|gt|lt|nbsp|quot|#39);/
+
+        # Stand in for the angle brackets around a URL until the tags are gone, so that stripping
+        # tags does not eat the link the converter has just written.
+        #
+        # @api private
+        # @since 0.2.0
+        LINK_CLOSE = "\u0011"
+
+        # @api private
+        # @since 0.2.0
+        LINK_OPEN = "\u0010"
+
+        class << self
+          # Converts rendered HTML to plain text.
+          #
+          # @param html [String] the rendered HTML part
+          #
+          # @return [String] the text part
+          #
+          # @api public
+          # @since 0.2.0
+          def call(html)
+            text = body_of(html.to_s)
+            text = strip_hidden_elements(text)
+            text = expand_anchors(text)
+            text = expand_breaks(text)
+            text = expand_list_items(text)
+            text = expand_blocks(text)
+            text = strip_tags(text)
+            text = unescape(text)
+            restore_links(tidy(text))
+          end
+
+          private
+
+          # `Label <https://example.com/path>`, or one of the two when the other adds nothing.
+          def anchor_text(attributes, inner)
+            url = href_in(attributes)
+            label = strip_tags(inner).gsub(/\s+/, " ").strip
+            return label if url.empty?
+            return url if label.empty? || label == url
+
+            "#{label} #{LINK_OPEN}#{url}#{LINK_CLOSE}"
+          end
+
+          def body_of(html) = html[%r{<body\b[^>]*>(.*?)</body>}mi, 1] || html
+
+          def expand_anchors(html)
+            html.gsub(%r{<a\b([^>]*)>(.*?)</a>}mi) { anchor_text(Regexp.last_match(1), Regexp.last_match(2)) }
+          end
+
+          def expand_blocks(html) = html.gsub(BLOCK_PATTERN, "\n\n")
+
+          def expand_breaks(html) = html.gsub(%r{<br\b[^>]*/?>}i, "\n")
+
+          def expand_list_items(html) = html.gsub(%r{</li\s*>}i, "").gsub(/<li\b[^>]*>/i, "\n- ")
+
+          def href_in(attributes)
+            match = attributes.match(/\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i)
+            return "" unless match
+
+            (match[1] || match[2] || match[3]).to_s.strip
+          end
+
+          def restore_links(text) = text.gsub(LINK_OPEN, "<").gsub(LINK_CLOSE, ">")
+
+          def strip_hidden_elements(html) = html.gsub(%r{<(head|style|script)\b[^>]*>.*?</\1\s*>}mi, "")
+
+          def strip_tags(html) = html.gsub(/<!--.*?-->/m, "").gsub(/<[^>]*>/, "")
+
+          def tidy(text) = text.gsub(/[ \t]+/, " ").gsub(/[ \t]+$/, "").gsub(/\n{3,}/, "\n\n").strip
+
+          def unescape(text) = text.gsub(ENTITY_PATTERN) { ENTITIES.fetch(Regexp.last_match(0)) }
+        end
+      end
+    end
+  end
+end

data/lib/phlex/hanami/mailer/view.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Hanami
+    module Mailer
+      # The base class for Phlex views rendered by a Hanami mailer.
+      #
+      # Subclass this for a mail view, or for an app-level base mail view. If you already have your
+      # own `Phlex::HTML` base class, include {Renderable} into it instead — the two are equivalent.
+      #
+      # A mailer finds its view by name, the way an action does: `MyApp::Mailers::Welcome` renders
+      # `MyApp::Views::Mailers::Welcome`.
+      #
+      # @example
+      #   # app/views/mailers/welcome.rb
+      #   module MyApp
+      #     module Views
+      #       module Mailers
+      #         class Welcome < Phlex::Hanami::Mailer::View
+      #           def initialize(user:) = @user = user
+      #
+      #           def view_template
+      #             h1 { "Welcome, #{@user.name}" }
+      #             p { a(href: url(:root)) { "Get started" } }
+      #           end
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # @api public
+      # @since 0.2.0
+      class View < Phlex::HTML
+        include Renderable
+      end
+    end
+  end
+end

data/lib/phlex/hanami/mailer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Hanami
+    # Phlex views for hanami-mailer.
+    #
+    # A mailer renders the same view twice, once for each part of the message, so a mail view
+    # answers to a format: {Mailer::View} renders markup for the HTML part and converts that markup
+    # for the text part. Everything else a view can do it can do too, except the parts of the
+    # context that only exist during a request.
+    #
+    # @example
+    #   # app/mailers/welcome.rb
+    #   module MyApp
+    #     module Mailers
+    #       class Welcome < Hanami::Mailer
+    #         from "hello@example.com"
+    #         to { |user| user.email }
+    #         subject "Welcome"
+    #
+    #         expose :user
+    #       end
+    #     end
+    #   end
+    #
+    #   # app/views/mailers/welcome.rb
+    #   module MyApp
+    #     module Views
+    #       module Mailers
+    #         class Welcome < Phlex::Hanami::Mailer::View
+    #           def initialize(user:) = @user = user
+    #
+    #           def view_template
+    #             h1 { "Welcome, #{@user.name}" }
+    #             p { a(href: url(:root)) { "Get started" } }
+    #           end
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    # @api public
+    # @since 0.2.0
+    module Mailer
+    end
+  end
+end

data/lib/phlex/hanami/renderable.rb

@@ -124,7 +124,7 @@ module Phlex
         # @api private
         # @since 0.2.0
         def configure_for_slice(slice)
-          extend SliceConfiguredView.new(slice)
+          extend SliceConfigured.new(slice)
         end
 
         # The layout configured on this class, or inherited from a superclass. {UNSET} when none has
@@ -354,12 +354,18 @@ module Phlex
 
       # The full URL for a named route.
       #
+      # Hanami's routes helper returns a `URI`; Phlex writes strings, and rejects anything else as
+      # an attribute value, so this hands back the string.
+      #
+      # @example
+      #   a(href: url(:posts)) { "Posts" }
+      #
       # @return [String]
       #
       # @api public
       # @since 0.2.0
       def url(...)
-        routes.url(...)
+        routes.url(...).to_s
       end
 
       private

data/lib/phlex/hanami/{slice_configured_view.rb → slice_configured.rb}

@@ -2,15 +2,15 @@
 
 module Phlex
   module Hanami
-    # Provides slice-specific configuration to a {Renderable} view defined in a slice's namespace.
+    # Tells a class which slice it belongs to.
     #
-    # `Hanami::SliceConfigurable` calls `configure_for_slice` once per slice as views are defined,
-    # so a view in the app namespace is configured for the app and one in a slice namespace is
-    # configured for that slice.
+    # `Hanami::SliceConfigurable` calls `configure_for_slice` once per slice as classes are defined,
+    # so a class in the app namespace is configured for the app and one in a slice namespace is
+    # configured for that slice. {Renderable} views and Hanami mailers both extend one of these.
     #
     # @api private
     # @since 0.2.0
-    class SliceConfiguredView < Module
+    class SliceConfigured < Module
       # The slice this module configures for.
       #
       # @return [Hanami::Slice]
@@ -28,7 +28,7 @@ module Phlex
 
       # @api private
       # @since 0.2.0
-      def extended(_view_class)
+      def extended(_klass)
         define_slice
       end
 

data/lib/phlex/hanami.rb

@@ -42,3 +42,7 @@ end.setup
 # Installs the integration. Referencing the constant is what autoloads it, so this cannot move into
 # the file itself — nothing else would ever refer to it.
 Hanami::Slice::ClassMethods.prepend(Phlex::Hanami::Extensions::Slice)
+
+# Mail is a second entry point, and an optional one. Zeitwerk keeps the mail classes unloaded until
+# something names one, but prepending onto `Hanami::Mailer` needs the constant to exist.
+Phlex::Hanami::Extensions::Mailer.install if Hanami.bundled?("hanami-mailer")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-hanami
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre.alpha.1
+  version: 0.2.0.pre.alpha.2
 platform: ruby
 authors:
 - Aaron Allen
@@ -66,13 +66,21 @@ files:
 - lib/phlex/hanami.rb
 - lib/phlex/hanami/context.rb
 - lib/phlex/hanami/errors/error.rb
+- lib/phlex/hanami/errors/mailer_view_error.rb
 - lib/phlex/hanami/errors/missing_context_error.rb
+- lib/phlex/hanami/errors/relative_path_error.rb
+- lib/phlex/hanami/extensions/mailer.rb
 - lib/phlex/hanami/extensions/slice.rb
 - lib/phlex/hanami/helpers.rb
 - lib/phlex/hanami/layout.rb
+- lib/phlex/hanami/mailer.rb
+- lib/phlex/hanami/mailer/layout.rb
+- lib/phlex/hanami/mailer/renderable.rb
+- lib/phlex/hanami/mailer/text.rb
+- lib/phlex/hanami/mailer/view.rb
 - lib/phlex/hanami/renderable.rb
+- lib/phlex/hanami/slice_configured.rb
 - lib/phlex/hanami/slice_configured_context.rb
-- lib/phlex/hanami/slice_configured_view.rb
 - lib/phlex/hanami/view.rb
 - sig/phlex-hanami.rbs
 homepage: https://github.com/aaronmallen/phlex-hanami