piko-lite-box 0.0.1

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # Provides slice-specific helper methods for any view object requiring access to helpers.
+      #
+      # @api public
+      # @since 2.1.0
+      class SliceConfiguredHelpers < Module
+        attr_reader :slice
+
+        # @api private
+        # @since 2.1.0
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        # @api private
+        # @since 2.1.0
+        def extended(klass)
+          include_helpers(klass)
+        end
+
+        # @return [String]
+        #
+        # @api public
+        # @since 2.1.0
+        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/hanami-3.0.1/lib/hanami/extensions/view/slice_configured_part.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # Provides slice-specific configuration and behavior for any view part class defined within a
+      # slice's module namespace.
+      #
+      # @api public
+      # @since 2.1.0
+      class SliceConfiguredPart < Module
+        attr_reader :slice
+
+        # @api private
+        # @since 2.1.0
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        # @api private
+        # @since 2.1.0
+        def extended(klass)
+          define_new
+        end
+
+        # @return [String]
+        #
+        # @api public
+        # @since 2.1.0
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        # Defines a `.new` method on the part class that provides a default `rendering:` argument of
+        # a rendering coming from a view configured for the slice. This means that any part can be
+        # initialized standalone (with a `value:` only) and still have access to all the integrated
+        # view facilities from the slice, such as helpers. This is helpful when unit testing parts.
+        #
+        # @example
+        #   module MyApp::Views::Parts
+        #     class Post < MyApp::View::Part
+        #       def title_tag
+        #         helpers.h1(value.title)
+        #       end
+        #     end
+        #   end
+        #
+        #   # Useful when unit testing parts
+        #   part = MyApp::Views::Parts::Post.new(value: hello_world_post)
+        #   part.title_tag # => "<h1>Hello world</h1>"
+        def define_new
+          slice = self.slice
+
+          define_method(:new) do |**args|
+            return super(**args) if args.key?(:rendering)
+
+            # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+            # so the slice cannot be inferred from its name.
+            slice_rendering = Class.new(Hanami::View)
+              .configure_for_slice(slice)
+              .new
+              .rendering
+
+            super(rendering: slice_rendering, **args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # Provides slice-specific configuration and behavior for any view class defined within a
+      # slice's module namespace.
+      #
+      # @api public
+      # @since 2.1.0
+      class SliceConfiguredView < Module
+        TEMPLATES_DIR = "templates"
+        VIEWS_DIR = "views"
+        PARTS_DIR = "parts"
+        SCOPES_DIR = "scopes"
+
+        attr_reader :slice
+
+        # @api private
+        # @since 2.1.0
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        # @api private
+        # @since 2.1.0
+        def extended(view_class)
+          load_app_view
+          configure_view(view_class)
+          define_inherited
+        end
+
+        # @return [String]
+        #
+        # @api public
+        # @since 2.1.0
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        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 => exception
+            raise unless exception.name == :View
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def configure_view(view_class)
+          view_class.settings.each do |setting|
+            next unless slice.config.views.respond_to?(setting.name)
+
+            # Configure the view from config on the slice, _unless it has already been configured by
+            # a parent slice_, and re-configuring it for this slice would make no change.
+            #
+            # In the case of most slices, its views config is likely to be the same as its parent
+            # (since each slice copies its `config` from its parent), and if we re-apply the config
+            # here, then it may possibly overwrite config customisations explicitly made in parent
+            # view classes.
+            #
+            # For example, given an app-level base view class, with custom config:
+            #
+            #   module MyApp
+            #     class View < Hanami::View
+            #       config.layout = "custom_layout"
+            #     end
+            #   end
+            #
+            # And then a view in a slice inheriting from it:
+            #
+            #   module MySlice
+            #     module Views
+            #       class SomeView < MyApp::View
+            #       end
+            #     end
+            #   end
+            #
+            # In this case, `SliceConfiguredView` will be extended two times:
+            #
+            # 1. When `MyApp::View` is defined
+            # 2. Again when `MySlice::Views::SomeView` is defined
+            #
+            # If we blindly re-configure all view settings each time `SliceConfiguredView` is
+            # extended, then at the point of (2) above, we'd end up overwriting the custom
+            # `config.layout` explicitly configured in the `MyApp::View` base class, leaving
+            # `MySlice::Views::SomeView` with `config.layout` of `"app"` (the default as specified
+            # at `Hanami.app.config.views.layout`), and not the `"custom_layout"` value configured
+            # in its immediate superclass.
+            #
+            # This would be surprising behavior, and we want to avoid it.
+            slice_value = slice.config.views.public_send(setting.name)
+            parent_value = slice.parent.config.views.public_send(setting.name) if slice.parent
+
+            next if slice.parent && slice_value == parent_value
+
+            view_class.config.public_send(
+              :"#{setting.name}=",
+              setting.mutable? ? slice_value.dup : slice_value
+            )
+          end
+
+          view_class.config.inflector = inflector
+
+          # 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 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
+
+          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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def define_inherited
+          template_name = method(:template_name)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+            subclass.config.template = template_name.(subclass)
+          end
+        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)
+          path = "#{slice.slice_name.path}/#{path}"
+
+          begin
+            require path
+          rescue LoadError => exception
+            raise exception unless exception.path == path
+          end
+
+          begin
+            inflector.constantize(inflector.camelize(path))
+          rescue NameError # rubocop: disable Lint/SuppressedException
+          end
+        end
+
+        def template_name(view_class)
+          inflector
+            .underscore(view_class.name)
+            .sub(/^#{slice.slice_name.path}\//, "")
+            .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|
+                # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+                # so the slice cannot be inferred from its name.
+                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|
+                # Call configure_for_slice explicitly, since this is an anonymous class at this point,
+                # so the slice cannot be inferred from its name.
+                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
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Extensions
+    module View
+      # Module including the standard library of Hanami helpers
+      #
+      # @api public
+      # @since 2.1.0
+      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
+
+        if Hanami.bundled?("i18n")
+          include Helpers::I18nHelper
+        end
+      end
+    end
+  end
+end

data/hanami-3.0.1/lib/hanami/extensions/view.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+require_relative "view/slice_configured_view"
+
+module Hanami
+  # @api private
+  module Extensions
+    # Integrated behavior for `Hanami::View` classes within Hanami apps.
+    #
+    # @see Hanami::View
+    #
+    # @api public
+    # @since 2.1.0
+    module View
+      # @api private
+      # @since 2.1.0
+      def self.included(view_class)
+        super
+
+        view_class.extend(Hanami::SliceConfigurable)
+        view_class.extend(ClassMethods)
+      end
+
+      # @api private
+      # @since 2.1.0
+      module ClassMethods
+        # @api private
+        # @since 2.1.0
+        def configure_for_slice(slice)
+          extend SliceConfiguredView.new(slice)
+        end
+      end
+    end
+  end
+end
+
+Hanami::View.include(Hanami::Extensions::View)

data/hanami-3.0.1/lib/hanami/extensions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+if Hanami.bundled?("hanami-db")
+  require_relative "extensions/db/repo"
+end
+
+if Hanami.bundled?("hanami-action")
+  require_relative "extensions/action"
+end
+
+if Hanami.bundled?("hanami-view")
+  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
+
+if Hanami.bundled?("hanami-mailer")
+  require "hanami/mailer"
+  require_relative "extensions/mailer"
+end
+
+if Hanami.bundled?("dry-operation")
+  require_relative "extensions/operation"
+end