hanami-view 2.0.0.alpha8 → 2.1.0.beta1

data/lib/hanami/view/path.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
 require "pathname"
-require "dry/core/cache"
 
 module Hanami
   class View
     # @api private
     class Path
-      extend Dry::Core::Cache
       include Dry::Equalizer(:dir, :root)
 
       attr_reader :dir, :root
@@ -25,12 +23,10 @@ module Hanami
         @root = Pathname(root)
       end
 
-      def lookup(name, format, child_dirs: [], parent_dir: false)
-        fetch_or_store(dir, root, name, format, child_dirs, parent_dir) do
-          lookup_template(name, format) ||
-            lookup_in_child_dirs(name, format, child_dirs: child_dirs) ||
-            parent_dir && lookup_in_parent_dir(name, format, child_dirs: child_dirs)
-        end
+      # Searches for a template using a wildcard for the engine extension
+      def lookup(prefix, name, format)
+        glob = dir.join(prefix, "#{name}.#{format}.*")
+        Dir[glob].first
       end
 
       def chdir(dirname)
@@ -40,29 +36,6 @@ module Hanami
       def to_s
         dir.to_s
       end
-
-      private
-
-      def root?
-        dir == root
-      end
-
-      # Search for a template using a wildcard for the engine extension
-      def lookup_template(name, format)
-        glob = dir.join("#{name}.#{format}.*")
-        Dir[glob].first
-      end
-
-      def lookup_in_child_dirs(name, format, child_dirs:)
-        child_dirs.reduce(nil) { |_, dir|
-          template = chdir(dir).lookup(name, format)
-          break template if template
-        }
-      end
-
-      def lookup_in_parent_dir(name, format, child_dirs:)
-        !root? && chdir("..").lookup(name, format, child_dirs: child_dirs, parent_dir: true)
-      end
     end
   end
 end

data/lib/hanami/view/renderer.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-require "dry/core/cache"
-require "dry/core/equalizer"
 require_relative "errors"
-require_relative "tilt"
 
 module Hanami
   class View
@@ -11,67 +8,62 @@ module Hanami
     class Renderer
       PARTIAL_PREFIX = "_"
       PATH_DELIMITER = "/"
+      CURRENT_PATH_PREFIX = "."
 
-      extend Dry::Core::Cache
+      attr_reader :config, :prefixes
 
-      include Dry::Equalizer(:paths, :format, :engine_mapping, :options)
-
-      attr_reader :paths, :format, :engine_mapping, :options
-
-      def initialize(paths, format:, engine_mapping: nil, **options)
-        @paths = paths
-        @format = format
-        @engine_mapping = engine_mapping || {}
-        @options = options
+      def initialize(config)
+        @config = config
+        @prefixes = [CURRENT_PATH_PREFIX]
       end
 
-      def template(name, scope, **lookup_options, &block)
-        path = lookup(name, **lookup_options)
+      def template(name, format, scope, &block)
+        old_prefixes = @prefixes.dup
 
-        if path
-          render(path, scope, &block)
-        else
-          raise TemplateNotFoundError.new(name, paths)
-        end
-      end
+        template_path = lookup(name, format)
 
-      def partial(name, scope, &block)
-        template(
-          name_for_partial(name),
-          scope,
-          child_dirs: %w[shared],
-          parent_dir: true,
-          &block
-        )
-      end
+        raise TemplateNotFoundError.new(name, format, config.paths) unless template_path
 
-      def render(path, scope, &block)
-        tilt(path).render(scope, {locals: scope._locals}, &block)
-      end
+        new_prefix = File.dirname(name)
+        @prefixes << new_prefix unless @prefixes.include?(new_prefix)
 
-      def chdir(dirname)
-        new_paths = paths.map { |path| path.chdir(dirname) }
+        render(template_path, scope, &block)
+      ensure
+        @prefixes = old_prefixes
+      end
 
-        self.class.new(new_paths, format: format, **options)
+      def partial(name, format, scope, &block)
+        template(name_for_partial(name), format, scope, &block)
       end
 
       private
 
-      def lookup(name, **options)
-        paths.inject(nil) { |_, path|
-          result = path.lookup(name, format, **options)
-          break result if result
+      def lookup(name, format)
+        View.cache.fetch_or_store(:lookup, name, format, config, 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
+              end
+            end
+          end
         }
       end
 
       def name_for_partial(name)
-        name_segments = name.to_s.split(PATH_DELIMITER)
-        name_segments[0..-2].push("#{PARTIAL_PREFIX}#{name_segments[-1]}").join(PATH_DELIMITER)
+        segments = name.to_s.split(PATH_DELIMITER)
+        segments[-1] = "#{PARTIAL_PREFIX}#{segments[-1]}"
+        segments.join(PATH_DELIMITER)
+      end
+
+      def render(path, scope, &block)
+        tilt(path).render(scope, {locals: scope._locals}, &block).html_safe
       end
 
       def tilt(path)
-        fetch_or_store(:engine, path, engine_mapping, options) {
-          Tilt[path, engine_mapping, **options]
+        View.cache.fetch_or_store(:tilt, path, config) {
+          Hanami::View::Tilt[path, config.renderer_engine_mapping, config.renderer_options]
         }
       end
     end

data/lib/hanami/view/rendering.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Hanami
+  class View
+    # @api private
+    class Rendering
+      attr_reader :config, :format
+
+      attr_reader :inflector, :part_builder, :scope_builder
+
+      attr_reader :context, :renderer
+
+      def initialize(config:, format:, context:)
+        @config = config
+        @format = format
+
+        @inflector = config.inflector
+        @part_builder = config.part_builder
+        @scope_builder = config.scope_builder
+
+        @context = context.dup_for_rendering(self)
+        @renderer = Renderer.new(config)
+      end
+
+      def template(name, scope, &block)
+        renderer.template(name, format, scope, &block)
+      end
+
+      def partial(name, scope, &block)
+        renderer.partial(name, format, scope, &block)
+      end
+
+      def part(name, value, as: nil)
+        part_builder.(name, value, as: as, rendering: self)
+      end
+
+      def scope(name = nil, locals) # rubocop:disable Style/OptionalArguments
+        scope_builder.(name, locals: locals, rendering: self)
+      end
+    end
+  end
+end

data/lib/hanami/view/{render_environment_missing.rb → rendering_missing.rb}

@@ -1,39 +1,34 @@
 # frozen_string_literal: true
 
 require "dry/inflector"
+require_relative "errors"
 
 module Hanami
   class View
     # @api private
-    class RenderEnvironmentMissing
-      class MissingEnvironmentError < StandardError
-        def message
-          "a +render_env+ must be provided"
-        end
-      end
-
+    class RenderingMissing
       def format
-        raise MissingEnvironmentError
+        raise RenderingMissingError
       end
 
       def context
-        raise MissingEnvironmentError
+        raise RenderingMissingError
       end
 
       def part(_name, _value, **_options)
-        raise MissingEnvironmentError
+        raise RenderingMissingError
       end
 
       def scope(_name = nil, _locals) # rubocop:disable Style/OptionalArguments
-        raise MissingEnvironmentError
+        raise RenderingMissingError
       end
 
       def template(_name, _scope)
-        raise MissingEnvironmentError
+        raise RenderingMissingError
       end
 
       def partial(_name, _scope)
-        raise MissingEnvironmentError
+        raise RenderingMissingError
       end
 
       def inflector

data/lib/hanami/view/scope.rb

@@ -2,7 +2,6 @@
 
 require "dry/core/equalizer"
 require "dry/core/constants"
-require_relative "render_environment_missing"
 
 module Hanami
   class View
@@ -21,7 +20,7 @@ module Hanami
       # @api private
       CONVENIENCE_METHODS = %i[format context locals].freeze
 
-      include Dry::Equalizer(:_name, :_locals, :_render_env)
+      include Dry::Equalizer(:_name, :_locals, :_rendering)
 
       # The scope's name
       #
@@ -43,18 +42,18 @@ module Hanami
       # @api public
       attr_reader :_locals
 
-      # The current render environment
+      # The current rendering
       #
-      # @return [RenderEnvironment] render environment
+      # @return [Rendering]
       #
       # @api private
-      attr_reader :_render_env
+      attr_reader :_rendering
 
       # Returns a new Scope instance
       #
       # @param name [Symbol, nil] scope name
       # @param locals [Hash<Symbol, Object>] template locals
-      # @param render_env [RenderEnvironment] render environment
+      # @param rendering [Rendering] the current rendering
       #
       # @return [Scope]
       #
@@ -62,11 +61,11 @@ module Hanami
       def initialize(
         name: nil,
         locals: Dry::Core::Constants::EMPTY_HASH,
-        render_env: RenderEnvironmentMissing.new
+        rendering: RenderingMissing.new
       )
         @_name = name
         @_locals = locals
-        @_render_env = render_env
+        @_rendering = rendering
       end
 
       # @overload render(partial_name, **locals, &block)
@@ -96,7 +95,7 @@ module Hanami
           partial_name = _inflector.underscore(_inflector.demodulize(partial_name.to_s))
         end
 
-        _render_env.partial(partial_name, _render_scope(**locals), &block)
+        _rendering.partial(partial_name, _render_scope(**locals), &block)
       end
 
       # Build a new scope using a scope class matching the provided name
@@ -108,7 +107,7 @@ module Hanami
       #
       # @api public
       def scope(name = nil, **locals)
-        _render_env.scope(name, locals)
+        _rendering.scope(name, locals)
       end
 
       # The template format for the current render environment.
@@ -123,7 +122,7 @@ module Hanami
       #
       # @api public
       def _format
-        _render_env.format
+        _rendering.format
       end
 
       # The context object for the current render environment
@@ -138,7 +137,7 @@ module Hanami
       #
       # @api public
       def _context
-        _render_env.context
+        _rendering.context
       end
 
       private
@@ -164,7 +163,7 @@ module Hanami
 
       def respond_to_missing?(name, include_private = false)
         _locals.key?(name) ||
-          _render_env.context.respond_to?(name) ||
+          _rendering.context.respond_to?(name) ||
           CONVENIENCE_METHODS.include?(name) ||
           super
       end
@@ -176,13 +175,13 @@ module Hanami
           self.class.new(
             # FIXME: what about `name`?
             locals: locals,
-            render_env: _render_env
+            rendering: _rendering
           )
         end
       end
 
       def _inflector
-        _render_env.inflector
+        _rendering.inflector
       end
     end
   end

data/lib/hanami/view/scope_builder.rb

@@ -1,97 +1,61 @@
 # frozen_string_literal: true
 
-require "dry/core/cache"
-require "dry/core/equalizer"
-require_relative "scope"
-
 module Hanami
   class View
     # Builds scope objects via matching classes
     #
     # @api private
     class ScopeBuilder
-      extend Dry::Core::Cache
-      include Dry::Equalizer(:namespace)
-
-      # The view's configured `scope_namespace`
-      #
-      # @api private
-      attr_reader :namespace
-
-      # @return [RenderEnvironment]
-      #
-      # @api private
-      attr_reader :render_env
-
-      # Returns a new instance of ScopeBuilder
-      #
-      # @api private
-      def initialize(namespace: nil, render_env: nil)
-        @namespace = namespace
-        @render_env = render_env
-      end
-
-      # @api private
-      def for_render_env(render_env)
-        return self if render_env == self.render_env
-
-        self.class.new(namespace: namespace, render_env: render_env)
-      end
-
-      # Returns a new scope using a class matching the name
-      #
-      # @param name [Symbol, Class] scope name
-      # @param locals [Hash<Symbol, Object>] locals hash
-      #
-      # @return [Hanami::View::Scope]
-      #
-      # @api private
-      def call(name = nil, locals) # rubocop:disable Style/OptionalArguments
-        scope_class(name).new(
-          name: name,
-          locals: locals,
-          render_env: render_env
-        )
-      end
-
-      private
-
-      DEFAULT_SCOPE_CLASS = Scope
+      class << self
+        # Returns a new scope using a class matching the name
+        #
+        # @param name [Symbol, Class] scope name
+        # @param locals [Hash<Symbol, Object>] locals hash
+        #
+        # @return [Hanami::View::Scope]
+        #
+        # @api private
+        def call(name = nil, locals:, rendering:) # rubocop:disable Style/OptionalArguments
+          klass = scope_class(name, rendering: rendering)
+
+          klass.new(name: name, locals: locals, rendering: rendering)
+        end
 
-      def scope_class(name = nil)
-        if name.nil?
-          DEFAULT_SCOPE_CLASS
-        elsif name.is_a?(Class)
-          name
-        else
-          fetch_or_store(namespace, name) do
-            resolve_scope_class(name: name)
+        private
+
+        def scope_class(name = nil, rendering:)
+          if name.nil?
+            rendering.config.scope_class
+          elsif name.is_a?(Class)
+            name
+          else
+            View.cache.fetch_or_store(:scope_class, rendering.config) do
+              resolve_scope_class(name: name, rendering: rendering)
+            end
           end
         end
-      end
 
-      def resolve_scope_class(name:)
-        name = inflector.camelize(name.to_s)
+        def resolve_scope_class(name:, rendering:)
+          name = rendering.inflector.camelize(name.to_s)
 
-        # Give autoloaders a chance to act
-        begin
-          klass = namespace.const_get(name)
-        rescue NameError # rubocop:disable Lint/HandleExceptions
-        end
+          namespace = rendering.config.scope_namespace
 
-        if !klass && namespace.const_defined?(name, false)
-          klass = namespace.const_get(name)
-        end
+          # Give autoloaders a chance to act
+          begin
+            klass = namespace.const_get(name)
+          rescue NameError # rubocop:disable Lint/HandleExceptions
+          end
 
-        if klass && klass < Scope
-          klass
-        else
-          DEFAULT_SCOPE_CLASS
-        end
-      end
+          if !klass && namespace.const_defined?(name, false)
+            klass = namespace.const_get(name)
+          end
 
-      def inflector
-        render_env.inflector
+          if klass && klass < Scope
+            klass
+          else
+            rendering.config.scope_class
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "haml"
+
+module Hanami
+  class View
+    module Tilt
+      # @api private
+      module HamlAdapter
+        # Add options to Haml::Engine to match the options from its default generator.
+        #
+        # The default generator for Haml::Engine is configurable via an engine option, like so:
+        #
+        # use :Generator, -> { options[:generator] }
+        #
+        # Because this Temple filter is set as a proc, the resulting effect within Temple's EngineDSL
+        # is that the generator's valid options are not merged into the full set of options available
+        # on Haml::Engine itself. This means we receive a "Option :capture_generator is invalid"
+        # warning when we set our `capture_generator:` below.
+        #
+        # However, this option is perfectly valid, so here we merge all the options for Haml's default
+        # generator into the top-level engine's options, avoiding the warning.
+        ::Haml::Engine.define_options(::Haml::Engine.options[:generator].options.valid_keys)
+
+        # Haml template renderer for Hanami::View.
+        #
+        # This differs from the standard Haml::Template by automatically escaping HTML based on a
+        # given string's `#html_safe?`, regardless of when "hanami/view/html" is required.
+        #
+        # @see Hanami::View::Tilt
+        # @api private
+        Template = Temple::Templates::Tilt(
+          ::Haml::Engine,
+          use_html_safe: true,
+          capture_generator: HTMLSafeStringBuffer,
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "slim"
+
+module Hanami
+  class View
+    module Tilt
+      # @api private
+      module SlimAdapter
+        # Add options to Slim::Engine to match the options from its default generator.
+        #
+        # The default generator for Slim::Engine is configurable via an engine option, like so:
+        #
+        # use(:Generator) { options[:generator] }
+        #
+        # Because this Temple filter is set as a proc, the resulting effect within Temple's EngineDSL
+        # is that the generator's valid options are not merged into the full set of options available
+        # on Slim::Engine itself. This means we receive a "Option :capture_generator is invalid"
+        # warning when we set our `capture_generator:` below.
+        #
+        # However, this option is perfectly valid, so here we merge all the options for Slim's default
+        # generator into the top-level engine's options, avoiding the warning.
+        ::Slim::Engine.define_options(::Slim::Engine.options[:generator].options.valid_keys)
+
+        # Slim template renderer for Hanami::View.
+        #
+        # This differs from the standard Slim::Template by automatically escaping HTML based on a
+        # given string's `#html_safe?`, regardless of when "hanami/view/html" is required.
+        #
+        # @see Hanami::View::Tilt
+        # @api private
+        Template = Temple::Templates::Tilt(
+          ::Slim::Engine,
+          use_html_safe: true,
+          capture_generator: HTMLSafeStringBuffer,
+        )
+      end
+    end
+  end
+end