phlex-hanami 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 301d34d14bd2989ab0ab899fd6f76e38b5a8e8b1a3fcffa182f6ece292652e81
-  data.tar.gz: 74e00aebe59f62800ad37bd576ab97f71efbfbabb536d5fa115e8b2ce5789509
+  metadata.gz: af266b5dd1d9a3b34563f84a472fe71d4e49cd1d2ea4e64982c61631bed12730
+  data.tar.gz: 88d3d2d0fa2aae7942f8d1d6c11386dcc06d7cae3ad7a8cff0de4647e0addbe2
 SHA512:
-  metadata.gz: 84d0aec75d54b2e1e7be95d57c9d2c7e9afb560abd4ec7b86065136618775988a33776da0195c71222f9921c628c7b3b6168ca8cc84710f8a18709114210d6a6
-  data.tar.gz: 8ab7a57fac797d8daa565d6335ed9efbe2b1cfde7c0f67f30ab98a5c8c01341ee6a2b46ebb0eced44807084080fc6f5d73bec15914f16780163143f4b1b13cc3
+  metadata.gz: 74cef7af6b2d42741c0d900c1772c3cf8a58a07ed3a5eac60fb4e8a1da72b57b0ba3a613f3be2bba92db3aa35fd3c93b914b222b724384edfc7c1843d42c2d90
+  data.tar.gz: 0e9b852908aa28e2f236637093642ad2d4b8f22c4e6a9711fea40d7f7789e406a3aacb85c9fc0109d2d19a7a217e3951a34f6e8823c6db5172d9e14ebe7c4931

data/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [v0.3.0] - 2026-10-07
+
+### Changed
+
+- A view's `routes`, `path` and `url` now use the app's routes, even in a slice with a routes file of its own. That
+  slice's own routes knew only its own names and dropped the prefix it is mounted at, so `path(:posts)` in a slice
+  mounted at `/blog` gave `"/posts"`. A view now names the route the way an action does: `path(:blog_posts)` gives
+  `"/blog/posts"`. Slices mounted at `"/"` keep their names. With hanami-view bundled, Hanami builds the context, so
+  the fix comes with Hanami's next release. ([#7](https://github.com/aaronmallen/phlex-hanami/issues/7))
+
+### Fixed
+
+- Mail views and layouts follow `config.actions.view_name_inference_base`. A slice that sets it to `"ui.views"` now
+  finds `ui.views.mailers.welcome`, `ui.views.layout` and `ui.views.mailers.layout`, where before it looked only
+  under `views`. ([#6](https://github.com/aaronmallen/phlex-hanami/issues/6))
+
+## [v0.2.2] - 2026-09-26
+
+### Added
+
+- A kind for `prop` in `Phlex::Hanami::Props`, as its third argument: `:positional`, `:*` for the leftover
+  positional arguments as an Array, or `:**` for the leftover keywords as a Hash. A component can now take
+  `prop :attributes, Types::Hash, :**` and pass HTML attributes through to its tag. A view with a `:**` prop receives
+  every exposure and request param.
+- `prop?`, for a prop the caller can leave out. When they do, it holds `Phlex::Hanami::Props::UNSET` rather than
+  `nil`, so a form can use the session's CSRF token by default and none when passed `token: nil`.
+- A block on `prop`, which runs on the new instance and coerces the value before the type sees it.
+- `reader:`, `writer:` and `predicate:` options on `prop`, each taking `:public`, `:protected` or `:private`. The
+  writer checks the value against the type.
+- `after_initialize`, which a class can define to run once every prop is set.
+
+### Changed
+
+- A prop whose type accepts `nil`, such as `Types::String.optional` or `NilClass`, is now optional and `nil` when
+  left out. It used to be required.
+- A default proc now runs on the new instance rather than on its own, so it can read the props declared above it. A
+  proc that relied on `self` being the class it was written in needs to change.
+
 ## [v0.2.1] - 2026-09-26
 
 ### Added
@@ -108,7 +146,10 @@ 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.2.0...HEAD
+[Unreleased]: https://github.com/aaronmallen/phlex-hanami/compare/0.3.0...HEAD
+[v0.3.0]: https://github.com/aaronmallen/phlex-hanami/compare/0.2.2...0.3.0
+[v0.2.2]: https://github.com/aaronmallen/phlex-hanami/compare/0.2.1...0.2.2
+[v0.2.1]: https://github.com/aaronmallen/phlex-hanami/compare/0.2.0...0.2.1
 [v0.2.0]: https://github.com/aaronmallen/phlex-hanami/compare/0.2.0-alpha.3...0.2.0
 [v0.2.0-alpha.3]: https://github.com/aaronmallen/phlex-hanami/compare/0.2.0-alpha.2...0.2.0-alpha.3
 [v0.2.0-alpha.2]: https://github.com/aaronmallen/phlex-hanami/compare/0.2.0-alpha.1...0.2.0-alpha.2

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

@@ -7,10 +7,10 @@ module Phlex
     # The type's own error, when there is one, is kept as the `cause`.
     #
     # @api public
-    # @since 0.3.0
+    # @since 0.2.1
     class InvalidPropError < Error
       # @api private
-      # @since 0.3.0
+      # @since 0.2.1
       #: (Module, Symbol, String) -> void
       def initialize(view_class, name, reason)
         super(<<~MESSAGE)

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

@@ -42,8 +42,10 @@ module Phlex
           #
           # 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.
+          # `views.mailers.welcome`. The `views` is the slice's
+          # `config.actions.view_name_inference_base`, so mail views live where action views do.
+          # Resolved through the container on every call rather than memoized, so code reloading is
+          # not defeated.
           #
           # @return [Class, nil]
           #
@@ -56,7 +58,7 @@ module Phlex
             mailer_slice = slice
             return nil unless mailer_slice && name
 
-            key = "views.#{view_name(mailer_slice)}"
+            key = Extensions::Slice.view_key(mailer_slice, view_name(mailer_slice))
             return nil unless mailer_slice.key?(key)
 
             view = mailer_slice[key]

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

@@ -109,6 +109,26 @@ module Phlex
             define_view_context(slice)
           end
 
+          # The container key for a view, under the base Hanami pairs an action's view with.
+          #
+          # Reads `config.actions.view_name_inference_base`, so a slice that keeps its views under
+          # `ui.views` finds its layouts and mail views there too. Falls back to `views` when
+          # hanami-action is not bundled, because Hanami has no such setting then.
+          #
+          # @example
+          #   Slice.view_key(MyApp::App, "mailers.welcome") # => "views.mailers.welcome"
+          #
+          # @return [String]
+          #
+          # @api private
+          # @since 0.3.0
+          #: (singleton(::Hanami::Slice), String) -> String
+          def view_key(slice, name)
+            actions = slice.config.actions
+            base = actions.respond_to?(:view_name_inference_base) ? actions.view_name_inference_base : "views"
+            [base, name].compact.join(".")
+          end
+
           private
 
           #: (singleton(::Hanami::Slice)) -> Module

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

@@ -59,7 +59,8 @@ module Phlex
 
           private
 
-          # A slice's conventional mail layout: `Views::Mailers::Layout`, if it defines one.
+          # A slice's conventional mail layout: `views.mailers.layout` in its container, if it has
+          # one, under whatever base the slice pairs action views with.
           #
           # 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
@@ -67,13 +68,9 @@ module Phlex
           #: () -> singleton(::Phlex::SGML)?
           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)
+            key = Extensions::Slice.view_key(slice, "mailers.layout")
+            slice[key] if slice.key?(key)
           end
 
           # The slice's view context, built without a request.

data/lib/phlex/hanami/props.rb

@@ -4,14 +4,15 @@ module Phlex
   module Hanami
     # Declared props, typed with dry-types.
     #
-    # Opt in per class. Each `prop` names a keyword `initialize` takes and the type its value goes
+    # Opt in per class. Each `prop` names an argument `initialize` takes and the type its value goes
     # through, and the value lands in an instance variable of the same name. A dry type is called,
     # so it coerces as well as checks: `Types::Params::Integer` turns the string a request param
     # arrives as into an Integer. Anything else that answers `call` is called the same way, and
     # anything that does not, such as a plain class, is matched with `===`.
     #
     # The initializer it builds takes real keywords, so auto render hands a view the props it
-    # declares and drops every other param, the same as it does for a hand written `initialize`.
+    # declares and drops every other param, the same as it does for a hand written `initialize`. A
+    # `:**` prop takes them all, request params included.
     #
     # Literal needs none of this. Extend `Literal::Properties` instead if you would rather use it.
     #
@@ -23,85 +24,153 @@ module Phlex
     #     prop :count, Types::Params::Integer
     #     prop :compact, Types::Bool, default: false
     #     prop :tags, Types::Array.of(Types::String), default: -> { [] }
+    #     prop :attributes, Types::Hash, :**
     #
     #     def view_template
-    #       article(class: ("compact" if @compact)) { h2 { @post.title } }
+    #       article(class: ("compact" if @compact), **@attributes) { h2 { @post.title } }
     #     end
     #   end
     #
     # @api public
-    # @since 0.3.0
+    # @since 0.2.1
     module Props
-      # Stands in for a keyword the caller left out, since `nil` can be a real value.
+      # The value of a prop declared with `prop?` that the caller left out, so a view can tell it
+      # from `nil`.
       #
-      # @api private
-      # @since 0.3.0
-      UNSET = ::Object.new.freeze #: Object
+      # @example
+      #   prop? :token, Types::String.optional
+      #
+      #   def token_given? = !Phlex::Hanami::Props::UNSET.equal?(@token)
+      #
+      # @api public
+      # @since 0.2.1
+      UNSET = ::Object.new.tap { |unset| def unset.inspect = "Phlex::Hanami::Props::UNSET" }.freeze #: Object
 
       # How the generated initializer names {UNSET}.
       #
       # @api private
-      # @since 0.3.0
+      # @since 0.2.1
       UNSET_PATH = "::Phlex::Hanami::Props::UNSET" #: String
 
-      # A prop name has to be a Ruby identifier, because it becomes a keyword and an instance
+      # A prop name has to be a Ruby identifier, because it becomes an argument and an instance
       # variable.
       #
       # @api private
-      # @since 0.3.0
+      # @since 0.2.1
       NAME_FORMAT = /\A[a-z_][a-zA-Z0-9_]*\z/ #: Regexp
 
-      # Sets each prop's instance variable from the keywords the generated initializer received.
+      # The argument kinds a prop can take, in the order `initialize` declares them.
       #
       # @api private
       # @since 0.3.0
+      KINDS = %i[positional * keyword **].freeze #: Array[Symbol]
+
+      # What `reader`, `writer` and `predicate` accept.
+      #
+      # @api private
+      # @since 0.3.0
+      VISIBILITIES = [false, :public, :protected, :private].freeze #: Array[Symbol | false]
+
+      # Sets each prop's instance variable from the arguments the generated initializer received.
+      #
+      # @api private
+      # @since 0.2.1
       #: (untyped, Binding) -> void
       def self.assign(view, arguments)
         view.class.props.each_value do |prop|
-          value = prop.resolve(view.class, arguments.local_variable_get(prop.name))
+          value = prop.resolve(view, arguments.local_variable_get(prop.variable))
           view.instance_variable_set(:"@#{prop.name}", value)
         end
       end
 
       # @api private
-      # @since 0.3.0
+      # @since 0.2.1
       #: (Module) -> void
       def self.included(view_class)
         view_class.extend(ClassMethods)
       end
 
       # @api public
-      # @since 0.3.0
+      # @since 0.2.1
       module ClassMethods
         # Declares a prop.
         #
-        # A prop with a default is optional. So is one whose dry type carries its own, as
-        # `Types::Bool.default(false)` does. A default goes through the type like any other value.
-        # Pass a proc for anything mutable, so each instance gets its own.
+        # A prop with a default is optional. So is one whose type accepts nil, which it gets when
+        # left out, and one whose dry type carries its own default, as `Types::Bool.default(false)`
+        # does. A default goes through the type like any other value. Pass a proc for anything
+        # mutable, so each instance gets its own. The proc runs on the new instance, so it can read
+        # the props declared above it.
+        #
+        # A block, when given, runs on the new instance with the value before the type sees it.
+        #
+        # @param name [Symbol] the argument, and the instance variable the value lands in
+        # @param type [#call, #===] a dry type, or anything that answers `call` or `===`
+        # @param kind [Symbol] `:keyword`, `:positional`, `:*` for the rest of the positional
+        #   arguments as an Array, or `:**` for the rest of the keywords as a Hash
+        # @param default [Object, Proc] the value when the argument is left out
+        # @param reader [false, Symbol] the visibility of a reader method, or false for none
+        # @param writer [false, Symbol] the visibility of a writer method that checks the type
+        # @param predicate [false, Symbol] the visibility of a `name?` method
+        #
+        # @return [Symbol] the name
+        #
+        # @raise [ArgumentError] if an option is not valid, or the argument would not fit the
+        #   ones declared before it
+        #
+        # @api public
+        # @since 0.2.1
+        # @rbs name: Symbol
+        # @rbs type: untyped
+        # @rbs kind: Symbol
+        # @rbs default: untyped
+        # @rbs reader: Symbol | false
+        # @rbs writer: Symbol | false
+        # @rbs predicate: Symbol | false
+        # @rbs &coercion: ? (untyped) -> untyped
+        # @rbs return: Symbol
+        def prop(name, type, kind = :keyword, default: UNSET, reader: false, writer: false, predicate: false, &coercion)
+          prop = Prop.new(name, type, kind, default:, omittable: false, coercion:)
+          declare_prop(prop, { reader:, writer:, predicate: })
+        end
+
+        # Declares a prop the caller can leave out, and that is set to {UNSET} when they do. A view
+        # can then tell an argument left out from one passed as `nil`.
+        #
+        # The type does not see {UNSET}, so it only has to accept what a caller passes.
         #
-        # @param name [Symbol] the keyword, and the instance variable the value lands in
+        # @param name [Symbol] the argument, and the instance variable the value lands in
         # @param type [#call, #===] a dry type, or anything that answers `call` or `===`
-        # @param default [Object, Proc] the value when the keyword is left out
+        # @param kind [Symbol] `:keyword` or `:positional`
+        # @param reader [false, Symbol] the visibility of a reader method, or false for none
+        # @param writer [false, Symbol] the visibility of a writer method that checks the type
+        # @param predicate [false, Symbol] the visibility of a `name?` method
         #
         # @return [Symbol] the name
         #
-        # @raise [ArgumentError] if the name is not a Ruby identifier
+        # @raise [ArgumentError] if an option is not valid, or the argument would not fit the
+        #   ones declared before it
         #
         # @api public
         # @since 0.3.0
-        #: (Symbol, untyped, ?default: untyped) -> Symbol
-        def prop(name, type, default: UNSET)
-          raise ArgumentError, "#{name.inspect} is not a valid prop name" unless NAME_FORMAT.match?(name.to_s)
+        # @rbs name: Symbol
+        # @rbs type: untyped
+        # @rbs kind: Symbol
+        # @rbs reader: Symbol | false
+        # @rbs writer: Symbol | false
+        # @rbs predicate: Symbol | false
+        # @rbs &coercion: ? (untyped) -> untyped
+        # @rbs return: Symbol
+        def prop?(name, type, kind = :keyword, reader: false, writer: false, predicate: false, &coercion)
+          raise ArgumentError, "prop? takes a :keyword or :positional kind" unless %i[keyword positional].include?(kind)
 
-          own_props[name] = Prop.new(name, type, default)
-          define_props_initializer
-          name
+          prop = Prop.new(name, type, kind, default: UNSET, omittable: true, coercion:)
+          declare_prop(prop, { reader:, writer:, predicate: })
         end
 
         # Every prop this class declares, its superclasses' first.
         #
         # @api public
-        # @since 0.3.0
+        # @since 0.2.1
         #: () -> Hash[Symbol, Prop]
         def props
           inherited = superclass.respond_to?(:props) ? superclass.props : {} #: Hash[Symbol, Prop]
@@ -110,20 +179,90 @@ module Phlex
 
         private
 
+        #: (Prop, Hash[Symbol, Symbol | false]) -> void
+        def check_methods(prop, methods)
+          methods.each do |option, visibility|
+            next if VISIBILITIES.include?(visibility)
+
+            raise ArgumentError, "#{option} must be one of #{VISIBILITIES.map(&:inspect).join(', ')}"
+          end
+
+          # A reader would replace `Object#class`, which Phlex and Hanami both call.
+          raise ArgumentError, "the :class prop cannot have a reader" if methods[:reader] && prop.name == :class
+        end
+
+        # Ruby allows no required positional argument after an optional one once there is a `*`,
+        # and the order would surprise a caller anyway.
+        #: (Prop, Array[Prop]) -> void
+        def check_positional_order(prop, others)
+          return unless prop.kind == :positional && !prop.optional?
+          return unless others.any? { |other| other.kind == :positional && other.optional? }
+
+          raise ArgumentError, "the required positional prop #{prop.name.inspect} follows an optional one"
+        end
+
+        #: (Prop, Array[Prop]) -> void
+        def check_splat(prop, others)
+          return unless %i[* **].include?(prop.kind) && others.any? { |other| other.kind == prop.kind }
+
+          raise ArgumentError, "#{self} already has a #{prop.kind.inspect} prop"
+        end
+
+        #: (Prop, Hash[Symbol, Symbol | false]) -> Symbol
+        def declare_prop(prop, methods)
+          others = props.reject { |name, _| name == prop.name }.values
+          check_methods(prop, methods)
+          check_splat(prop, others)
+          check_positional_order(prop, others)
+
+          own_props[prop.name] = prop
+          define_props_initializer
+          define_prop_methods(prop, methods)
+          prop.name
+        end
+
+        #: (Prop, Symbol) -> Symbol
+        def define_prop_method(prop, option)
+          ivar = :"@#{prop.name}"
+
+          case option
+          when :reader then props_module.define_method(prop.name) { instance_variable_get(ivar) }
+          when :predicate then props_module.define_method(:"#{prop.name}?") { !!instance_variable_get(ivar) }
+          else define_prop_writer(prop)
+          end
+        end
+
+        # Defines the reader, writer and predicate asked for, each with its own visibility.
+        #: (Prop, Hash[Symbol, Symbol | false]) -> void
+        def define_prop_methods(prop, methods)
+          methods.each do |option, visibility|
+            props_module.send(visibility, define_prop_method(prop, option)) if visibility
+          end
+        end
+
+        # A writer runs the value through the type, as `initialize` does.
+        #: (Prop) -> Symbol
+        def define_prop_writer(prop)
+          ivar = :"@#{prop.name}"
+
+          props_module.define_method(:"#{prop.name}=") do |value|
+            instance_variable_set(ivar, prop.cast(self.class, value))
+          end
+        end
+
         # Writes `initialize` into a module of its own rather than onto the class, so a class can
         # still define `initialize` and call `super`.
         #: () -> void
         def define_props_initializer
-          @props_initializer ||= ::Module.new.tap { |initializer| include(initializer) }
-          keywords = props.each_value.map { |prop| prop.optional? ? "#{prop.name}: #{UNSET_PATH}" : "#{prop.name}:" }
-          signature = keywords.join(", ")
+          signature = props.values.sort_by.with_index { |prop, index| [KINDS.index(prop.kind), index] }.map(&:parameter)
 
-          # `binding` rather than the names themselves, because a prop may be named after a
+          # `binding` rather than the names themselves, because a keyword may be named after a
           # reserved word such as `class`, which is a valid keyword but not a readable variable.
-          @props_initializer.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def initialize(#{signature})                     # def initialize(post:, compact: ::Phlex::Hanami::Props::UNSET)
-              ::Phlex::Hanami::Props.assign(self, binding)  #   ::Phlex::Hanami::Props.assign(self, binding)
-            end                                             # end
+          props_module.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def initialize(#{signature.join(', ')})                      # def initialize(post:, compact: ::Phlex::Hanami::Props::UNSET)
+              ::Phlex::Hanami::Props.assign(self, binding)              #   ::Phlex::Hanami::Props.assign(self, binding)
+              after_initialize if respond_to?(:after_initialize, true)  #   after_initialize if respond_to?(:after_initialize, true)
+            end                                                         # end
           RUBY
         end
 
@@ -131,59 +270,122 @@ module Phlex
         def own_props
           @own_props ||= {}
         end
+
+        #: () -> Module
+        def props_module
+          @props_module ||= ::Module.new.tap { |props_module| include(props_module) }
+        end
       end
 
       # One declared prop.
       #
       # @api private
-      # @since 0.3.0
+      # @since 0.2.1
       class Prop
         attr_reader :name #: Symbol
 
-        #: (Symbol, untyped, untyped) -> void
-        def initialize(name, type, default)
+        attr_reader :kind #: Symbol
+
+        #: (Symbol, untyped, Symbol, default: untyped, omittable: bool, coercion: Proc?) -> void
+        def initialize(name, type, kind, default:, omittable:, coercion:)
+          raise ArgumentError, "#{name.inspect} is not a valid prop name" unless NAME_FORMAT.match?(name.to_s)
+          raise ArgumentError, "kind must be one of #{KINDS.map(&:inspect).join(', ')}" unless KINDS.include?(kind)
+          raise ArgumentError, "a #{kind.inspect} prop cannot have a default" if splat?(kind) && !UNSET.equal?(default)
+
           @name = name
           @type = type
+          @kind = kind
           @default = default
+          @omittable = omittable
+          @coercion = coercion
+        end
+
+        # Runs a value through the type.
+        #
+        # @raise [InvalidPropError] if the type rejects the value
+        #
+        #: (Module, untyped) -> untyped
+        def cast(view_class, value)
+          if @type.respond_to?(:call)
+            begin
+              return @type.call(value)
+            rescue StandardError => e
+              raise InvalidPropError.new(view_class, @name, e.message)
+            end
+          end
+
+          return value if @type === value # rubocop:disable Style/CaseEquality
+
+          raise InvalidPropError.new(view_class, @name, "#{value.inspect} is not a #{@type.inspect}")
         end
 
-        # Whether the keyword can be left out.
+        # Whether the argument can be left out.
         #
         #: () -> bool
         def optional?
-          !UNSET.equal?(@default) || type_default?
+          @omittable || splat?(@kind) || !UNSET.equal?(@default) || type_default? || nilable?
+        end
+
+        # This prop's part of the generated initializer's signature.
+        #
+        #: () -> String
+        def parameter
+          case @kind
+          when :keyword then optional? ? "#{@name}: #{UNSET_PATH}" : "#{@name}:"
+          when :positional then optional? ? "#{variable} = #{UNSET_PATH}" : variable.to_s
+          else "#{@kind}#{variable}"
+          end
         end
 
         # The value to assign, given what the caller passed or {UNSET}.
         #
         # @raise [InvalidPropError] if the type rejects the value
         #
-        #: (Module, untyped) -> untyped
-        def resolve(view_class, value)
+        #: (untyped, untyped) -> untyped
+        def resolve(view, value)
           if UNSET.equal?(value)
-            return @type.call if UNSET.equal?(@default)
+            return UNSET if @omittable
+            return @type.call if UNSET.equal?(@default) && type_default?
 
-            value = @default.is_a?(::Proc) ? @default.call : @default
+            value = default_value(view)
           end
 
-          cast(view_class, value)
+          value = view.instance_exec(value, &@coercion) if @coercion
+          cast(view.class, value)
+        end
+
+        # The local variable the generated initializer receives the value in. A keyword keeps its
+        # name, since auto render reads it from the signature. Any other argument gets one that
+        # cannot clash with a reserved word.
+        #
+        #: () -> Symbol
+        def variable
+          @kind == :keyword ? @name : :"__#{@name}__"
         end
 
         private
 
-        #: (Module, untyped) -> untyped
-        def cast(view_class, value)
-          if @type.respond_to?(:call)
-            begin
-              return @type.call(value)
-            rescue StandardError => e
-              raise InvalidPropError.new(view_class, @name, e.message)
-            end
-          end
+        # A prop with no default of its own is optional only because its type accepts nil.
+        #: (untyped) -> untyped
+        def default_value(view)
+          return nil if UNSET.equal?(@default)
 
-          return value if @type === value # rubocop:disable Style/CaseEquality
+          @default.is_a?(::Proc) ? view.instance_exec(&@default) : @default
+        end
 
-          raise InvalidPropError.new(view_class, @name, "#{value.inspect} is not a #{@type.inspect}")
+        # A dry type built with `.optional`, or anything else that matches nil. A callable is left
+        # out of the second test, since `===` on a Proc calls it.
+        #: () -> bool
+        def nilable?
+          return @type.optional? if @type.respond_to?(:optional?)
+          return false if @type.respond_to?(:call)
+
+          @type === nil # rubocop:disable Style/CaseEquality, Style/NilComparison
+        end
+
+        #: (Symbol) -> bool
+        def splat?(kind)
+          %i[* **].include?(kind)
         end
 
         # A dry type built with `.default` fills in a missing value itself.

data/lib/phlex/hanami/renderable.rb

@@ -140,15 +140,15 @@ module Phlex
           input.slice(*parameters.filter_map { |type, name| name if KEYWORD_TYPES.include?(type) })
         end
 
-        # The slice's conventional layout: `Views::Layout` in the slice's namespace, if it defines
-        # one. Resolved on each call rather than memoized, so code reloading is not defeated.
+        # The slice's conventional layout: `views.layout` in its container, if it has one, under
+        # whatever base the slice pairs action views with. Resolved on each call rather than
+        # memoized, so code reloading is not defeated.
         #: () -> singleton(::Phlex::SGML)?
         def default_layout
           return nil unless slice
-          return nil unless slice.namespace.const_defined?(:Views, false)
 
-          views = slice.namespace.const_get(:Views, false)
-          views.const_get(:Layout, false) if views.const_defined?(:Layout, false)
+          key = Extensions::Slice.view_key(slice, "layout")
+          slice[key] if slice.key?(key)
         end
       end
     end

data/lib/phlex/hanami/slice_configured_context.rb

@@ -69,9 +69,12 @@ module Phlex
         slice["i18n"] if slice.key?("i18n")
       end
 
+      # Resolves from the app, not the slice. A slice with its own routes file registers its own
+      # "routes", which knows only that slice's names and none of the prefix it is mounted at.
+      # Actions resolve the app's, so this keeps a view and an action in the same slice in step.
       #: () -> ::Hanami::Slice::RoutesHelper?
       def resolve_routes
-        slice["routes"] if slice.key?("routes")
+        slice.app["routes"] if slice.app.key?("routes")
       end
     end
   end

data/sig/phlex/hanami/extensions/slice.rbs

@@ -14,6 +14,8 @@ module Phlex
 
         def self.view_context_class: (singleton(::Hanami::Slice)) -> (singleton(::Hanami::View::Context) | singleton(Context))
 
+        def self.view_key: (singleton(::Hanami::Slice), String) -> String
+
         private def self.views_namespace: (singleton(::Hanami::Slice)) -> Module
       end
     end

data/sig/phlex/hanami/props.rbs

@@ -9,34 +9,68 @@ module Phlex
 
       NAME_FORMAT: Regexp
 
+      KINDS: Array[Symbol]
+
+      VISIBILITIES: Array[Symbol | false]
+
       def self.assign: (untyped, Binding) -> void
 
       def self.included: (Module) -> void
 
       module ClassMethods
-        def prop: (Symbol, untyped, ?default: untyped) -> Symbol
+        def prop: (Symbol name, untyped type, ?Symbol kind, ?default: untyped, ?reader: Symbol | false, ?writer: Symbol | false, ?predicate: Symbol | false) ?{ (untyped) -> untyped } -> Symbol
+
+        def prop?: (Symbol name, untyped type, ?Symbol kind, ?reader: Symbol | false, ?writer: Symbol | false, ?predicate: Symbol | false) ?{ (untyped) -> untyped } -> Symbol
 
         def props: () -> Hash[Symbol, Prop]
 
         private
 
+        def check_methods: (Prop, Hash[Symbol, Symbol | false]) -> void
+
+        def check_positional_order: (Prop, Array[Prop]) -> void
+
+        def check_splat: (Prop, Array[Prop]) -> void
+
+        def declare_prop: (Prop, Hash[Symbol, Symbol | false]) -> Symbol
+
+        def define_prop_method: (Prop, Symbol) -> Symbol
+
+        def define_prop_writer: (Prop) -> Symbol
+
+        def define_prop_methods: (Prop, Hash[Symbol, Symbol | false]) -> void
+
         def define_props_initializer: () -> void
 
         def own_props: () -> Hash[Symbol, Prop]
+
+        def props_module: () -> Module
       end
 
       class Prop
         attr_reader name: Symbol
 
-        def initialize: (Symbol, untyped, untyped) -> void
+        attr_reader kind: Symbol
+
+        def initialize: (Symbol, untyped, Symbol, default: untyped, omittable: bool, coercion: Proc?) -> void
+
+        def cast: (Module, untyped) -> untyped
 
         def optional?: () -> bool
 
-        def resolve: (Module, untyped) -> untyped
+        def parameter: () -> String
+
+        def resolve: (untyped, untyped) -> untyped
+
+        def variable: () -> Symbol
 
         private
 
-        def cast: (Module, untyped) -> untyped
+        def default_value: (untyped) -> untyped
+
+        def nilable?: () -> bool
+
+        def splat?: (Symbol) -> bool
 
         def type_default?: () -> bool
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-hanami
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Aaron Allen
@@ -141,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A Phlex adapter for Hanami
 test_files: []