hanami 2.0.3 → 2.1.0.beta2

data/lib/hanami/extensions/view/context.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/view"
-require "hanami/view/context"
 require_relative "../../errors"
 
 module Hanami
@@ -13,88 +11,159 @@ module Hanami
       #
       # @api private
       module Context
-        def self.included(context_class)
-          super
-
-          context_class.extend(Hanami::SliceConfigurable)
-          context_class.extend(ClassMethods)
-          context_class.prepend(InstanceMethods)
-        end
+        class << self
+          # Returns a context class for the given slice. If a context class is not defined, defines
+          # a class named `Views::Context` within the slice's namespace.
+          #
+          # @api private
+          def context_class(slice)
+            views_namespace = views_namespace(slice)
+
+            if views_namespace.const_defined?(:Context)
+              return views_namespace.const_get(:Context)
+            end
 
-        module ClassMethods
-          def configure_for_slice(slice)
-            extend SliceConfiguredContext.new(slice)
+            views_namespace.const_set(:Context, Class.new(context_superclass(slice)).tap { |klass|
+              klass.configure_for_slice(slice)
+            })
           end
-        end
 
-        module InstanceMethods
-          # @see SliceConfiguredContext#define_new
-          def initialize(**kwargs)
-            defaults = {content: {}}
+          private
 
-            super(**kwargs, **defaults)
+          def context_superclass(slice)
+            return Hanami::View::Context if Hanami.app.equal?(slice)
+
+            begin
+              slice.inflector.constantize(
+                slice.inflector.camelize("#{slice.app.slice_name.name}/views/context")
+              )
+            rescue NameError => e
+              raise e unless %i[Views Context].include?(e.name)
+
+              Hanami::View::Context
+            end
           end
 
-          def inflector
-            _options.fetch(:inflector)
+          # TODO: this could be moved into the top-level Extensions::View
+          def views_namespace(slice)
+            if slice.namespace.const_defined?(:Views)
+              slice.namespace.const_get(:Views)
+            else
+              slice.namespace.const_set(:Views, Module.new)
+            end
           end
+        end
 
-          def routes
-            _options.fetch(:routes)
+        module ClassExtension
+          def self.included(context_class)
+            super
+
+            context_class.extend(Hanami::SliceConfigurable)
+            context_class.extend(ClassMethods)
+            context_class.prepend(InstanceMethods)
           end
 
-          def settings
-            _options.fetch(:settings)
+          module ClassMethods
+            def configure_for_slice(slice)
+              extend SliceConfiguredContext.new(slice)
+            end
           end
 
-          def assets
-            unless _options[:assets]
-              raise Hanami::ComponentLoadError, "hanami-assets gem is required to access assets"
+          module InstanceMethods
+            attr_reader :inflector
+
+            attr_reader :settings
+
+            # @see SliceConfiguredContext#define_new
+            def initialize( # rubocop:disable Metrics/ParameterLists
+              inflector: nil,
+              settings: nil,
+              routes: nil,
+              assets: nil,
+              request: nil,
+              **args
+            )
+              @inflector = inflector
+              @settings = settings
+              @routes = routes
+              @assets = assets
+              @request = request
+
+              @content_for = {}
+
+              super(**args)
             end
 
-            _options[:assets]
-          end
+            def initialize_copy(source)
+              # The standard implementation of initialize_copy will make shallow copies of all
+              # instance variables from the source. This is fine for most of our ivars.
+              super
 
-          def content_for(key, value = nil, &block)
-            content = _options[:content]
-            output = nil
+              # Dup any objects that will be mutated over a given rendering to ensure no leakage of
+              # state across distinct view renderings.
+              @content_for = source.instance_variable_get(:@content_for).dup
+            end
 
-            if block
-              content[key] = yield
-            elsif value
-              content[key] = value
-            else
-              output = content[key]
+            def with(**args)
+              self.class.new(
+                inflector: @inflector,
+                settings: @settings,
+                assets: @assets,
+                routes: @routes,
+                request: @request,
+                **args
+              )
             end
 
-            output
-          end
+            def assets
+              unless @assets
+                raise Hanami::ComponentLoadError, "the hanami-assets gem is required to access assets"
+              end
 
-          def current_path
-            request.fullpath
-          end
+              @assets
+            end
 
-          def csrf_token
-            request.session[Hanami::Action::CSRFProtection::CSRF_TOKEN]
-          end
+            def request
+              unless @request
+                raise Hanami::ComponentLoadError, "only views rendered from Hanami::Action instances have a request"
+              end
 
-          def request
-            _options.fetch(:request)
-          end
+              @request
+            end
 
-          def session
-            request.session
-          end
+            def routes
+              unless @routes
+                raise Hanami::ComponentLoadError, "the hanami-router gem is required to access routes"
+              end
 
-          def flash
-            response.flash
-          end
+              @routes
+            end
 
-          private
+            def content_for(key, value = nil)
+              if block_given?
+                @content_for[key] = yield
+              elsif value
+                @content_for[key] = value
+              else
+                @content_for[key]
+              end
+            end
+
+            def current_path
+              request.fullpath
+            end
+
+            def csrf_token
+              request.session[Hanami::Action::CSRFProtection::CSRF_TOKEN]
+            end
+
+            def session
+              request.session
+            end
 
-          # TODO: create `Request#flash` so we no longer need the `response`
-          def response
-            _options.fetch(:response)
+            def flash
+              request.flash
+            end
           end
         end
       end
@@ -102,4 +171,4 @@ module Hanami
   end
 end
 
-Hanami::View::Context.include(Hanami::Extensions::View::Context)
+Hanami::View::Context.include(Hanami::Extensions::View::Context::ClassExtension)

data/lib/hanami/extensions/view/part.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # @api private
+      module Part
+        def self.included(part_class)
+          super
+
+          part_class.extend(Hanami::SliceConfigurable)
+          part_class.include(StandardHelpers)
+          part_class.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def configure_for_slice(slice)
+            extend SliceConfiguredHelpers.new(slice)
+          end
+        end
+      end
+    end
+  end
+end
+
+Hanami::View::Part.include(Hanami::Extensions::View::Part)

data/lib/hanami/extensions/view/scope.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # @api private
+      module Scope
+        def self.included(scope_class)
+          super
+
+          scope_class.extend(Hanami::SliceConfigurable)
+          scope_class.include(StandardHelpers)
+          scope_class.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def configure_for_slice(slice)
+            extend SliceConfiguredHelpers.new(slice)
+          end
+        end
+      end
+    end
+  end
+end
+
+Hanami::View::Scope.include(Hanami::Extensions::View::Scope)

data/lib/hanami/extensions/view/slice_configured_context.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/view"
-
 module Hanami
   module Extensions
     module View

data/lib/hanami/extensions/view/slice_configured_helpers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # @api private
+      class SliceConfiguredHelpers < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(klass)
+          include_helpers(klass)
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        def include_helpers(klass)
+          if mod = helpers_module(slice.app)
+            klass.include(mod)
+          end
+
+          if mod = helpers_module(slice)
+            klass.include(mod)
+          end
+        end
+
+        def helpers_module(slice)
+          return unless slice.namespace.const_defined?(:Views)
+          return unless slice.namespace.const_get(:Views).const_defined?(:Helpers)
+
+          slice.namespace.const_get(:Views).const_get(:Helpers)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/extensions/view/slice_configured_view.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "hanami/view"
-
 module Hanami
   module Extensions
     module View
@@ -11,6 +9,11 @@ module Hanami
       # @api private
       # @since 2.0.0
       class SliceConfiguredView < Module
+        TEMPLATES_DIR = "templates"
+        VIEWS_DIR = "views"
+        PARTS_DIR = "parts"
+        SCOPES_DIR = "scopes"
+
         attr_reader :slice
 
         def initialize(slice)
@@ -19,6 +22,7 @@ module Hanami
         end
 
         def extended(view_class)
+          load_app_view
           configure_view(view_class)
           define_inherited
         end
@@ -29,6 +33,19 @@ module Hanami
 
         private
 
+        # If the given view doesn't inherit from the app view, attempt to load it anyway, since
+        # requiring the app view is necessary for _its_ `SliceConfiguredView` hook to execute and
+        # define the app-level part and scope classes that we refer to here.
+        def load_app_view
+          return if app?
+
+          begin
+            slice.app.namespace.const_get(:View, false)
+          rescue NameError => e
+            raise unless e.name == :View
+          end
+        end
+
         # rubocop:disable Metrics/AbcSize
         def configure_view(view_class)
           view_class.settings.each do |setting|
@@ -84,12 +101,30 @@ module Hanami
           end
 
           view_class.config.inflector = inflector
-          view_class.config.paths = prepare_paths(slice, view_class.config.paths)
+
+          # Configure the paths for this view if:
+          #   - We are the app, and a user hasn't provided custom `paths` (in this case, we need to
+          #     set the defaults)
+          #   - We are a slice, and the view's inherited `paths` is identical to the parent's config
+          #     (which would result in the view in a slice erroneously trying to find templates in
+          #     the app)
+          if (!slice.parent && view_class.config.paths.empty?) ||
+             (slice.parent && view_class.config.paths.map(&:dir) == [templates_path(slice.parent)])
+            view_class.config.paths = templates_path(slice)
+          end
+
           view_class.config.template = template_name(view_class)
+          view_class.config.default_context = Extensions::View::Context.context_class(slice).new
 
-          if (part_namespace = namespace_from_path(slice.config.views.parts_path))
+          view_class.config.part_class = part_class
+          view_class.config.scope_class = scope_class
+
+          if (part_namespace = namespace_from_path("#{VIEWS_DIR}/#{PARTS_DIR}"))
             view_class.config.part_namespace = part_namespace
           end
+          if (scope_namespace = namespace_from_path("#{VIEWS_DIR}/#{SCOPES_DIR}"))
+            view_class.config.scope_namespace = scope_namespace
+          end
         end
         # rubocop:enable Metrics/AbcSize
 
@@ -102,20 +137,12 @@ module Hanami
           end
         end
 
-        def prepare_paths(slice, configured_paths)
-          configured_paths.map { |path|
-            if path.dir.relative?
-              if slice.app.equal?(slice)
-                # App-level templates are in app/
-                slice.root.join(APP_DIR, path.dir)
-              else
-                # Other slice templates are in the root slice dir
-                slice.root.join(path.dir)
-              end
-            else
-              path
-            end
-          }
+        def templates_path(slice)
+          if slice.app.equal?(slice)
+            slice.root.join(APP_DIR, TEMPLATES_DIR)
+          else
+            slice.root.join(TEMPLATES_DIR)
+          end
         end
 
         def namespace_from_path(path)
@@ -134,16 +161,74 @@ module Hanami
         end
 
         def template_name(view_class)
-          slice
-            .inflector
+          inflector
             .underscore(view_class.name)
             .sub(/^#{slice.slice_name.path}\//, "")
-            .sub(/^#{view_class.config.template_inference_base}\//, "")
+            .sub(/^#{VIEWS_DIR}\//, "")
         end
 
         def inflector
           slice.inflector
         end
+
+        def part_class
+          @part_class ||=
+            if views_namespace.const_defined?(:Part)
+              views_namespace.const_get(:Part)
+            else
+              views_namespace.const_set(:Part, Class.new(part_superclass).tap { |klass|
+                # Give the slice to `configure_for_slice`, since it cannot be inferred when it is
+                # called via `.inherited`, since the class is anonymous at this point
+                klass.configure_for_slice(slice)
+              })
+            end
+        end
+
+        def part_superclass
+          return Hanami::View::Part if app?
+
+          begin
+            inflector.constantize(inflector.camelize("#{slice.app.slice_name.name}/views/part"))
+          rescue NameError
+            Hanami::View::Part
+          end
+        end
+
+        def scope_class
+          @scope_class ||=
+            if views_namespace.const_defined?(:Scope)
+              views_namespace.const_get(:Scope)
+            else
+              views_namespace.const_set(:Scope, Class.new(scope_superclass).tap { |klass|
+                # Give the slice to `configure_for_slice`, since it cannot be inferred when it is
+                # called via `.inherited`, since the class is anonymous at this point
+                klass.configure_for_slice(slice)
+              })
+            end
+        end
+
+        def scope_superclass
+          return Hanami::View::Scope if app?
+
+          begin
+            inflector.constantize(inflector.camelize("#{slice.app.slice_name.name}/views/scope"))
+          rescue NameError
+            Hanami::View::Scope
+          end
+        end
+
+        def views_namespace
+          @slice_views_namespace ||=
+            if slice.namespace.const_defined?(:Views)
+              slice.namespace.const_get(:Views)
+            else
+              slice.namespace.const_set(:Views, Module.new)
+            end
+        end
+
+        def app?
+          slice.app == slice
+        end
       end
     end
   end

data/lib/hanami/extensions/view/standard_helpers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      module StandardHelpers
+        include Hanami::View::Helpers::EscapeHelper
+        include Hanami::View::Helpers::NumberFormattingHelper
+        include Hanami::View::Helpers::TagHelper
+        include Helpers::FormHelper
+
+        if Hanami.bundled?("hanami-assets")
+          include Helpers::AssetsHelper
+        end
+      end
+    end
+  end
+end

data/lib/hanami/extensions.rb

@@ -1,10 +1,17 @@
 # frozen_string_literal: true
 
 if Hanami.bundled?("hanami-controller")
-  require_relative "./extensions/action"
+  require_relative "extensions/action"
 end
 
 if Hanami.bundled?("hanami-view")
-  require_relative "./extensions/view"
-  require_relative "./extensions/view/context"
+  require "hanami/view"
+  require_relative "extensions/view"
+  require_relative "extensions/view/context"
+  require_relative "extensions/view/part"
+  require_relative "extensions/view/scope"
+end
+
+if Hanami.bundled?("hanami-router")
+  require_relative "extensions/router/errors"
 end