dry-view 0.5.1 → 0.7.1

data/lib/dry/view/scope.rb

@@ -1,43 +1,189 @@
-require 'dry-equalizer'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/core/constants"
+require_relative "render_environment_missing"
 
 module Dry
-  module View
+  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
-      include Dry::Equalizer(:_locals, :_context, :_renderer)
+      # @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
-      attr_reader :_context
-      attr_reader :_renderer
 
-      def initialize(renderer:, context: nil, 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
-        @_context = context
-        @_renderer = renderer
+        @_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
 
-      def render(partial_name, **locals, &block)
-        _renderer.partial(partial_name, __render_scope(locals), &block)
+      # 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 __render_scope(**locals)
-        if locals.any?
-          self.class.new(renderer: _renderer, context: _context, locals: locals)
-        else
+      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

data/lib/dry/view/scope_builder.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "dry/core/cache"
+require "dry/core/equalizer"
+require_relative "scope"
+
+module Dry
+  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 [Dry::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
+
+      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)
+          end
+        end
+      end
+
+      def resolve_scope_class(name:)
+        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 < Scope
+          klass
+        else
+          DEFAULT_SCOPE_CLASS
+        end
+      end
+
+      def inflector
+        render_env.inflector
+      end
+    end
+  end
+end

data/lib/dry/view/tilt.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "dry/core/cache"
+require "tilt"
+
+module Dry
+  class View
+    # @api private
+    module Tilt
+      extend Dry::Core::Cache
+
+      class << self
+        def [](path, mapping, **options)
+          ext = File.extname(path).sub(/^./, "").to_sym
+          activate_adapter ext
+
+          with_mapping(mapping).new(path, **options)
+        end
+
+        def default_mapping
+          ::Tilt.default_mapping
+        end
+
+        def register_adapter(ext, adapter)
+          adapters[ext] = adapter
+        end
+
+        def deregister_adapter(ext)
+          adapters.delete(ext)
+        end
+
+        private
+
+        def adapters
+          @adapters ||= {}
+        end
+
+        def activate_adapter(ext)
+          fetch_or_store(:adapter, ext) {
+            adapter = adapters[ext]
+            return unless adapter
+
+            *requires, error_message = adapter.requirements
+
+            begin
+              requires.each(&method(:require))
+            rescue LoadError => e
+              raise e, "#{e.message}\n\n#{error_message}"
+            end
+
+            adapter.activate
+          }
+        end
+
+        def with_mapping(mapping)
+          fetch_or_store(:mapping, mapping) {
+            if mapping.any?
+              build_mapping(mapping)
+            else
+              default_mapping
+            end
+          }
+        end
+
+        def build_mapping(mapping)
+          default_mapping.dup.tap do |new_mapping|
+            mapping.each do |extension, template_class|
+              new_mapping.register template_class, extension
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "tilt/erb"
+require_relative "tilt/haml"

data/lib/dry/view/tilt/erb.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Dry
+  class View
+    module Tilt
+      module ERB
+        def self.requirements
+          ["dry/view/tilt/erbse", <<~ERROR]
+            dry-view requires erbse for full compatibility when rendering .erb templates (e.g. implicitly capturing block content when yielding)
+
+            To ignore this and use another engine for .erb templates, deregister this adapter before calling your views:
+
+            Dry::View::Tilt.deregister_adapter(:erb)
+          ERROR
+        end
+
+        def self.activate
+          Tilt.default_mapping.register ErbseTemplate, "erb"
+          self
+        end
+      end
+
+      register_adapter :erb, ERB
+    end
+  end
+end

data/lib/dry/view/tilt/erbse.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "tilt/template"
+require "erbse"
+
+module Dry
+  class View
+    module Tilt
+      # Tilt template class copied from cells-erb gem
+      class ErbseTemplate < ::Tilt::Template
+        def prepare
+          @template = ::Erbse::Engine.new
+        end
+
+        def precompiled_template(_locals)
+          @template.call(data)
+        end
+      end
+    end
+  end
+end

data/lib/dry/view/tilt/haml.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Dry
+  class View
+    module Tilt
+      module Haml
+        def self.requirements
+          ["hamlit/block", <<~ERROR]
+            dry-view requires hamlit-block for full compatibility when rendering .haml templates (e.g. implicitly capturing block content when yielding)
+
+            To ignore this and use another engine for .haml templates, dereigster this adapter before calling your views:
+
+            Dry::View::Tilt.deregister_adatper(:haml)
+          ERROR
+        end
+
+        def self.activate
+          # Requiring hamlit/block will register the engine with Tilt
+          self
+        end
+      end
+
+      register_adapter :haml, Haml
+    end
+  end
+end