dry-view 0.5.1 → 0.7.1

data/lib/dry/view/part_builder.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "dry/core/cache"
+require "dry/core/equalizer"
+require_relative "part"
+
+module Dry
+  class View
+    # Decorates exposure values with matching parts
+    #
+    # @api private
+    class PartBuilder
+      extend Dry::Core::Cache
+      include Dry::Equalizer(:namespace)
+
+      attr_reader :namespace
+      attr_reader :render_env
+
+      # Returns a new instance of PartBuilder
+      #
+      # @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
+
+      # Decorates an exposure value
+      #
+      # @param name [Symbol] exposure name
+      # @param value [Object] exposure value
+      # @param options [Hash] exposure options
+      #
+      # @return [Dry::View::Part] decorated value
+      #
+      # @api private
+      def call(name, value, **options)
+        builder = value.respond_to?(:to_ary) ? :build_collection_part : :build_part
+
+        send(builder, name, value, **options)
+      end
+
+      private
+
+      def build_part(name, value, **options)
+        klass = part_class(name: name, **options)
+
+        klass.new(
+          name: name,
+          value: value,
+          render_env: render_env
+        )
+      end
+
+      def build_collection_part(name, value, **options)
+        collection_as = collection_options(name: name, **options)[:as]
+        item_name, item_as = collection_item_options(name: name, **options).values_at(:name, :as)
+
+        arr = value.to_ary.map { |obj|
+          build_part(item_name, obj, **options.merge(as: item_as))
+        }
+
+        build_part(name, arr, **options.merge(as: collection_as))
+      end
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def collection_options(name:, **options)
+        collection_as = options[:as].is_a?(Array) ? options[:as].first : nil
+
+        options.merge(as: collection_as)
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      def collection_item_options(name:, **options)
+        singular_name = inflector.singularize(name).to_sym
+        singular_as =
+          if options[:as].is_a?(Array)
+            options[:as].last if options[:as].length > 1
+          else
+            options[:as]
+          end
+
+        if singular_as && !singular_as.is_a?(Class)
+          singular_as = inflector.singularize(singular_as.to_s)
+        end
+
+        options.merge(
+          name: singular_name,
+          as: singular_as
+        )
+      end
+
+      def part_class(name:, fallback_class: Part, **options)
+        name = options[:as] || name
+
+        if name.is_a?(Class)
+          name
+        else
+          fetch_or_store(namespace, name, fallback_class) do
+            resolve_part_class(name: name, fallback_class: fallback_class)
+          end
+        end
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity
+      def resolve_part_class(name:, fallback_class:)
+        return fallback_class unless namespace
+
+        name = inflector.camelize(name.to_s)
+
+        # Give autoloaders a chance to act
+        begin
+          klass = namespace.const_get(name)
+        rescue NameError # rubocop:disable Lint/HandleExceptions
+        end
+
+        if !klass && namespace.const_defined?(name, false)
+          klass = namespace.const_get(name)
+        end
+
+        if klass && klass < Part
+          klass
+        else
+          fallback_class
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def inflector
+        render_env.inflector
+      end
+    end
+  end
+end

data/lib/dry/view/path.rb

@@ -1,19 +1,36 @@
+# frozen_string_literal: true
+
 require "pathname"
+require "dry/core/cache"
 
 module Dry
-  module View
+  class View
+    # @api private
     class Path
+      extend Dry::Core::Cache
       include Dry::Equalizer(:dir, :root)
 
       attr_reader :dir, :root
 
-      def initialize(dir, options = {})
+      def self.[](path)
+        if path.is_a?(self)
+          path
+        else
+          new(path)
+        end
+      end
+
+      def initialize(dir, root: dir)
         @dir = Pathname(dir)
-        @root = Pathname(options.fetch(:root, dir))
+        @root = Pathname(root)
       end
 
-      def lookup(name, format)
-        template?(name, format) || template?("shared/#{name}", format) || !root? && chdir('..').lookup(name, format)
+      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)
@@ -21,7 +38,7 @@ module Dry
       end
 
       def to_s
-        dir
+        dir.to_s
       end
 
       private
@@ -31,10 +48,21 @@ module Dry
       end
 
       # Search for a template using a wildcard for the engine extension
-      def template?(name, format)
+      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/dry/view/render_environment.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module Dry
+  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/dry/view/render_environment_missing.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+module Dry
+  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/dry/view/rendered.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module Dry
+  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, Dry::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 [Dry::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/dry/view/renderer.rb

@@ -1,41 +1,48 @@
-require 'tilt'
-require 'dry-equalizer'
+# frozen_string_literal: true
+
+require "dry/core/cache"
+require "dry/core/equalizer"
+require_relative "errors"
+require_relative "tilt"
 
 module Dry
-  module View
+  class View
+    # @api private
     class Renderer
-      PARTIAL_PREFIX = "_".freeze
-      PATH_DELIMITER = "/".freeze
-
-      include Dry::Equalizer(:paths, :format)
+      PARTIAL_PREFIX = "_"
+      PATH_DELIMITER = "/"
 
-      TemplateNotFoundError = Class.new(StandardError)
+      extend Dry::Core::Cache
 
-      attr_reader :paths, :format, :engine, :tilts
+      include Dry::Equalizer(:paths, :format, :engine_mapping, :options)
 
-      def self.tilts
-        @__engines__ ||= {}
-      end
+      attr_reader :paths, :format, :engine_mapping, :options
 
-      def initialize(paths, format:)
+      def initialize(paths, format:, engine_mapping: nil, **options)
         @paths = paths
         @format = format
-        @tilts = self.class.tilts
+        @engine_mapping = engine_mapping || {}
+        @options = options
       end
 
-      def template(name, scope, &block)
-        path = lookup(name)
+      def template(name, scope, **lookup_options, &block)
+        path = lookup(name, **lookup_options)
 
         if path
           render(path, scope, &block)
         else
-          msg = "Template #{name.inspect} could not be found in paths:\n#{paths.map { |pa| "- #{pa.to_s}" }.join("\n")}"
-          raise TemplateNotFoundError, msg
+          raise TemplateNotFoundError.new(name, paths)
         end
       end
 
       def partial(name, scope, &block)
-        template(name_for_partial(name), scope, &block)
+        template(
+          name_for_partial(name),
+          scope,
+          child_dirs: %w[shared],
+          parent_dir: true,
+          &block
+        )
       end
 
       def render(path, scope, &block)
@@ -45,26 +52,26 @@ module Dry
       def chdir(dirname)
         new_paths = paths.map { |path| path.chdir(dirname) }
 
-        self.class.new(new_paths, format: format)
+        self.class.new(new_paths, format: format, **options)
       end
 
-      def lookup(name)
-        paths.inject(false) { |result, path|
-          result || path.lookup(name, format)
+      private
+
+      def lookup(name, **options)
+        paths.inject(nil) { |_, path|
+          result = path.lookup(name, format, **options)
+          break result if result
         }
       end
 
-      private
-
       def name_for_partial(name)
         name_segments = name.to_s.split(PATH_DELIMITER)
-        partial_name = name_segments[0..-2].push("#{PARTIAL_PREFIX}#{name_segments[-1]}").join(PATH_DELIMITER)
+        name_segments[0..-2].push("#{PARTIAL_PREFIX}#{name_segments[-1]}").join(PATH_DELIMITER)
       end
 
-      # TODO: make default_encoding configurable
       def tilt(path)
-        tilts.fetch(path) {
-          tilts[path] = Tilt.new(path, nil, default_encoding: "utf-8")
+        fetch_or_store(:engine, path, engine_mapping, options) {
+          Tilt[path, engine_mapping, **options]
         }
       end
     end