hanami-view 3.0.0.rc1 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab1223361a1dd1e27cda821d93b04857383189680e9eb2936011ae18119a3b98
-  data.tar.gz: 10d4f6e9057266613cdd392a0daa16d4aa130cffdafda095e393fa1260a28e3e
+  metadata.gz: cfd4f5b396df91cbef8969c45d2619115365a83856411998e92f9bf9ba35d027
+  data.tar.gz: fd73d60f403a32f11a4261caf786dc33ba7f53c891edbf50dfcfe44f2445fb5c
 SHA512:
-  metadata.gz: 2bb9ee14ae0cb4c446c80e24ee36a6f73a21baf95bc41face07aeb694014f74bed5e8ef1dfa8ec827de1f2a74acf3248cfdfd4c99ece34bcbb014c3a2f4bfddd
-  data.tar.gz: 33310b9d1de7704edcf2db34c401e310b18649a4d41f6bf8d5320c73842a46d545c9be9e43b9347634d2c9e635fc7d752f55b4630bd262091da43c1afffb4c29
+  metadata.gz: c7958b7d98292e6595c0abde96ce7ba136d2ac75d2036d415668ded39a6a44435349b5fa6ea0bf87486e3a7c55ff54bce5be971a62bc7b70e5d2cad18dad4ff9
+  data.tar.gz: 4baa7d74944594e1af1357ed042b1cae7cc1577200e026f9da575142ac199824dece54a67158bf1a3e1f1a698ac72774e01433d20052d306fa8d3a0a670d08e4

data/CHANGELOG.md

@@ -19,7 +19,45 @@ and this project adheres to [Break Versioning](https://www.taoensso.com/break-ve
 
 ### Security
 
-[Unreleased]: https://github.com/hanami/view/compare/v3.0.0.rc1...HEAD
+[Unreleased]: https://github.com/hanami/view/compare/v3.0.1...HEAD
+
+## [3.0.1] - 2026-08-14
+
+### Fixed
+
+- Report the calling template as the current template name inside blocks passed to `render`, instead of the partial the block is yielded into. (@timriley in #281)
+- Look up bare-named partials in the directory containing the template that renders them, instead of a same-named directory at the root. (@timriley in #282)
+
+    Previously, a partial rendered via a relative path (e.g. `render("shared/fields")` from `posts/show`) would look for its own bare-named partials under `shared/` at the root, rather than `posts/shared/`.
+
+[3.0.1]: https://github.com/hanami/view/compare/v3.0.0...v3.0.1
+
+## [3.0.0] - 2026-06-30
+
+### Added
+
+- Track the currently-rendering template name. (@timriley in #277)
+
+    Expose this as `Hanami::View::Scope#_template_name` (with `template_name` as a convenience alias) and `Hanami::View::Context#current_template_name`.
+
+    The name is resolved path of the file actually being rendered, relative to its configured `paths` directory, with format/engine extensions stripped. For example, `render("form")` from inside `posts/show.html.erb` returns `"posts/_form"`; a layout at `layouts/app.html.erb` returns `"layouts/app"`.
+
+    The current template name can be used to enable such behaviors as lazy/relative key lookups for i18n view helpers. 
+
+### Changed
+
+- **BREAKING:** Default to undecorated exposures. (@timriley in #274)
+
+    Decorate your exposures with the new `.decorate` method, or the `decorate: true` option for `.expose`. Default back to decorated exposures via `config.decorate_exposures = true`. 
+- Cache the view's resolved configuration as a frozen `Data` snapshot (via dry-configurable's `#to_data`) at initialization, avoiding repeated config lookups on the rendering hot path for improved memory usage and speed. (@cllns in #276)
+- Require Ruby 3.3 or newer.
+
+### Fixed
+
+- Allow the gem to be eager loaded by Zeitwerk when the optional haml and slim gems are not installed. (@timriley in #279)
+- Use our own Haml template engine even when the haml gem is required before hanami-view. (@timriley in #279)
+
+[3.0.0]: https://github.com/hanami/view/compare/v2.3.1...v3.0.0
 
 ## [3.0.0.rc1] - 2026-06-16
 
@@ -27,9 +65,11 @@ and this project adheres to [Break Versioning](https://www.taoensso.com/break-ve
 
 - Track the currently-rendering template name. (@timriley in #277)
 
-    Expose the topmost entry as `Hanami::View::Rendering#current_template_name` and the full stack as `#current_template_names`. Entries are the resolved path of the file actually being rendered, relative to its configured `paths` directory, with format/engine extensions stripped. For example, `render("form")` from inside `posts/show.html.erb` reports `"posts/_form"`; a layout at `layouts/app.html.erb` reports `"layouts/app"`.
+    Expose this as `Hanami::View::Scope#_template_name` (with `template_name` as a convenience alias) and `Hanami::View::Context#current_template_name`.
+
+    The name is resolved path of the file actually being rendered, relative to its configured `paths` directory, with format/engine extensions stripped. For example, `render("form")` from inside `posts/show.html.erb` returns `"posts/_form"`; a layout at `layouts/app.html.erb` returns `"layouts/app"`.
 
-    Convenience accessors are available as `Hanami::View::Scope#_template_name` (with `template_name` as a convenience alias) and `Hanami::View::Context#current_template_name`. The current template name can be used to enable such behaviors as lazy/relative key lookups for i18n view helpers. 
+    The current template name can be used to enable such behaviors as lazy/relative key lookups for i18n view helpers. 
 
 ### Changed
 

data/lib/hanami/view/context.rb

@@ -47,7 +47,7 @@ module Hanami
       # @return [String, nil]
       #
       # @api public
-      # @since x.x.x
+      # @since 3.0.0
       def current_template_name
         _rendering.current_template_name
       end

data/lib/hanami/view/renderer.rb

@@ -16,7 +16,7 @@ module Hanami
     #   rendered, its parent directory (e.g. `"users"` for `"users/index"`) is pushed onto the stack
     #   so that a partial referenced by its bare name (e.g. `render("form")` from inside
     #   `users/index.html.erb`) can be found alongside the template that renders it. The stack is
-    #    snapshot-and-restored around each render via `ensure`.
+    #   snapshot-and-restored around each render via `ensure`.
     #
     # `#lookup` tries every combination of a path and a prefix, joining each pair with the
     # requested name to find a matching file. `paths` are checked in configured order; an earlier
@@ -48,20 +48,21 @@ module Hanami
 
       def template(name, format, scope, &block)
         old_prefixes = @prefixes.dup
+        old_template_names = @current_template_names
 
         result = lookup(name, format)
         raise TemplateNotFoundError.new(name, format, config_data.paths) unless result
 
         template_path, relative_path = result
 
-        new_prefix = File.dirname(name)
+        new_prefix = File.dirname(relative_path)
         @prefixes << new_prefix unless @prefixes.include?(new_prefix)
-        @current_template_names << resolve_template_name(relative_path)
+        @current_template_names = old_template_names + [resolve_template_name(relative_path)]
 
-        render(template_path, scope, &block)
+        render(template_path, scope, &yielded_block(block, old_template_names))
       ensure
         @prefixes = old_prefixes
-        @current_template_names.pop if result
+        @current_template_names = old_template_names
       end
 
       def partial(name, format, scope, &block)
@@ -107,6 +108,28 @@ module Hanami
         }
       end
 
+      # Wraps a block yielded into a template so that, while it runs, `#current_template_name`
+      # reports the template that _wrote_ the block, not the one yielding to it.
+      #
+      # A block passed to `render` is written inside the calling template, so its contents belong to
+      # that template even though they're evaluated during the rendering of another.
+      #
+      # @return [Proc, nil]
+      def yielded_block(block, caller_template_names)
+        return nil unless block
+
+        proc { |*args|
+          yielding_template_names = @current_template_names
+          @current_template_names = caller_template_names
+
+          begin
+            block.call(*args)
+          ensure
+            @current_template_names = yielding_template_names
+          end
+        }
+      end
+
       # Derives the rendered template's name from its relative path, suitable for tracking on
       # `@current_template_names` and surfacing via `#current_template_name`.
       #

data/lib/hanami/view/rendering.rb

@@ -37,9 +37,6 @@ module Hanami
       # no render is in progress.
       #
       # @return [String, nil]
-      #
-      # @api public
-      # @since x.x.x
       def current_template_name
         renderer.current_template_name
       end
@@ -48,9 +45,6 @@ module Hanami
       # rendered.
       #
       # @return [Array<String>]
-      #
-      # @api private
-      # @since x.x.x
       def current_template_names
         renderer.current_template_names
       end

data/lib/hanami/view/scope.rb

@@ -157,7 +157,7 @@ module Hanami
       #   @return [String, nil]
       #
       # @api public
-      # @since x.x.x
+      # @since 3.0.0
       def _template_name
         _rendering.current_template_name
       end

data/lib/hanami/view/tilt.rb

@@ -10,14 +10,24 @@ module Hanami
       # @api private
       # @since 2.1.0
       Mapping = ::Tilt.default_mapping.dup.tap { |mapping|
-        # If "slim" has been required before "hanami/view", unregister Slim's non-lazy registered
-        # template, so our own template adapter (using register_lazy below) can take precedence.
-        mapping.unregister "slim"
+        # Unregister any existing mappings for the extensions we provide our own engines for.
+        #
+        # Tilt preferences non-lazy registrations over lazy ones (see `Tilt::Mapping#lookup`). So if
+        # "haml" or "slim" has been required before this mapping is built (each of which registers
+        # its own non-lazy mapping with Tilt), our own lazy-registered adapters below would be
+        # shadowed and never picked up, and templates would render without our specific required
+        # behavior.
+        #
+        # Unregistering first ensures our engines are always used, regardless of load order.
+        mapping.unregister "erb", "rhtml", "haml", "slim"
 
         # Register our own ERB template.
         mapping.register_lazy "Hanami::View::ERB::Template", "hanami/view/erb/template", "erb", "rhtml"
 
-        # Register ERB templates for Haml and Slim that set the `use_html_safe: true` option.
+        # Register templates for Haml and Slim that set the `use_html_safe: true` option.
+        #
+        # We register these lazily so that the optional "haml" and "slim" gems only need to be
+        # installed when their templates are actually used.
         #
         # Our template namespaces below have the "Adapter" suffix to work around a bug in Tilt's
         # `Mapping#const_defined?`, which (if slim was already required) would receive

data/lib/hanami/view/version.rb

@@ -3,6 +3,6 @@
 module Hanami
   class View
     # @api public
-    VERSION = "3.0.0.rc1"
+    VERSION = "3.0.1"
   end
 end

data/lib/hanami/view.rb

@@ -30,7 +30,12 @@ module Hanami
         loader.ignore(
           "#{root}/hanami-view.rb",
           "#{root}/hanami/view/version.rb",
-          "#{root}/hanami/view/errors.rb"
+          "#{root}/hanami/view/errors.rb",
+          # These adapters require the optional "haml" and "slim" gems. They are loaded lazily by
+          # Tilt (see Hanami::View::Tilt) only when their respective template engines are used;
+          # ignore them here to allow eager loading without those gems installed.
+          "#{root}/hanami/view/tilt/haml_adapter.rb",
+          "#{root}/hanami/view/tilt/slim_adapter.rb"
         )
         loader.inflector = Zeitwerk::GemInflector.new("#{root}/hanami-view.rb")
         loader.inflector.inflect(
@@ -246,7 +251,7 @@ module Hanami
     #
     #   @param value [Boolean] whether to decorate exposures by default
     #   @api public
-    #   @since x.x.x
+    #   @since 3.0.0
     # @!scope class
     setting :decorate_exposures, default: false
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hanami-view
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc1
+  version: 3.0.1
 platform: ruby
 authors:
 - Hanakai team