hanami-view 1.3.3 → 2.0.0.alpha2

data/lib/hanami/view/path.rb

@@ -0,0 +1,68 @@
+# 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
+
+      def self.[](path)
+        if path.is_a?(self)
+          path
+        else
+          new(path)
+        end
+      end
+
+      def initialize(dir, root: dir)
+        @dir = Pathname(dir)
+        @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
+      end
+
+      def chdir(dirname)
+        self.class.new(dir.join(dirname), root: root)
+      end
+
+      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/render_environment.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module Hanami
+  class View
+    # @api private
+    class RenderEnvironment
+      def self.prepare(renderer, config, context)
+        new(
+          renderer: renderer,
+          inflector: config.inflector,
+          context: context,
+          scope_builder: config.scope_builder.new(namespace: config.scope_namespace),
+          part_builder: config.part_builder.new(namespace: config.part_namespace)
+        )
+      end
+
+      include Dry::Equalizer(:renderer, :inflector, :context, :scope_builder, :part_builder)
+
+      attr_reader :renderer, :inflector, :context, :scope_builder, :part_builder
+
+      def initialize(renderer:, inflector:, context:, scope_builder:, part_builder:)
+        @renderer = renderer
+        @inflector = inflector
+        @context = context.for_render_env(self)
+        @scope_builder = scope_builder.for_render_env(self)
+        @part_builder = part_builder.for_render_env(self)
+      end
+
+      def format
+        renderer.format
+      end
+
+      def part(name, value, **options)
+        part_builder.(name, value, **options)
+      end
+
+      def scope(name = nil, locals) # rubocop:disable Style/OptionalArguments
+        scope_builder.(name, locals)
+      end
+
+      def template(name, scope, &block)
+        renderer.template(name, scope, &block)
+      end
+
+      def partial(name, scope, &block)
+        renderer.partial(name, scope, &block)
+      end
+
+      def chdir(dirname)
+        self.class.new(
+          renderer: renderer.chdir(dirname),
+          inflector: inflector,
+          context: context,
+          scope_builder: scope_builder,
+          part_builder: part_builder
+        )
+      end
+    end
+  end
+end

data/lib/hanami/view/render_environment_missing.rb

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

data/lib/hanami/view/rendered.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module Hanami
+  class View
+    # Output of a View rendering
+    #
+    # @api public
+    class Rendered
+      include Dry::Equalizer(:output, :locals)
+
+      # Returns the rendered view
+      #
+      # @return [String]
+      #
+      # @api public
+      attr_reader :output
+
+      # Returns the hash of locals used to render the view
+      #
+      # @return [Hash[<Symbol, Hanami::View::Part>] locals hash
+      #
+      # @api public
+      attr_reader :locals
+
+      # @api private
+      def initialize(output:, locals:)
+        @output = output
+        @locals = locals
+      end
+
+      # Returns the local corresponding to the key
+      #
+      # @param name [Symbol] local key
+      #
+      # @return [Hanami::View::Part]
+      #
+      # @api public
+      def [](name)
+        locals[name]
+      end
+
+      # Returns the rendered view
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        output
+      end
+      alias_method :to_str, :to_s
+    end
+  end
+end

data/lib/hanami/view/renderer.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "dry/core/cache"
+require "dry/core/equalizer"
+require_relative "errors"
+require_relative "tilt"
+
+module Hanami
+  class View
+    # @api private
+    class Renderer
+      PARTIAL_PREFIX = "_"
+      PATH_DELIMITER = "/"
+
+      extend Dry::Core::Cache
+
+      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
+      end
+
+      def template(name, scope, **lookup_options, &block)
+        path = lookup(name, **lookup_options)
+
+        if path
+          render(path, scope, &block)
+        else
+          raise TemplateNotFoundError.new(name, paths)
+        end
+      end
+
+      def partial(name, scope, &block)
+        template(
+          name_for_partial(name),
+          scope,
+          child_dirs: %w[shared],
+          parent_dir: true,
+          &block
+        )
+      end
+
+      def render(path, scope, &block)
+        tilt(path).render(scope, &block)
+      end
+
+      def chdir(dirname)
+        new_paths = paths.map { |path| path.chdir(dirname) }
+
+        self.class.new(new_paths, format: format, **options)
+      end
+
+      private
+
+      def lookup(name, **options)
+        paths.inject(nil) { |_, path|
+          result = path.lookup(name, format, **options)
+          break result if result
+        }
+      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)
+      end
+
+      def tilt(path)
+        fetch_or_store(:engine, path, engine_mapping, options) {
+          Tilt[path, engine_mapping, **options]
+        }
+      end
+    end
+  end
+end

data/lib/hanami/view/scope.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/core/constants"
+require_relative "render_environment_missing"
+
+module Hanami
+  class View
+    # Evaluation context for templates (including layouts and partials) and
+    # provides a place to encapsulate view-specific behaviour alongside a
+    # template and its locals.
+    #
+    # @abstract Subclass this and provide your own methods adding view-specific
+    #   behavior. You should not override `#initialize`
+    #
+    # @see https://dry-rb.org/gems/dry-view/templates/
+    # @see https://dry-rb.org/gems/dry-view/scopes/
+    #
+    # @api public
+    class Scope
+      # @api private
+      CONVENIENCE_METHODS = %i[format context locals].freeze
+
+      include Dry::Equalizer(:_name, :_locals, :_render_env)
+
+      # The scope's name
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      attr_reader :_name
+
+      # The scope's locals
+      #
+      # @overload _locals
+      #   Returns the locals
+      # @overload locals
+      #   A convenience alias for `#_format.` Is available unless there is a
+      #   local named `locals`
+      #
+      # @return [Hash[<Symbol, Object>]
+      #
+      # @api public
+      attr_reader :_locals
+
+      # The current render environment
+      #
+      # @return [RenderEnvironment] render environment
+      #
+      # @api private
+      attr_reader :_render_env
+
+      # Returns a new Scope instance
+      #
+      # @param name [Symbol, nil] scope name
+      # @param locals [Hash<Symbol, Object>] template locals
+      # @param render_env [RenderEnvironment] render environment
+      #
+      # @return [Scope]
+      #
+      # @api public
+      def initialize(
+        name: nil,
+        locals: Dry::Core::Constants::EMPTY_HASH,
+        render_env: RenderEnvironmentMissing.new
+      )
+        @_name = name
+        @_locals = locals
+        @_render_env = render_env
+      end
+
+      # @overload render(partial_name, **locals, &block)
+      #   Renders a partial using the scope
+      #
+      #   @param partial_name [Symbol, String] partial name
+      #   @param locals [Hash<Symbol, Object>] partial locals
+      #   @yieldreturn [String] string content to include where the partial calls `yield`
+      #
+      # @overload render(**locals, &block)
+      #   Renders a partial (named after the scope's own name) using the scope
+      #
+      #   @param locals[Hash<Symbol, Object>] partial locals
+      #   @yieldreturn [String] string content to include where the partial calls `yield`
+      #
+      # @return [String] the rendered partial output
+      #
+      # @api public
+      def render(partial_name = nil, **locals, &block)
+        partial_name ||= _name
+
+        unless partial_name
+          raise ArgumentError, "+partial_name+ must be provided for unnamed scopes"
+        end
+
+        if partial_name.is_a?(Class)
+          partial_name = _inflector.underscore(_inflector.demodulize(partial_name.to_s))
+        end
+
+        _render_env.partial(partial_name, _render_scope(**locals), &block)
+      end
+
+      # Build a new scope using a scope class matching the provided name
+      #
+      # @param name [Symbol, Class] scope name (or class)
+      # @param locals [Hash<Symbol, Object>] scope locals
+      #
+      # @return [Scope]
+      #
+      # @api public
+      def scope(name = nil, **locals)
+        _render_env.scope(name, locals)
+      end
+
+      # The template format for the current render environment.
+      #
+      # @overload _format
+      #   Returns the format.
+      # @overload format
+      #   A convenience alias for `#_format.` Is available unless there is a
+      #   local named `format`
+      #
+      # @return [Symbol] format
+      #
+      # @api public
+      def _format
+        _render_env.format
+      end
+
+      # The context object for the current render environment
+      #
+      # @overload _context
+      #   Returns the context.
+      # @overload context
+      #   A convenience alias for `#_context`. Is available unless there is a
+      #   local named `context`.
+      #
+      # @return [Context] context
+      #
+      # @api public
+      def _context
+        _render_env.context
+      end
+
+      private
+
+      # Handles missing methods, according to the following rules:
+      #
+      # 1. If there is a local with a name matching the method, it returns the
+      #    local.
+      # 2. If the `context` responds to the method, then it will be sent the
+      #    method and all its arguments.
+      def method_missing(name, *args, &block)
+        if _locals.key?(name)
+          _locals[name]
+        elsif _context.respond_to?(name)
+          _context.public_send(name, *args, &block)
+        elsif CONVENIENCE_METHODS.include?(name)
+          __send__(:"_#{name}", *args, &block)
+        else
+          super
+        end
+      end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+
+      def respond_to_missing?(name, include_private = false)
+        _locals.key?(name) ||
+          _render_env.context.respond_to?(name) ||
+          CONVENIENCE_METHODS.include?(name) ||
+          super
+      end
+
+      def _render_scope(**locals)
+        if locals.none?
+          self
+        else
+          self.class.new(
+            # FIXME: what about `name`?
+            locals: locals,
+            render_env: _render_env
+          )
+        end
+      end
+
+      def _inflector
+        _render_env.inflector
+      end
+    end
+  end
+end