hanami-view 1.3.0.beta1 → 2.0.0.alpha2

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, "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,28 @@
-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
-
-    # 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 }'")
-      end
-    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")
 
-    # 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}.")
+        super(msg)
       end
     end
   end