hanami 2.0.2 → 2.1.0.beta1

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,14 @@
+# 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
+      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