hanami-view 2.0.0.alpha5 → 2.0.0.alpha8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec11d28fb1ab17f2de3bfa384fce768648a6975f6f5261795b239069733a5df2
-  data.tar.gz: 6f631fa7bdd6528d406534f074ec7df1823e46a4ae692a0c4b83e6c8ba30efbf
+  metadata.gz: d49c664876b44d1be9f65e7d9c472a3fe50ab40d42002b170a4a2121ddf2f095
+  data.tar.gz: 51508250526dd6af93f2f8d1af2031e37c39109896a0b92fac038b99a65e1512
 SHA512:
-  metadata.gz: 6ca038a05ffb5361ca9e61820af0487498f3a6dee0842f33f5f51577127e36fd6f97eea13df0984a64cb66d093a0c331a943736856589062310f1b0c2d40eada
-  data.tar.gz: 3468190981d001cbb87618779abae17ce19700cb7855ac70db09db5895f23cea4056ea580aa967b7a59f1168d6801fc93129184aa4afcfb871682e1386feb0ed
+  metadata.gz: e08aff9c75a5c412922f6e7669078e0a88258d8aa6d80b7b56569ce3732a15e703861e7a713381c1e928cbe5e5a67f1ac51e2473a9de85868ca9c895184e838e
+  data.tar.gz: cdad93f677870279dad0fb101dbfc03b4da79d78f78f3f1d6de5fdc50b7e7b0f4e69aef6b9b360049aaa2ff45d2e15beb24b2afe6116a87c07a17eb9eb0219eb

data/CHANGELOG.md

@@ -1,6 +1,34 @@
 # Hanami::View
 View layer for Hanami
 
+## v2.0.0.alpha8 - 2022-05-19
+
+### Added
+- [Tim Riley] Access a hash of template locals via accessing `locals` inside any template
+
+### Changed
+- [Tim Riley] Removed automatic integration of `Hanami::View` subclasses with their surrounding Hanami application. View base classes within Hanami apps should inherit from `Hanami::Application::View` instead.
+
+## v2.0.0.alpha7 - 2022-03-08
+
+### Added
+- [Luca Guidi] Automatically inject the app's `settings` and `assets` components (if present) into instances of `Hanami::View::ApplicationContext`
+- [Luca Guidi] Temporarily added to `Hanami::View::ApplicationContext` the `#content_for`, `#current_path` `#csrf_token` helpers, ported from the hanami-2-application-template. Some of those helpers will be moved to `hanami-helpers` gem in a later release.
+
+### Changed
+- [Sean Collins] For views within an Hanami application, changed default location for templates from "web/templates" to "templates"
+- [Luca Guidi] For views within an Hanami application, the default `part_namespace` is now `"view/parts"` (previously `"views/parts"`)
+
+## Fixed
+- [Luca Guidi] Application-level configuration is now applied to `Hanami::View` subclasses, no matter how deep their inheritance chain (e.g. app base view -> slice base view -> slice view)
+
+## v2.0.0.alpha6 - 2022-02-10
+### Added
+- [Luca Guidi] Official support for Ruby: MRI 3.0 and 3.1
+
+### Changed
+- [Luca Guidi] Drop support for Ruby: MRI 2.3, 2.4, 2.5, 2.6, and 2.7.
+
 ## v2.0.0.alpha5 - 2022-01-12
 ### Added
 - [Marc Busqué] Automatically provide access to Hanami application routes helper as `routes` in default application view context (`Hanami::View::ApplicationContext`)

data/README.md

@@ -26,7 +26,7 @@ A view layer for [Hanami](http://hanamirb.org)
 
 ## Rubies
 
-__Hanami::view__ supports Ruby (MRI) 2.6+
+__Hanami::view__ supports Ruby (MRI) 3.0+
 
 ## Installation
 

data/hanami-view.gemspec

@@ -18,13 +18,14 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'bin'
   spec.executables   = []
   spec.require_paths = ['lib']
+  spec.metadata["rubygems_mfa_required"] = "true"
 
   spec.metadata['allowed_push_host'] = 'https://rubygems.org'
   spec.metadata['changelog_uri']     = 'https://github.com/hanami/view/blob/main/CHANGELOG.md'
   spec.metadata['source_code_uri']   = 'https://github.com/hanami/view'
   spec.metadata['bug_tracker_uri']   = 'https://github.com/hanami/view/issues'
 
-  spec.required_ruby_version = ">= 2.4.0"
+  spec.required_ruby_version = ">= 3.0"
 
   spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
   spec.add_runtime_dependency "dry-configurable", "~> 0.13", ">= 0.13.0"

data/lib/hanami/view/context.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "dry/core/equalizer"
-require_relative "application_context"
 require_relative "decorated_attributes"
 
 module Hanami
@@ -19,23 +18,6 @@ module Hanami
 
       attr_reader :_render_env, :_options
 
-      def self.inherited(subclass)
-        super
-
-        # When inheriting within an Hanami app, add application context behavior
-        provider = application_provider(subclass)
-        if provider
-          subclass.include ApplicationContext.new(provider)
-        end
-      end
-
-      def self.application_provider(subclass)
-        if Hanami.respond_to?(:application?) && Hanami.application?
-          Hanami.application.component_provider(subclass)
-        end
-      end
-      private_class_method :application_provider
-
       # Returns a new instance of Context
       #
       # In subclasses, you should include an `**options` parameter and pass _all

data/lib/hanami/view/errors.rb

@@ -2,6 +2,11 @@
 
 module Hanami
   class View
+    # @since 2.0.0
+    # @api public
+    class Error < StandardError
+    end
+
     # Error raised when critical settings are not configured
     #
     # @api private

data/lib/hanami/view/renderer.rb

@@ -46,7 +46,7 @@ module Hanami
       end
 
       def render(path, scope, &block)
-        tilt(path).render(scope, &block)
+        tilt(path).render(scope, {locals: scope._locals}, &block)
       end
 
       def chdir(dirname)

data/lib/hanami/view/scope.rb

@@ -35,7 +35,7 @@ module Hanami
       # @overload _locals
       #   Returns the locals
       # @overload locals
-      #   A convenience alias for `#_format.` Is available unless there is a
+      #   A convenience alias for `#_locals.` Is available unless there is a
       #   local named `locals`
       #
       # @return [Hash[<Symbol, Object>]

data/lib/hanami/view/version.rb

@@ -3,6 +3,6 @@
 module Hanami
   class View
     # @api private
-    VERSION = "2.0.0.alpha5"
+    VERSION = "2.0.0.alpha8"
   end
 end

data/lib/hanami/view.rb

@@ -15,7 +15,6 @@ require_relative "view/render_environment"
 require_relative "view/rendered"
 require_relative "view/renderer"
 require_relative "view/scope_builder"
-require_relative "view/standalone_view"
 
 module Hanami
   # A standalone, template-based view rendering system that offers everything
@@ -230,23 +229,388 @@ module Hanami
 
     # @!endgroup
 
-    include StandaloneView
-
-    def self.inherited(subclass)
+    # @api private
+    def self.inherited(klass)
       super
 
-      # If inheriting directly from Hanami::View within an Hanami app, configure
-      # the view for the application
-      if subclass.superclass == View && (provider = application_provider(subclass))
-        subclass.include ApplicationView.new(provider)
+      exposures.each do |name, exposure|
+        klass.exposures.import(name, exposure)
       end
     end
 
-    def self.application_provider(subclass)
-      if Hanami.respond_to?(:application?) && Hanami.application?
-        Hanami.application.component_provider(subclass)
+    # @!group Exposures
+
+    # @!macro [new] exposure_options
+    #   @param options [Hash] the exposure's options
+    #   @option options [Boolean] :layout expose this value to the layout (defaults to false)
+    #   @option options [Boolean] :decorate decorate this value in a matching Part (defaults to
+    #     true)
+    #   @option options [Symbol, Class] :as an alternative name or class to use when finding a
+    #     matching Part
+
+    # @overload expose(name, **options, &block)
+    #   Define a value to be passed to the template. The return value of the
+    #   block will be decorated by a matching Part and passed to the template.
+    #
+    #   The block will be evaluated with the view instance as its `self`. The
+    #   block's parameters will determine what it is given:
+    #
+    #   - To receive other exposure values, provide positional parameters
+    #     matching the exposure names. These exposures will already by decorated
+    #     by their Parts.
+    #   - To receive the view's input arguments (whatever is passed to
+    #     `View#call`), provide matching keyword parameters. You can provide
+    #     default values for these parameters to make the corresponding input
+    #     keys optional
+    #   - To receive the Context object, provide a `context:` keyword parameter
+    #   - To receive the view's input arguments in their entirety, provide a
+    #     keywords splat parameter (i.e. `**input`)
+    #
+    #   @example Accessing input arguments
+    #     expose :article do |slug:|
+    #       article_repo.find_by_slug(slug)
+    #     end
+    #
+    #   @example Accessing other exposures
+    #     expose :articles do
+    #       article_repo.listing
+    #     end
+    #
+    #     expose :featured_articles do |articles|
+    #       articles.select(&:featured?)
+    #     end
+    #
+    #   @param name [Symbol] name for the exposure
+    #   @macro exposure_options
+    #
+    # @overload expose(name, **options)
+    #   Define a value to be passed to the template, provided by an instance
+    #   method matching the name. The method's return value will be decorated by
+    #   a matching Part and passed to the template.
+    #
+    #   The method's parameters will determine what it is given:
+    #
+    #   - To receive other exposure values, provide positional parameters
+    #     matching the exposure names. These exposures will already by decorated
+    #     by their Parts.
+    #   - To receive the view's input arguments (whatever is passed to
+    #     `View#call`), provide matching keyword parameters. You can provide
+    #     default values for these parameters to make the corresponding input
+    #     keys optional
+    #   - To receive the Context object, provide a `context:` keyword parameter
+    #   - To receive the view's input arguments in their entirey, provide a
+    #     keywords splat parameter (i.e. `**input`)
+    #
+    #   @example Accessing input arguments
+    #     expose :article
+    #
+    #     def article(slug:)
+    #       article_repo.find_by_slug(slug)
+    #     end
+    #
+    #   @example Accessing other exposures
+    #     expose :articles
+    #     expose :featured_articles
+    #
+    #     def articles
+    #       article_repo.listing
+    #     end
+    #
+    #     def featured_articles
+    #       articles.select(&:featured?)
+    #     end
+    #
+    #   @param name [Symbol] name for the exposure
+    #   @macro exposure_options
+    #
+    # @overload expose(name, **options)
+    #   Define a single value to pass through from the input data (when there is
+    #   no instance method matching the `name`). This value will be decorated by
+    #   a matching Part and passed to the template.
+    #
+    #   @param name [Symbol] name for the exposure
+    #   @macro exposure_options
+    #   @option options [Boolean] :default a default value to provide if there is no matching
+    #     input data
+    #
+    # @overload expose(*names, **options)
+    #   Define multiple values to pass through from the input data (when there
+    #   is no instance methods matching their names). These values will be
+    #   decorated by matching Parts and passed through to the template.
+    #
+    #   The provided options will be applied to all the exposures.
+    #
+    #   @param names [Symbol] names for the exposures
+    #   @macro exposure_options
+    #   @option options [Boolean] :default a default value to provide if there is no matching
+    #     input data
+    #
+    # @see https://dry-rb.org/gems/dry-view/exposures/
+    #
+    # @api public
+    def self.expose(*names, **options, &block)
+      if names.length == 1
+        exposures.add(names.first, block, **options)
+      else
+        names.each do |name|
+          exposures.add(name, **options)
+        end
       end
     end
-    private_class_method :application_provider
+
+    # @api public
+    def self.private_expose(*names, **options, &block)
+      expose(*names, **options, private: true, &block)
+    end
+
+    # Returns the defined exposures. These are unbound, since bound exposures
+    # are only created when initializing a View instance.
+    #
+    # @return [Exposures]
+    # @api private
+    def self.exposures
+      @exposures ||= Exposures.new
+    end
+
+    # @!endgroup
+
+    # @!group Scope
+
+    # Creates and assigns a scope for the current view.
+    #
+    # The newly created scope is useful to add custom logic that is specific
+    # to the view.
+    #
+    # The scope has access to locals, exposures, and inherited scope (if any)
+    #
+    # If the view already has an explicit scope the newly created scope will
+    # inherit from the explicit scope.
+    #
+    # There are two cases when this may happen:
+    #   1. The scope was explicitly assigned (e.g. `config.scope = MyScope`)
+    #   2. The scope has been inherited by the view superclass
+    #
+    # If the view doesn't have an already existing scope, the newly scope
+    # will inherit from `Hanami::View::Scope` by default.
+    #
+    # However, you can specify any base class for it. This is not
+    # recommended, unless you know what you're doing.
+    #
+    # @param scope [Hanami::View::Scope] the current scope (if any), or the
+    #   default base class will be `Hanami::View::Scope`
+    # @param block [Proc] the scope logic definition
+    #
+    # @api public
+    #
+    # @example Basic usage
+    #   class MyView < Hanami::View
+    #     config.scope = MyScope
+    #
+    #     scope do
+    #       def greeting
+    #         _locals[:message].upcase + "!"
+    #       end
+    #
+    #       def copyright(time)
+    #         "Copy #{time.year}"
+    #       end
+    #     end
+    #   end
+    #
+    #   # my_view.html.erb
+    #   # <%= greeting %>
+    #   # <%= copyright(Time.now.utc) %>
+    #
+    #   MyView.new.(message: "Hello") # => "HELLO!"
+    #
+    # @example Inherited scope
+    #   class MyScope < Hanami::View::Scope
+    #     private
+    #
+    #     def shout(string)
+    #       string.upcase + "!"
+    #     end
+    #   end
+    #
+    #   class MyView < Hanami::View
+    #     config.scope = MyScope
+    #
+    #     scope do
+    #       def greeting
+    #         shout(_locals[:message])
+    #       end
+    #
+    #       def copyright(time)
+    #         "Copy #{time.year}"
+    #       end
+    #     end
+    #   end
+    #
+    #   # my_view.html.erb
+    #   # <%= greeting %>
+    #   # <%= copyright(Time.now.utc) %>
+    #
+    #   MyView.new.(message: "Hello") # => "HELLO!"
+    def self.scope(base: config.scope || Hanami::View::Scope, &block)
+      config.scope = Class.new(base, &block)
+    end
+
+    # @!endgroup
+
+    # @!group Render environment
+
+    # Returns a render environment for the view and the given options. This
+    # environment isn't chdir'ed into any particular directory.
+    #
+    # @param format [Symbol] template format to use (defaults to the `default_format` setting)
+    # @param context [Context] context object to use (defaults to the `default_context` setting)
+    #
+    # @see View.template_env render environment for the view's template
+    # @see View.layout_env render environment for the view's layout
+    #
+    # @return [RenderEnvironment]
+    # @api public
+    def self.render_env(format: config.default_format, context: config.default_context)
+      RenderEnvironment.prepare(renderer(format), config, context)
+    end
+
+    # @overload template_env(format: config.default_format, context: config.default_context)
+    #   Returns a render environment for the view and the given options,
+    #   chdir'ed into the view's template directory. This is the environment
+    #   used when rendering the template, and is useful to to fetch
+    #   independently when unit testing Parts and Scopes.
+    #
+    #   @param format [Symbol] template format to use (defaults to the `default_format` setting)
+    #   @param context [Context] context object to use (defaults to the `default_context` setting)
+    #
+    #   @return [RenderEnvironment]
+    #   @api public
+    def self.template_env(**args)
+      render_env(**args).chdir(config.template)
+    end
+
+    # @overload layout_env(format: config.default_format, context: config.default_context)
+    #   Returns a render environment for the view and the given options,
+    #   chdir'ed into the view's layout directory. This is the environment used
+    #   when rendering the view's layout.
+    #
+    #   @param format [Symbol] template format to use (defaults to the `default_format` setting)
+    #   @param context [Context] context object to use (defaults to the `default_context` setting)
+    #
+    #   @return [RenderEnvironment] @api public
+    def self.layout_env(**args)
+      render_env(**args).chdir(layout_path)
+    end
+
+    # Returns renderer for the view and provided format
+    #
+    # @api private
+    def self.renderer(format)
+      fetch_or_store(:renderer, config, format) {
+        Renderer.new(
+          config.paths,
+          format: format,
+          engine_mapping: config.renderer_engine_mapping,
+          **config.renderer_options
+        )
+      }
+    end
+
+    # @api private
+    def self.layout_path
+      File.join(*[config.layouts_dir, config.layout].compact)
+    end
+
+    # @!endgroup
+
+    # Returns an instance of the view. This binds the defined exposures to the
+    # view instance.
+    #
+    # Subclasses can define their own `#initialize` to accept injected
+    # dependencies, but must call `super()` to ensure the standard view
+    # initialization can proceed.
+    #
+    # @api public
+    def initialize
+      @exposures = self.class.exposures.bind(self)
+    end
+
+    # The view's configuration
+    #
+    # @api private
+    def config
+      self.class.config
+    end
+
+    # The view's bound exposures
+    #
+    # @return [Exposures]
+    # @api private
+    def exposures
+      @exposures
+    end
+
+    # Render the view
+    #
+    # @param format [Symbol] template format to use
+    # @param context [Context] context object to use
+    # @param input input data for preparing exposure values
+    #
+    # @return [Rendered] rendered view object
+    # @api public
+    def call(format: config.default_format, context: config.default_context, **input)
+      ensure_config
+
+      env = self.class.render_env(format: format, context: context)
+      template_env = self.class.template_env(format: format, context: context)
+
+      locals = locals(template_env, input)
+      output = env.template(config.template, template_env.scope(config.scope, locals))
+
+      if layout?
+        layout_env = self.class.layout_env(format: format, context: context)
+        begin
+          output = env.template(
+            self.class.layout_path,
+            layout_env.scope(config.scope, layout_locals(locals))
+          ) { output }
+        rescue TemplateNotFoundError
+          raise LayoutNotFoundError.new(config.layout, config.paths)
+        end
+      end
+
+      Rendered.new(output: output, locals: locals)
+    end
+
+    private
+
+    # @api private
+    def ensure_config
+      raise UndefinedConfigError, :paths unless Array(config.paths).any?
+      raise UndefinedConfigError, :template unless config.template
+    end
+
+    # @api private
+    def locals(render_env, input)
+      exposures.(context: render_env.context, **input) do |value, exposure|
+        if exposure.decorate? && value
+          render_env.part(exposure.name, value, **exposure.options)
+        else
+          value
+        end
+      end
+    end
+
+    # @api private
+    def layout_locals(locals)
+      locals.each_with_object({}) do |(key, value), layout_locals|
+        layout_locals[key] = value if exposures[key].for_layout?
+      end
+    end
+
+    # @api private
+    def layout?
+      !!config.layout # rubocop:disable Style/DoubleNegation
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hanami-view
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha5
+  version: 2.0.0.alpha8
 platform: ruby
 authors:
 - Tim Riley
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-12 00:00:00.000000000 Z
+date: 2022-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -156,8 +156,6 @@ files:
 - hanami-view.gemspec
 - lib/hanami-view.rb
 - lib/hanami/view.rb
-- lib/hanami/view/application_configuration.rb
-- lib/hanami/view/application_context.rb
 - lib/hanami/view/application_view.rb
 - lib/hanami/view/context.rb
 - lib/hanami/view/context_helpers/content_helpers.rb
@@ -174,7 +172,6 @@ files:
 - lib/hanami/view/renderer.rb
 - lib/hanami/view/scope.rb
 - lib/hanami/view/scope_builder.rb
-- lib/hanami/view/standalone_view.rb
 - lib/hanami/view/tilt.rb
 - lib/hanami/view/tilt/erb.rb
 - lib/hanami/view/tilt/erbse.rb
@@ -184,6 +181,7 @@ homepage: https://dry-rb.org/gems/hanami-view
 licenses:
 - MIT
 metadata:
+  rubygems_mfa_required: 'true'
   allowed_push_host: https://rubygems.org
   changelog_uri: https://github.com/hanami/view/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/hanami/view
@@ -196,14 +194,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A complete, standalone view rendering system that gives you everything you

data/lib/hanami/view/application_configuration.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/configurable"
-require_relative "../view"
-
-module Hanami
-  class View
-    class ApplicationConfiguration
-      include Dry::Configurable
-
-      setting :parts_path, default: "views/parts"
-
-      def initialize(*)
-        super
-
-        @base_config = View.config.dup
-
-        configure_defaults
-      end
-
-      # Returns the list of available settings
-      #
-      # @return [Set]
-      #
-      # @since 2.0.0
-      # @api private
-      def settings
-        self.class.settings + View.settings - NON_FORWARDABLE_METHODS
-      end
-
-      def finalize!
-        return self if frozen?
-
-        base_config.finalize!
-
-        super
-      end
-
-      private
-
-      attr_reader :base_config
-
-      def configure_defaults
-        self.paths = ["web/templates"]
-        self.template_inference_base = "views"
-        self.layout = "application"
-      end
-
-      # An inflector for views is not configurable via `config.views.inflector` on an
-      # `Hanami::Application`. The application-wide inflector is already configurable
-      # there as `config.inflector` and will be used as the default inflector for views.
-      #
-      # A custom inflector may still be provided in an `Hanami::View` subclass, via
-      # `config.inflector=`.
-      NON_FORWARDABLE_METHODS = [:inflector, :inflector=].freeze
-      private_constant :NON_FORWARDABLE_METHODS
-
-      def method_missing(name, *args, &block)
-        return super if NON_FORWARDABLE_METHODS.include?(name)
-
-        if config.respond_to?(name)
-          config.public_send(name, *args, &block)
-        elsif base_config.respond_to?(name)
-          base_config.public_send(name, *args, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(name, _include_all = false)
-        return false if NON_FORWARDABLE_METHODS.include?(name)
-
-        config.respond_to?(name) || base_config.respond_to?(name) || super
-      end
-    end
-  end
-end

data/lib/hanami/view/application_context.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Hanami
-  class View
-    class ApplicationContext < Module
-      attr_reader :provider
-      attr_reader :application
-
-      def initialize(provider)
-        @provider = provider
-        @application = provider.respond_to?(:application) ? provider.application : Hanami.application
-      end
-
-      def included(context_class)
-        define_initialize
-        context_class.include(InstanceMethods)
-      end
-
-      private
-
-      def define_initialize
-        inflector = application.inflector
-        routes = application[:routes_helper] if application.key?(:routes_helper)
-
-        define_method :initialize do |**options|
-          @inflector = options[:inflector] || inflector
-          @routes = options[:routes] || routes
-          super(**options)
-        end
-      end
-
-      module InstanceMethods
-        attr_reader :inflector
-        attr_reader :routes
-
-        def request
-          _options.fetch(:request)
-        end
-
-        def session
-          request.session
-        end
-
-        def flash
-          response.flash
-        end
-
-        private
-
-        # TODO: create `Request#flash` so we no longer need the `response`
-        def response
-          _options.fetch(:response)
-        end
-      end
-    end
-  end
-end

data/lib/hanami/view/standalone_view.rb

@@ -1,400 +0,0 @@
-require_relative "scope"
-
-module Hanami
-  class View
-    module StandaloneView
-      def self.included(klass)
-        klass.extend ClassMethods
-        klass.include InstanceMethods
-      end
-
-      module ClassMethods
-        # @api private
-        def inherited(klass)
-          super
-
-          exposures.each do |name, exposure|
-            klass.exposures.import(name, exposure)
-          end
-        end
-
-        # @!group Exposures
-
-        # @!macro [new] exposure_options
-        #   @param options [Hash] the exposure's options
-        #   @option options [Boolean] :layout expose this value to the layout (defaults to false)
-        #   @option options [Boolean] :decorate decorate this value in a matching Part (defaults to
-        #     true)
-        #   @option options [Symbol, Class] :as an alternative name or class to use when finding a
-        #     matching Part
-
-        # @overload expose(name, **options, &block)
-        #   Define a value to be passed to the template. The return value of the
-        #   block will be decorated by a matching Part and passed to the template.
-        #
-        #   The block will be evaluated with the view instance as its `self`. The
-        #   block's parameters will determine what it is given:
-        #
-        #   - To receive other exposure values, provide positional parameters
-        #     matching the exposure names. These exposures will already by decorated
-        #     by their Parts.
-        #   - To receive the view's input arguments (whatever is passed to
-        #     `View#call`), provide matching keyword parameters. You can provide
-        #     default values for these parameters to make the corresponding input
-        #     keys optional
-        #   - To receive the Context object, provide a `context:` keyword parameter
-        #   - To receive the view's input arguments in their entirety, provide a
-        #     keywords splat parameter (i.e. `**input`)
-        #
-        #   @example Accessing input arguments
-        #     expose :article do |slug:|
-        #       article_repo.find_by_slug(slug)
-        #     end
-        #
-        #   @example Accessing other exposures
-        #     expose :articles do
-        #       article_repo.listing
-        #     end
-        #
-        #     expose :featured_articles do |articles|
-        #       articles.select(&:featured?)
-        #     end
-        #
-        #   @param name [Symbol] name for the exposure
-        #   @macro exposure_options
-        #
-        # @overload expose(name, **options)
-        #   Define a value to be passed to the template, provided by an instance
-        #   method matching the name. The method's return value will be decorated by
-        #   a matching Part and passed to the template.
-        #
-        #   The method's parameters will determine what it is given:
-        #
-        #   - To receive other exposure values, provide positional parameters
-        #     matching the exposure names. These exposures will already by decorated
-        #     by their Parts.
-        #   - To receive the view's input arguments (whatever is passed to
-        #     `View#call`), provide matching keyword parameters. You can provide
-        #     default values for these parameters to make the corresponding input
-        #     keys optional
-        #   - To receive the Context object, provide a `context:` keyword parameter
-        #   - To receive the view's input arguments in their entirey, provide a
-        #     keywords splat parameter (i.e. `**input`)
-        #
-        #   @example Accessing input arguments
-        #     expose :article
-        #
-        #     def article(slug:)
-        #       article_repo.find_by_slug(slug)
-        #     end
-        #
-        #   @example Accessing other exposures
-        #     expose :articles
-        #     expose :featured_articles
-        #
-        #     def articles
-        #       article_repo.listing
-        #     end
-        #
-        #     def featured_articles
-        #       articles.select(&:featured?)
-        #     end
-        #
-        #   @param name [Symbol] name for the exposure
-        #   @macro exposure_options
-        #
-        # @overload expose(name, **options)
-        #   Define a single value to pass through from the input data (when there is
-        #   no instance method matching the `name`). This value will be decorated by
-        #   a matching Part and passed to the template.
-        #
-        #   @param name [Symbol] name for the exposure
-        #   @macro exposure_options
-        #   @option options [Boolean] :default a default value to provide if there is no matching
-        #     input data
-        #
-        # @overload expose(*names, **options)
-        #   Define multiple values to pass through from the input data (when there
-        #   is no instance methods matching their names). These values will be
-        #   decorated by matching Parts and passed through to the template.
-        #
-        #   The provided options will be applied to all the exposures.
-        #
-        #   @param names [Symbol] names for the exposures
-        #   @macro exposure_options
-        #   @option options [Boolean] :default a default value to provide if there is no matching
-        #     input data
-        #
-        # @see https://dry-rb.org/gems/dry-view/exposures/
-        #
-        # @api public
-        def expose(*names, **options, &block)
-          if names.length == 1
-            exposures.add(names.first, block, **options)
-          else
-            names.each do |name|
-              exposures.add(name, **options)
-            end
-          end
-        end
-
-        # @api public
-        def private_expose(*names, **options, &block)
-          expose(*names, **options, private: true, &block)
-        end
-
-        # Returns the defined exposures. These are unbound, since bound exposures
-        # are only created when initializing a View instance.
-        #
-        # @return [Exposures]
-        # @api private
-        def exposures
-          @exposures ||= Exposures.new
-        end
-
-        # @!endgroup
-
-        # @!group Scope
-
-        # Creates and assigns a scope for the current view.
-        #
-        # The newly created scope is useful to add custom logic that is specific
-        # to the view.
-        #
-        # The scope has access to locals, exposures, and inherited scope (if any)
-        #
-        # If the view already has an explicit scope the newly created scope will
-        # inherit from the explicit scope.
-        #
-        # There are two cases when this may happen:
-        #   1. The scope was explicitly assigned (e.g. `config.scope = MyScope`)
-        #   2. The scope has been inherited by the view superclass
-        #
-        # If the view doesn't have an already existing scope, the newly scope
-        # will inherit from `Hanami::View::Scope` by default.
-        #
-        # However, you can specify any base class for it. This is not
-        # recommended, unless you know what you're doing.
-        #
-        # @param scope [Hanami::View::Scope] the current scope (if any), or the
-        #   default base class will be `Hanami::View::Scope`
-        # @param block [Proc] the scope logic definition
-        #
-        # @api public
-        #
-        # @example Basic usage
-        #   class MyView < Hanami::View
-        #     config.scope = MyScope
-        #
-        #     scope do
-        #       def greeting
-        #         _locals[:message].upcase + "!"
-        #       end
-        #
-        #       def copyright(time)
-        #         "Copy #{time.year}"
-        #       end
-        #     end
-        #   end
-        #
-        #   # my_view.html.erb
-        #   # <%= greeting %>
-        #   # <%= copyright(Time.now.utc) %>
-        #
-        #   MyView.new.(message: "Hello") # => "HELLO!"
-        #
-        # @example Inherited scope
-        #   class MyScope < Hanami::View::Scope
-        #     private
-        #
-        #     def shout(string)
-        #       string.upcase + "!"
-        #     end
-        #   end
-        #
-        #   class MyView < Hanami::View
-        #     config.scope = MyScope
-        #
-        #     scope do
-        #       def greeting
-        #         shout(_locals[:message])
-        #       end
-        #
-        #       def copyright(time)
-        #         "Copy #{time.year}"
-        #       end
-        #     end
-        #   end
-        #
-        #   # my_view.html.erb
-        #   # <%= greeting %>
-        #   # <%= copyright(Time.now.utc) %>
-        #
-        #   MyView.new.(message: "Hello") # => "HELLO!"
-        def scope(base: config.scope || Hanami::View::Scope, &block)
-          config.scope = Class.new(base, &block)
-        end
-
-        # @!endgroup
-
-        # @!group Render environment
-
-        # Returns a render environment for the view and the given options. This
-        # environment isn't chdir'ed into any particular directory.
-        #
-        # @param format [Symbol] template format to use (defaults to the `default_format` setting)
-        # @param context [Context] context object to use (defaults to the `default_context` setting)
-        #
-        # @see View.template_env render environment for the view's template
-        # @see View.layout_env render environment for the view's layout
-        #
-        # @return [RenderEnvironment]
-        # @api public
-        def render_env(format: config.default_format, context: config.default_context)
-          RenderEnvironment.prepare(renderer(format), config, context)
-        end
-
-        # @overload template_env(format: config.default_format, context: config.default_context)
-        #   Returns a render environment for the view and the given options,
-        #   chdir'ed into the view's template directory. This is the environment
-        #   used when rendering the template, and is useful to to fetch
-        #   independently when unit testing Parts and Scopes.
-        #
-        #   @param format [Symbol] template format to use (defaults to the `default_format` setting)
-        #   @param context [Context] context object to use (defaults to the `default_context` setting)
-        #
-        #   @return [RenderEnvironment]
-        #   @api public
-        def template_env(**args)
-          render_env(**args).chdir(config.template)
-        end
-
-        # @overload layout_env(format: config.default_format, context: config.default_context)
-        #   Returns a render environment for the view and the given options,
-        #   chdir'ed into the view's layout directory. This is the environment used
-        #   when rendering the view's layout.
-        #
-        #   @param format [Symbol] template format to use (defaults to the `default_format` setting)
-        #   @param context [Context] context object to use (defaults to the `default_context` setting)
-        #
-        #   @return [RenderEnvironment] @api public
-        def layout_env(**args)
-          render_env(**args).chdir(layout_path)
-        end
-
-        # Returns renderer for the view and provided format
-        #
-        # @api private
-        def renderer(format)
-          fetch_or_store(:renderer, config, format) {
-            Renderer.new(
-              config.paths,
-              format: format,
-              engine_mapping: config.renderer_engine_mapping,
-              **config.renderer_options
-            )
-          }
-        end
-
-        # @api private
-        def layout_path
-          File.join(*[config.layouts_dir, config.layout].compact)
-        end
-
-        # @!endgroup
-      end
-
-      module InstanceMethods
-        # Returns an instance of the view. This binds the defined exposures to the
-        # view instance.
-        #
-        # Subclasses can define their own `#initialize` to accept injected
-        # dependencies, but must call `super()` to ensure the standard view
-        # initialization can proceed.
-        #
-        # @api public
-        def initialize
-          @exposures = self.class.exposures.bind(self)
-        end
-
-        # The view's configuration
-        #
-        # @api private
-        def config
-          self.class.config
-        end
-
-        # The view's bound exposures
-        #
-        # @return [Exposures]
-        # @api private
-        def exposures
-          @exposures
-        end
-
-        # Render the view
-        #
-        # @param format [Symbol] template format to use
-        # @param context [Context] context object to use
-        # @param input input data for preparing exposure values
-        #
-        # @return [Rendered] rendered view object
-        # @api public
-        def call(format: config.default_format, context: config.default_context, **input)
-          ensure_config
-
-          env = self.class.render_env(format: format, context: context)
-          template_env = self.class.template_env(format: format, context: context)
-
-          locals = locals(template_env, input)
-          output = env.template(config.template, template_env.scope(config.scope, locals))
-
-          if layout?
-            layout_env = self.class.layout_env(format: format, context: context)
-            begin
-              output = env.template(
-                self.class.layout_path,
-                layout_env.scope(config.scope, layout_locals(locals))
-              ) { output }
-            rescue TemplateNotFoundError
-              raise LayoutNotFoundError.new(config.layout, config.paths)
-            end
-          end
-
-          Rendered.new(output: output, locals: locals)
-        end
-
-        private
-
-        # @api private
-        def ensure_config
-          raise UndefinedConfigError, :paths unless Array(config.paths).any?
-          raise UndefinedConfigError, :template unless config.template
-        end
-
-        # @api private
-        def locals(render_env, input)
-          exposures.(context: render_env.context, **input) do |value, exposure|
-            if exposure.decorate? && value
-              render_env.part(exposure.name, value, **exposure.options)
-            else
-              value
-            end
-          end
-        end
-
-        # @api private
-        def layout_locals(locals)
-          locals.each_with_object({}) do |(key, value), layout_locals|
-            layout_locals[key] = value if exposures[key].for_layout?
-          end
-        end
-
-        # @api private
-        def layout?
-          !!config.layout # rubocop:disable Style/DoubleNegation
-        end
-      end
-    end
-  end
-end