hanami-view 2.3.0 → 3.0.0.rc1

data/lib/hanami/view/renderer.rb

@@ -1,73 +1,123 @@
 # frozen_string_literal: true
 
+require "pathname"
 require_relative "errors"
 
 module Hanami
   class View
+    # Resolves a template by name and renders it through Tilt.
+    #
+    # Template lookup combines two pieces of state:
+    #
+    # - **`config.paths`** — the configured view paths, immutable for the lifetime of the
+    #   renderer. When multiple view paths are configured, earlier ones override later ones.
+    # - **`@prefixes`** — a stack of subdirectories within each view path to search, mutated
+    #   during rendering. It starts at `[CURRENT_PATH_PREFIX]` (the root itself). When a template is
+    #   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`.
+    #
+    # `#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
+    # entry overrides a later one. `prefixes` are checked oldest-first: a partial at the root
+    # wins over a same-named partial in a directory pushed onto the stack mid-render. First match
+    # wins.
+    #
     # @api private
-    # @since 2.1.0
     class Renderer
-      # @api private
-      # @since 2.1.0
       PARTIAL_PREFIX = "_"
-
-      # @api private
-      # @since 2.1.0
       PATH_DELIMITER = "/"
-
-      # @api private
-      # @since 2.1.0
       CURRENT_PATH_PREFIX = "."
 
-      # @api private
-      # @since 2.1.0
-      attr_reader :config, :prefixes
+      # Matches the `.format.engine` extensions on a template path (e.g. `.html.erb`).
+      EXTENSIONS_REGEXP = /\.[^.\/]+\.[^.\/]+\z/
+
+      # Stack of resolved names for the templates and partials currently being rendered. The top of
+      # the stack is the innermost render in progress.
+      #
+      # @return [Array<String>]
+      attr_reader :current_template_names
 
       # @api private
-      # @since 2.1.0
-      def initialize(config)
-        @config = config
+      def initialize(config_data)
+        @config_data = config_data
         @prefixes = [CURRENT_PATH_PREFIX]
+        @current_template_names = []
       end
 
-      # @api private
-      # @since 2.1.0
       def template(name, format, scope, &block)
         old_prefixes = @prefixes.dup
 
-        template_path = lookup(name, format)
+        result = lookup(name, format)
+        raise TemplateNotFoundError.new(name, format, config_data.paths) unless result
 
-        raise TemplateNotFoundError.new(name, format, config.paths) unless template_path
+        template_path, relative_path = result
 
         new_prefix = File.dirname(name)
         @prefixes << new_prefix unless @prefixes.include?(new_prefix)
+        @current_template_names << resolve_template_name(relative_path)
 
         render(template_path, scope, &block)
       ensure
         @prefixes = old_prefixes
+        @current_template_names.pop if result
       end
 
-      # @api private
-      # @since 2.1.0
       def partial(name, format, scope, &block)
         template(name_for_partial(name), format, scope, &block)
       end
 
+      # Returns the resolved name of the template or partial currently being rendered, or nil if no
+      # render is in progress.
+      #
+      # The name is the file's path relative to the matching view path, with format/engine
+      # extensions stripped.
+      #
+      # @return [String, nil]
+      def current_template_name
+        @current_template_names.last
+      end
+
       private
 
+      attr_reader :config_data, :prefixes
+
+      # Searches `config.paths` (under each of the `prefixes`) for a template matching `name` and
+      # `format`. Returns the template's absolute file path (for rendering via Tilt) together with
+      # its path relative to the matching view path.
+      #
+      # Results are memoized via `View.cache` keyed on `(name, format, config_data, prefixes)`.
+      #
+      # @return [[String, String], nil]
       def lookup(name, format)
-        View.cache.fetch_or_store(:lookup, name, format, config, prefixes) {
+        View.cache.fetch_or_store(:lookup, name, format, config_data.object_id, prefixes) {
           catch :found do
-            config.paths.reduce(nil) do |_, path|
-              prefixes.reduce(nil) do |_, prefix|
-                result = path.lookup(prefix, name, format)
-                throw :found, result if result
+            config_data.paths.each do |path|
+              prefixes.each do |prefix|
+                file_path = path.lookup(prefix, name, format)
+                if file_path
+                  relative_path = Pathname.new(file_path).relative_path_from(path.dir).to_s
+                  throw :found, [file_path, relative_path]
+                end
               end
             end
+            nil
           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`.
+      #
+      # Strips format/engine extensions (e.g. `.html.erb`), so `"posts/_form.html.erb"` becomes
+      # `"posts/_form"`.
+      #
+      # @return [String]
+      def resolve_template_name(relative_path)
+        relative_path.sub(EXTENSIONS_REGEXP, "")
+      end
+
       def name_for_partial(name)
         segments = name.to_s.split(PATH_DELIMITER)
         segments[-1] = "#{PARTIAL_PREFIX}#{segments[-1]}"
@@ -79,8 +129,8 @@ module Hanami
       end
 
       def tilt(path)
-        View.cache.fetch_or_store(:tilt, path, config) {
-          Hanami::View::Tilt[path, config.renderer_engine_mapping, config.renderer_options]
+        View.cache.fetch_or_store(:tilt, path, config_data.object_id) {
+          Hanami::View::Tilt[path, config_data.renderer_engine_mapping, config_data.renderer_options]
         }
       end
     end

data/lib/hanami/view/rendering.rb

@@ -3,54 +3,70 @@
 module Hanami
   class View
     # @api private
-    # @since 2.1.0
     class Rendering
       # @api private
-      # @since 2.1.0
-      attr_reader :config, :format
+      attr_reader :format
 
-      # @api private
-      # @since 2.1.0
       attr_reader :inflector, :part_builder, :scope_builder
 
-      # @api private
-      # @since 2.1.0
+      attr_reader :part_class, :part_namespace, :scope_class, :scope_namespace
+
+      # Stable identity for the underlying config snapshot.
+      attr_reader :cache_key
+
       attr_reader :context, :renderer
 
-      # @api private
-      # @since 2.1.0
-      def initialize(config:, format:, context:)
-        @config = config
+      def initialize(config_data:, format:, context:)
         @format = format
 
-        @inflector = config.inflector
-        @part_builder = config.part_builder
-        @scope_builder = config.scope_builder
+        @inflector = config_data.inflector
+        @part_builder = config_data.part_builder
+        @scope_builder = config_data.scope_builder
+
+        @part_class = config_data.part_class
+        @part_namespace = config_data.part_namespace
+        @scope_class = config_data.scope_class
+        @scope_namespace = config_data.scope_namespace
+        @cache_key = config_data.object_id
 
         @context = context.dup_for_rendering(self)
-        @renderer = Renderer.new(config)
+        @renderer = Renderer.new(config_data)
       end
 
+      # Returns the resolved name of the template or partial currently being rendered, or nil if
+      # no render is in progress.
+      #
+      # @return [String, nil]
+      #
+      # @api public
+      # @since x.x.x
+      def current_template_name
+        renderer.current_template_name
+      end
+
+      # Returns the stack of resolved names for the templates and partials currently being
+      # rendered.
+      #
+      # @return [Array<String>]
+      #
       # @api private
-      # @since 2.1.0
+      # @since x.x.x
+      def current_template_names
+        renderer.current_template_names
+      end
+
       def template(name, scope, &block)
         renderer.template(name, format, scope, &block)
       end
 
-      # @api private
-      # @since 2.1.0
       def partial(name, scope, &block)
         renderer.partial(name, format, scope, &block)
       end
 
-      # @api private
-      # @since 2.1.0
       def part(name, value, as: nil)
         part_builder.(name, value, as: as, rendering: self)
       end
 
-      # @api private
-      # @since 2.1.0
       def scope(name = nil, locals) # rubocop:disable Style/OptionalArguments
         scope_builder.(name, locals: locals, rendering: self)
       end

data/lib/hanami/view/rendering_missing.rb

@@ -8,47 +8,44 @@ module Hanami
     # @api private
     # @since 2.1.0
     class RenderingMissing
-      # @api private
-      # @since 2.1.0
       def format
         raise RenderingMissingError
       end
 
-      # @api private
-      # @since 2.1.0
       def context
         raise RenderingMissingError
       end
 
-      # @api private
-      # @since 2.1.0
       def part(_name, _value, **_options)
         raise RenderingMissingError
       end
 
-      # @api private
-      # @since 2.1.0
       def scope(_name = nil, _locals) # rubocop:disable Style/OptionalArguments
         raise RenderingMissingError
       end
 
-      # @api private
-      # @since 2.1.0
       def template(_name, _scope)
         raise RenderingMissingError
       end
 
-      # @api private
-      # @since 2.1.0
       def partial(_name, _scope)
         raise RenderingMissingError
       end
 
-      # @api private
-      # @since 2.1.0
       def inflector
         @inflector ||= Dry::Inflector.new
       end
+
+      def current_template_name
+        nil
+      end
+
+      def current_template_names
+        EMPTY_TEMPLATE_NAMES
+      end
+
+      EMPTY_TEMPLATE_NAMES = [].freeze
+      private_constant :EMPTY_TEMPLATE_NAMES
     end
   end
 end

data/lib/hanami/view/scope.rb

@@ -19,7 +19,7 @@ module Hanami
     # @since 2.1.0
     class Scope
       # @api private
-      CONVENIENCE_METHODS = %i[format context locals].freeze
+      CONVENIENCE_METHODS = %i[format context locals template_name].freeze
 
       include Dry::Equalizer(:_name, :_locals, :_rendering)
 
@@ -35,10 +35,10 @@ module Hanami
       #
       # @overload _locals
       #   Returns the locals.
+      #   @return [Hash{Symbol => Object}]
       # @overload locals
       #   A convenience alias for `#_locals.` Is available unless there is a local named `locals`
-      #
-      # @return [Hash[<Symbol, Object>]
+      #   @return [Hash{Symbol => Object}]
       #
       # @api public
       # @since 2.1.0
@@ -76,16 +76,16 @@ module Hanami
       #   Renders a partial using the scope.
       #
       #   @param partial_name [Symbol, String] partial name
-      #   @param locals [Hash<Symbol, Object>] partial locals
+      #   @param locals [Hash{Symbol => Object}] partial locals
       #   @yieldreturn [String] string content to include where the partial calls `yield`
+      #   @return [String] the rendered partial output
       #
       # @overload render(**locals, &block)
       #   Renders a partial (named after the scope's own name) using the scope.
       #
-      #   @param locals[Hash<Symbol, Object>] partial locals
+      #   @param locals [Hash{Symbol => Object}] partial locals
       #   @yieldreturn [String] string content to include where the partial calls `yield`
-      #
-      # @return [String] the rendered partial output
+      #   @return [String] the rendered partial output
       #
       # @api public
       # @since 2.1.0
@@ -120,11 +120,10 @@ module Hanami
       #
       # @overload _format
       #   Returns the format.
+      #   @return [Symbol] format
       # @overload format
-      #   A convenience alias for `#_format.` Is available unless there is a
-      #   local named `format`
-      #
-      # @return [Symbol] format
+      #   A convenience alias for `#_format.` Is available unless there is a local named `format`.
+      #   @return [Symbol] format
       #
       # @api public
       # @since 2.1.0
@@ -136,11 +135,10 @@ module Hanami
       #
       # @overload _context
       #   Returns the context.
+      #   @return [Context] context
       # @overload context
-      #   A convenience alias for `#_context`. Is available unless there is a
-      #   local named `context`.
-      #
-      # @return [Context] context
+      #   A convenience alias for `#_context`. Is available unless there is a local named `context`.
+      #   @return [Context] context
       #
       # @api public
       # @since 2.1.0
@@ -148,6 +146,22 @@ module Hanami
         _rendering.context
       end
 
+      # Returns the name of the template or partial currently being rendered.
+      #
+      # @overload _template_name
+      #   Returns the current template name.
+      #   @return [String, nil]
+      # @overload template_name
+      #   A convenience alias for `#_template_name`. Is available unless there is a local named
+      #   `template_name`.
+      #   @return [String, nil]
+      #
+      # @api public
+      # @since x.x.x
+      def _template_name
+        _rendering.current_template_name
+      end
+
       private
 
       # Handles missing methods, according to the following rules:

data/lib/hanami/view/scope_builder.rb

@@ -17,7 +17,7 @@ module Hanami
         #
         # @api public
         # @since 2.1.0
-        def call(name = nil, locals:, rendering:) # rubocop:disable Style/OptionalArguments
+        def call(name = nil, locals:, rendering:)
           klass = scope_class(name, rendering: rendering)
 
           klass.new(name: name, locals: locals, rendering: rendering)
@@ -27,11 +27,11 @@ module Hanami
 
         def scope_class(name = nil, rendering:)
           if name.nil?
-            rendering.config.scope_class
+            rendering.scope_class
           elsif name.is_a?(Class)
             name
           else
-            View.cache.fetch_or_store(name, rendering.config) do
+            View.cache.fetch_or_store(name, rendering.cache_key) do
               resolve_scope_class(name: name, rendering: rendering)
             end
           end
@@ -40,12 +40,12 @@ module Hanami
         def resolve_scope_class(name:, rendering:)
           name = rendering.inflector.camelize(name.to_s)
 
-          namespace = rendering.config.scope_namespace
+          namespace = rendering.scope_namespace
 
           # Give autoloaders a chance to act
           begin
             klass = namespace.const_get(name)
-          rescue NameError # rubocop:disable Lint/HandleExceptions
+          rescue NameError # rubocop:disable Lint/SuppressedException
           end
 
           if !klass && namespace.const_defined?(name, false)
@@ -55,7 +55,7 @@ module Hanami
           if klass && klass < Scope
             klass
           else
-            rendering.config.scope_class
+            rendering.scope_class
           end
         end
       end

data/lib/hanami/view/tilt/haml_adapter.rb

@@ -34,7 +34,7 @@ module Hanami
         Template = Temple::Templates::Tilt(
           ::Haml::Engine,
           use_html_safe: true,
-          capture_generator: HTMLSafeStringBuffer,
+          capture_generator: HTMLSafeStringBuffer
         )
       end
     end

data/lib/hanami/view/tilt/slim_adapter.rb

@@ -34,7 +34,7 @@ module Hanami
         Template = Temple::Templates::Tilt(
           ::Slim::Engine,
           use_html_safe: true,
-          capture_generator: HTMLSafeStringBuffer,
+          capture_generator: HTMLSafeStringBuffer
         )
       end
     end

data/lib/hanami/view/version.rb

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