hanami-view 1.3.1 → 2.0.0.alpha3

data/hanami-view.gemspec

@@ -1,28 +1,38 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'hanami/view/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'hanami-view'
-  spec.version       = Hanami::View::VERSION
-  spec.authors       = ['Luca Guidi']
-  spec.email         = ['me@lucaguidi.com']
-  spec.description   = %q{View layer for Hanami}
-  spec.summary       = %q{View layer for Hanami, with a separation between views and templates}
-  spec.homepage      = 'http://hanamirb.org'
+  spec.authors       = ["Tim Riley", "Piotr Solnica"]
+  spec.email         = ["tim@icelab.com.au", "piotr.solnica@gmail.com"]
   spec.license       = 'MIT'
+  spec.version       = Hanami::View::VERSION.dup
 
-  spec.files         = `git ls-files -- lib/* CHANGELOG.md LICENSE.md README.md hanami-view.gemspec`.split($/)
+  spec.summary       = "A complete, standalone view rendering system that gives you everything you need to write well-factored view code"
+  spec.description   = spec.summary
+  spec.homepage      = 'https://dry-rb.org/gems/hanami-view'
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "hanami-view.gemspec", "lib/**/*"]
+  spec.bindir        = 'bin'
   spec.executables   = []
-  spec.test_files    = spec.files.grep(%r{^(test)/})
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 2.3.0'
 
-  spec.add_runtime_dependency 'tilt',         '~> 2.0', '>= 2.0.1'
-  spec.add_runtime_dependency 'hanami-utils', '~> 1.3'
+  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.add_runtime_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_runtime_dependency "dry-configurable", "~> 0.13", ">= 0.13.0"
+  spec.add_runtime_dependency "dry-core", "~> 0.5", ">= 0.5"
+  spec.add_runtime_dependency "dry-inflector", "~> 0.1"
+  spec.add_runtime_dependency "tilt", "~> 2.0", ">= 2.0.6"
 
-  spec.add_development_dependency 'bundler', '>= 1.6', '< 3'
-  spec.add_development_dependency 'rspec',   '~> 3.7'
-  spec.add_development_dependency 'rake',    '~> 12'
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
 end

data/lib/hanami/view/application_configuration.rb

@@ -0,0 +1,77 @@
+# 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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hanami
+  class View
+    module ApplicationContext
+      def initialize(inflector: Hanami.application.inflector, **options)
+        @inflector = inflector
+        super
+      end
+
+      def inflector
+        @inflector
+      end
+
+      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

data/lib/hanami/view/application_view.rb

@@ -0,0 +1,89 @@
+module Hanami
+  class View
+    class ApplicationView < Module
+      InheritedHook = Class.new(Module)
+
+      attr_reader :provider
+      attr_reader :application
+      attr_reader :inherited_hook
+
+      def initialize(provider)
+        @provider = provider
+        @application = provider.respond_to?(:application) ? provider.application : Hanami.application
+        @inherited_hook = InheritedHook.new
+
+        define_inherited_hook
+      end
+
+      def included(view_class)
+        configure_view view_class
+        view_class.extend inherited_hook
+      end
+
+      private
+
+      def configure_view(view_class)
+        view_class.settings.each do |setting|
+          if application.config.views.respond_to?(:"#{setting}")
+            application_value = application.config.views.public_send(:"#{setting}")
+            view_class.config.public_send :"#{setting}=", application_value
+          end
+        end
+
+        view_class.config.inflector = provider.inflector
+        view_class.config.paths = prepare_paths(provider, view_class.config.paths)
+        view_class.config.template = template_name(view_class)
+
+        if (part_namespace = namespace_from_path(application.config.views.parts_path))
+          view_class.config.part_namespace = part_namespace
+        end
+      end
+
+      def define_inherited_hook
+        template_name = method(:template_name)
+
+        inherited_hook.send :define_method, :inherited do |subclass|
+          super(subclass)
+          subclass.config.template = template_name.(subclass)
+        end
+      end
+
+      def prepare_paths(provider, configured_paths)
+        configured_paths.map { |path|
+          if path.dir.relative?
+            provider.root.join(path.dir)
+          else
+            path
+          end
+        }
+      end
+
+      def template_name(view_class)
+        provider
+          .inflector
+          .underscore(view_class.name)
+          .sub(/^#{provider.namespace_path}\//, "")
+          .sub(/^#{view_class.config.template_inference_base}\//, "")
+      end
+
+      def namespace_from_path(path)
+        path = "#{provider.namespace_path}/#{path}"
+
+        begin
+          require path
+        rescue LoadError => exception
+          raise exception unless exception.path == path
+        end
+
+        begin
+          inflector.constantize(inflector.camelize(path))
+        rescue NameError => exception
+        end
+      end
+
+      def inflector
+        provider.inflector
+      end
+    end
+  end
+end

data/lib/hanami/view/context.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require_relative "application_context"
+require_relative "decorated_attributes"
+
+module Hanami
+  class View
+    # Provides a baseline environment across all the templates, parts and scopes
+    # in a given rendering.
+    #
+    # @abstract Subclass this and add your own methods (along with a custom
+    #   `#initialize` if you wish to inject dependencies)
+    #
+    # @api public
+    class Context
+      include Dry::Equalizer(:_options)
+      include DecoratedAttributes
+
+      attr_reader :_render_env, :_options
+
+      def self.inherited(subclass)
+        super
+
+        # When inheriting within an Hanami app, add application context behavior
+        if application_provider(subclass)
+          subclass.include ApplicationContext
+        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
+      # arguments_ to `super`. This allows Context to make copies of itself
+      # while preserving your dependencies.
+      #
+      # @example
+      #   class MyContext < Hanami::View::Context
+      #     # Injected dependency
+      #     attr_reader :assets
+      #
+      #     def initialize(assets:, **options)
+      #       @assets = assets
+      #       super
+      #     end
+      #   end
+      #
+      # @api public
+      def initialize(render_env: nil, **options)
+        @_render_env = render_env
+        @_options = options
+      end
+
+      # @api private
+      def for_render_env(render_env)
+        return self if render_env == _render_env
+
+        self.class.new(**_options.merge(render_env: render_env))
+      end
+
+      # Returns a copy of the Context with new options merged in.
+      #
+      # This may be useful to supply values for dependencies that are _optional_
+      # when initializing your custom Context subclass.
+      #
+      # @example
+      #   class MyContext < Hanami::View::Context
+      #     # Injected dependencies (request is optional)
+      #     attr_reader :assets, :request
+      #
+      #     def initialize(assets:, request: nil, **options)
+      #       @assets = assets
+      #       @request = reuqest
+      #       super
+      #     end
+      #   end
+      #
+      #   my_context = MyContext.new(assets: assets)
+      #   my_context_with_request = my_context.with(request: request)
+      #
+      # @api public
+      def with(**new_options)
+        self.class.new(
+          render_env: _render_env,
+          **_options.merge(new_options)
+        )
+      end
+    end
+  end
+end

data/lib/hanami/view/context_helpers/content_helpers.rb

@@ -0,0 +1,26 @@
+module Hanami
+  class View
+    module ContextHelpers
+      module ContentHelpers
+        def initialize(content: {}, **options)
+          super
+        end
+
+        def content_for(key, value = nil, &block)
+          content = _options[:content]
+          output = nil
+
+          if block
+            content[key] = yield
+          elsif value
+            content[key] = value
+          else
+            output = content[key]
+          end
+
+          output
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/decorated_attributes.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Hanami
+  class View
+    # Decorates attributes in Parts.
+    module DecoratedAttributes
+      # @api private
+      def self.included(klass)
+        klass.extend ClassInterface
+      end
+
+      # Decorated attributes class-level interface.
+      module ClassInterface
+        # @api private
+        MODULE_NAME = :DecoratedAttributes
+
+        # Decorates the provided attributes, wrapping them in Parts using the
+        # current render environment.
+        #
+        # @example
+        #   class Article < Hanami::View::Part
+        #     decorate :feature_image
+        #     decorate :author as: :person
+        #   end
+        #
+        # @param names [Array<Symbol>] the attribute names
+        # @param options [Hash] the options to pass to the Part Builder
+        # @option options [Symbol, Class] :as an alternative name or class to use when finding a
+        #   matching Part
+        #
+        # @api public
+        def decorate(*names, **options)
+          decorated_attributes.decorate(*names, **options)
+        end
+
+        private
+
+        def decorated_attributes
+          if const_defined?(MODULE_NAME, false)
+            const_get(MODULE_NAME)
+          else
+            const_set(MODULE_NAME, Attributes.new).tap do |mod|
+              prepend mod
+            end
+          end
+        end
+      end
+
+      # @api private
+      class Attributes < Module
+        def initialize(*)
+          @names = Set.new
+          super
+        end
+
+        def decorate(*names, **options)
+          @names += names
+
+          class_eval do
+            names.each do |name|
+              define_method name do
+                attribute = super()
+
+                if _render_env && attribute
+                  _render_env.part(name, attribute, **options)
+                else
+                  attribute
+                end
+              end
+            end
+          end
+        end
+
+        def inspect
+          %(#<#{self.class.name}#{@names.to_a.sort.inspect}>)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/view/errors.rb

@@ -1,65 +1,43 @@
-module Hanami
-  module View
-    # @since 0.5.0
-    class Error < ::StandardError
-    end
+# frozen_string_literal: true
 
-    # Missing template error
-    #
-    # This is raised at the runtime when Hanami::View cannot find a template for
-    # the requested format.
-    #
-    # We can't raise this error during the loading phase, because at that time
-    # we don't know if a view implements its own rendering policy.
-    # A view is allowed to override `#render`, and this scenario can make the
-    # presence of a template useless. One typical example is the usage of a
-    # serializer that returns the output string, without rendering a template.
+module Hanami
+  class View
+    # Error raised when critical settings are not configured
     #
-    # @since 0.1.0
-    class MissingTemplateError < Error
-      # @since 0.1.0
-      # @api private
-      def initialize(template, format)
-        super("Can't find template '#{ template }' for '#{ format }' format.")
+    # @api private
+    class UndefinedConfigError < StandardError
+      def initialize(key)
+        super("no +#{key}+ configured")
       end
     end
 
-    # Missing format error
-    #
-    # This is raised at the runtime when rendering context lacks the :format
-    # key.
-    #
-    # @since 0.1.0
-    #
-    # @see Hanami::View::Rendering#render
-    class MissingFormatError < Error
-    end
+    # Error raised when template could not be found within a view's configured
+    # paths
+    #
+    # @api private
+    class TemplateNotFoundError < StandardError
+      def initialize(template_name, lookup_paths)
+        msg = [
+          "Template +#{template_name}+ could not be found in paths:",
+          lookup_paths.map { |path| " - #{path}" }
+        ].join("\n\n")
 
-    # Missing template layout error
-    #
-    # This is raised at the runtime when Hanami::Layout cannot find its template.
-    #
-    # @since 0.5.0
-    class MissingTemplateLayoutError < Error
-      # @since 0.5.0
-      # @api private
-      def initialize(template)
-        super("Can't find layout template '#{ template }'")
+        super(msg)
       end
     end
 
-    # Unknown or render type
-    #
-    # This is raised at the runtime when `Hanami::Layout` doesn't recognize the render type.
-    #
-    # @since 1.1.0
-    class UnknownRenderTypeError < Error
-      # @since 1.1.0
-      # @api private
-      def initialize(known_types, supplied_options)
-        known_types_list = known_types.map{|t| "':#{t}'"}.join(', ')
-        supplied_options_list = supplied_options.keys.map{|t| "':#{t}'"}.join(', ')
-        super("Calls to `render` in a layout must include one of #{known_types_list}. Found #{supplied_options_list}.")
+    # Error raised when layout could not be found within a view's configured
+    # paths
+    #
+    # @api private
+    class LayoutNotFoundError < StandardError
+      def initialize(layout_name, lookup_paths)
+        msg = [
+          "Layout +#{layout_name}+ could not be found in paths:",
+          lookup_paths.map { |path| " - #{path}" }
+        ].join("\n\n")
+
+        super(msg)
       end
     end
   end

data/lib/hanami/view/exposure.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+
+module Hanami
+  class View
+    # An exposure defined on a view
+    #
+    # @api private
+    class Exposure
+      include Dry::Equalizer(:name, :proc, :object, :options)
+
+      EXPOSURE_DEPENDENCY_PARAMETER_TYPES = %i[req opt].freeze
+      INPUT_PARAMETER_TYPES = %i[key keyreq keyrest].freeze
+
+      attr_reader :name
+      attr_reader :proc
+      attr_reader :object
+      attr_reader :options
+
+      def initialize(name, proc = nil, object = nil, **options)
+        @name = name
+        @proc = prepare_proc(proc, object)
+        @object = object
+        @options = options
+      end
+
+      def bind(obj)
+        self.class.new(name, proc, obj, **options)
+      end
+
+      def dependency_names
+        if proc
+          proc.parameters.each_with_object([]) { |(type, name), names|
+            names << name if EXPOSURE_DEPENDENCY_PARAMETER_TYPES.include?(type)
+          }
+        else
+          []
+        end
+      end
+
+      def input_keys
+        if proc
+          proc.parameters.each_with_object([]) { |(type, name), keys|
+            keys << name if INPUT_PARAMETER_TYPES.include?(type)
+          }
+        else
+          []
+        end
+      end
+
+      def for_layout?
+        options.fetch(:layout) { false }
+      end
+
+      def decorate?
+        options.fetch(:decorate) { true }
+      end
+
+      def private?
+        options.fetch(:private) { false }
+      end
+
+      def default_value
+        options[:default]
+      end
+
+      def call(input, locals = {})
+        if proc
+          call_proc(input, locals)
+        else
+          input.fetch(name) { default_value }
+        end
+      end
+
+      private
+
+      def call_proc(input, locals)
+        args, keywords = proc_args(input, locals)
+
+        if keywords.empty?
+          if proc.is_a?(Method)
+            proc.(*args)
+          else
+            object.instance_exec(*args, &proc)
+          end
+        else
+          if proc.is_a?(Method)
+            proc.(*args, **keywords)
+          else
+            object.instance_exec(*args, **keywords, &proc)
+          end
+        end
+      end
+
+      def proc_args(input, locals)
+        dependency_args = proc_dependency_args(locals)
+        keywords = proc_input_args(input)
+
+        if keywords.empty?
+          [dependency_args, {}]
+        else
+          [dependency_args, keywords]
+        end
+      end
+
+      def proc_dependency_args(locals)
+        dependency_names.map { |name| locals.fetch(name) }
+      end
+
+      def proc_input_args(input)
+        input_keys.each_with_object({}) { |key, args|
+          args[key] = input[key] if input.key?(key)
+        }
+      end
+
+      def prepare_proc(proc, object)
+        if proc
+          proc
+        elsif object.respond_to?(name, _include_private = true)
+          object.method(name)
+        end
+      end
+    end
+  end
+end