hanami 2.0.0.alpha6 → 2.0.0.alpha8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fc76408b7d97db32194d24bf73739bde8405fbd13855b7e4ea744f634d0739e
-  data.tar.gz: 30d954f8332ea7579898a87187a89a0ae2a1b34b5d9f564a86b6f61c0844f2af
+  metadata.gz: 36c07c10545a327f0eab55e1a23e3a6f1b258dd7c4db890d16155d98a132bb90
+  data.tar.gz: 02a8dbd6f028e198dead1d972aef4a78b04246b3201e2c90f94e2827f4582906
 SHA512:
-  metadata.gz: f64124d027449d451f5be703f4c00850c826e4d55ebef1e6c396be63dea59a9019cb74438f7844f1e68a187299ea45c7f89ba1e98267380e7d8e1b1f8666e4b9
-  data.tar.gz: 8ea32aae47f0fe9536726c977af03904fa23f7258ef747b2cdd1a3b324eb064466beccc9340b7dddfb46d3d6a49c8aba899b1b488c6016377581599efd594577
+  metadata.gz: 938be86da6f4c1d5e797db8f0cc185feb2ac070c4d8ba10f48b6bbe922f8b1fd8b618c9871306a7f3d2d75c34a8fab857949d7f18dd04bb833be092fbb8ced27
+  data.tar.gz: 459f220765e02c024fe4b1a5e17ec7a13bba10e2cb3f1b64dfa059cd351bea4cffcd47be1ca5a1cd8b2c89757f20dbcaaa7e77fbfdacb05c9fc87345974e7ec0

data/CHANGELOG.md

@@ -1,6 +1,85 @@
 # Hanami
 The web, with simplicity.
 
+## v2.0.0.alpha8 - 2020-05-19
+
+## Added
+- [Tim Riley] Introduced `Hanami::Application::Action` as base class for actions that integrate with Hanami applications. Base action classes in Hanami applications should now inherit from this.
+- [Tim Riley] Introduced `Hanami::Application::View` and `Hanami::Application::View::Context` as base classes for views and view contexts that integrate with Hanami applications. Base view classes in Hanami applications should now inherit from these.
+- [Tim Riley] Introduced `Hanami::Application.application_name`, which returns an `Hanami::SliceName` instance, with methods for representing the application name in various formats.
+
+## Fixed
+- [Andrew Croome] When a request is halted, do not attempt to automatically render any view paired with an `Hanami::Application::Action`
+
+## Changed
+- [Tim Riley] `Hanami::Application.namespace_name`, `.namespace_path` have been removed. These can now be accessed from the `.application_name`.
+- [Tim Riley] `Hanami::Slice.slice_name` now returns an `Hanami::SliceName` instance instead of a Symbol
+- [Tim Riley] `Hanami::Slice.namespace_path` has been removed. This can now be accessed from the `.slice_name`.
+
+## v2.0.0.alpha7.1 - 2020-03-09
+
+## Fixed
+- [Tim Riley] Fixed error creating slice classes when the enclosing module did not already exist
+
+## v2.0.0.alpha7 - 2020-03-08
+
+## Added
+- [Tim Riley] Introduced `Hanami::ApplicationLoadError` and `Hanami::SliceLoadError` exceptions to represent errors encountered during application and slice loading.
+- [Tim Riley] `Hanami::Slice.shutdown` can be used to stop all the providers in a slice
+
+## Changed
+- [Tim Riley] Slices are now represented as concrete classes (such as `Main::Slice`) inheriting from `Hanami::Slice`, as opposed to _instances_ of `Hanami::Slice`. You may create your own definitions for these slices in `config/slices/[slice_name].rb`, which you can then use for customising per-slice config and behavior, e.g.
+
+    ```ruby
+    # config/slices/main.rb:
+
+    module Main
+      class Slice < Hanami::Slice
+        # slice config here
+      end
+    end
+    ```
+- [Tim Riley] Application-level `config.slice(slice_name, &block)` setting has been removed in favour of slice configuration within concrete slice class definitions
+- [Tim Riley] You can configure your slice imports inside your slice classes, e.g.
+
+    ```ruby
+    # config/slices/main.rb:
+
+    module Main
+      class Slice < Hanami::Slice
+        # Import all exported components from "search" slice
+        import from: :search
+      end
+    end
+    ```
+- [Tim Riley] You can configure your slice exports inside your slice classes, e.g.
+
+    ```ruby
+    # config/slices/search.rb:
+
+    module Search
+      class Slice < Hanami::Slice
+        # Export the "index_entity" component only
+        export ["index_entity"]
+      end
+    end
+    ```
+- [Tim Riley] For advanced cases, you can configure your slice's container via a `prepare_container` block:
+
+    ```ruby
+    # config/slices/search.rb:
+
+    module Search
+      class Slice < Hanami::Slice
+        prepare_container do |container|
+          # `container` object is available here, with
+          # slice-specific configuration already applied
+        end
+      end
+    end
+    ```
+- [Tim Riley] `Hanami::Application.shutdown` will now also shutdown all registered slices
+
 ## v2.0.0.alpha6 - 2022-02-10
 ### Added
 - [Luca Guidi] Official support for Ruby: MRI 3.1

data/lib/hanami/application/action/slice_configured_action.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "hanami/action"
+
+module Hanami
+  class Application
+    class Action < Hanami::Action
+      # Provides slice-specific configuration and behavior for any action class defined
+      # within a slice's module namespace.
+      #
+      # @api private
+      # @since 2.0.0
+      class SliceConfiguredAction < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(action_class)
+          configure_action(action_class)
+          extend_behavior(action_class)
+          define_new
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        # @see Hanami::Application::Action#initialize
+        def define_new
+          resolve_view = method(:resolve_paired_view)
+          resolve_view_context = method(:resolve_view_context)
+          resolve_routes = method(:resolve_routes)
+
+          define_method(:new) do |**kwargs|
+            super(
+              view: kwargs.fetch(:view) { resolve_view.(self) },
+              view_context: kwargs.fetch(:view_context) { resolve_view_context.(self) },
+              routes: kwargs.fetch(:routes) { resolve_routes.() },
+              **kwargs,
+            )
+          end
+        end
+
+        def configure_action(action_class)
+          action_class.config.settings.each do |setting|
+            action_class.config.public_send :"#{setting}=", actions_config.public_send(:"#{setting}")
+          end
+        end
+
+        def extend_behavior(action_class)
+          if actions_config.sessions.enabled?
+            require "hanami/action/session"
+            action_class.include Hanami::Action::Session
+          end
+
+          if actions_config.csrf_protection
+            require "hanami/action/csrf_protection"
+            action_class.include Hanami::Action::CSRFProtection
+          end
+
+          if actions_config.cookies.enabled?
+            require "hanami/action/cookies"
+            action_class.include Hanami::Action::Cookies
+          end
+        end
+
+        def resolve_paired_view(action_class)
+          view_identifiers = actions_config.view_name_inferrer.call(
+            action_class_name: action_class.name,
+            slice: slice,
+          )
+
+          view_identifiers.detect do |identifier|
+            break slice[identifier] if slice.key?(identifier)
+          end
+        end
+
+        def resolve_view_context(_action_class)
+          identifier = actions_config.view_context_identifier
+
+          if slice.key?(identifier)
+            slice[identifier]
+          elsif slice.application.key?(identifier)
+            slice.application[identifier]
+          end
+        end
+
+        def resolve_routes
+          slice.application[:routes_helper] if slice.application.key?(:routes_helper)
+        end
+
+        def actions_config
+          slice.application.config.actions
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/action.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "hanami/action"
+require "hanami/slice_configurable"
+require_relative "action/slice_configured_action"
+
+module Hanami
+  class Application
+    # Superclass for actions intended for use within an Hanami application.
+    #
+    # @see Hanami::Action
+    #
+    # @api public
+    # @since 2.0.0
+    class Action < Hanami::Action
+      extend Hanami::SliceConfigurable
+
+      class << self
+        # @api private
+        def configure_for_slice(slice)
+          extend SliceConfiguredAction.new(slice)
+        end
+      end
+
+      attr_reader :view, :view_context, :routes
+
+      # @see SliceConfiguredAction#define_new
+      # @api public
+      def initialize(view: nil, view_context: nil, routes: nil, **kwargs)
+        @view = view
+        @view_context = view_context
+        @routes = routes
+
+        super(**kwargs)
+      end
+
+      private
+
+      def build_response(**options)
+        options = options.merge(view_options: method(:view_options))
+        super(**options)
+      end
+
+      def view_options(req, res)
+        {context: view_context&.with(**view_context_options(req, res))}.compact
+      end
+
+      def view_context_options(req, res)
+        {request: req, response: res}
+      end
+
+      def finish(req, res, halted)
+        res.render(view, **req.params) if !halted && auto_render?(res)
+        super
+      end
+
+      # Returns true if a view should automatically be rendered onto the response body.
+      #
+      # This may be overridden to enable/disable automatic rendering.
+      #
+      # @param res [Hanami::Action::Response]
+      #
+      # @return [Boolean]
+      #
+      # @since 2.0.0
+      # @api public
+      def auto_render?(res)
+        view && res.body.empty?
+      end
+    end
+  end
+end

data/lib/hanami/application/routing/router.rb

@@ -0,0 +1,36 @@
+# # frozen_string_literal: true
+
+# require "hanami/application/router"
+
+# Hanami.application.register_provider :router do
+#   start do
+#     configuration = Hanami.application.configuration
+
+#     routes = begin
+#       require File.join(configuration.root, configuration.router.routes_path)
+#       routes_class = Hanami.application.send(:autodiscover_application_constant, configuration.router.routes_class_name) # WIP private
+#       routes_class.routes
+#     rescue LoadError
+#       proc {}
+#     end
+
+#     resolver = configuration.router.resolver.new(
+#       slices: Hanami.application.slices,
+#       inflector: Hanami.application.inflector # TODO: use container[:inflector]?
+#     )
+
+#     router = Hanami::Application::Router.new(
+#       routes: routes,
+#       resolver: resolver,
+#       **configuration.router.options,
+#     ) do
+#       use Hanami.application[:rack_monitor]
+
+#       Hanami.application.config.for_each_middleware do |m, *args, &block|
+#         use(m, *args, &block)
+#       end
+#     end
+
+#     register :router, router
+#   end
+# end

data/lib/hanami/application/slice_registrar.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+require_relative "../slice"
+
+module Hanami
+  class Application
+    # @api private
+    class SliceRegistrar
+      attr_reader :application, :slices
+      private :application, :slices
+
+      def initialize(application)
+        @application = application
+        @slices = {}
+      end
+
+      def register(name, slice_class = nil, &block)
+        if slices.key?(name.to_sym)
+          raise SliceLoadError, "Slice '#{name}' is already registered"
+        end
+
+        # TODO: raise error unless name meets format (i.e. single level depth only)
+
+        slices[name.to_sym] = slice_class || build_slice(name, &block)
+      end
+
+      def [](name)
+        slices.fetch(name) do
+          raise SliceLoadError, "Slice '#{name}' not found"
+        end
+      end
+
+      def freeze
+        slices.freeze
+        super
+      end
+
+      def load_slices
+        slice_configs = Dir[root.join(CONFIG_DIR, "slices", "*#{RB_EXT}")]
+          .map { |file| File.basename(file, RB_EXT) }
+
+        slice_dirs = Dir[File.join(root, SLICES_DIR, "*")]
+          .select { |path| File.directory?(path) }
+          .map { |path| File.basename(path) }
+
+        (slice_dirs + slice_configs).uniq.sort.each do |slice_name|
+          load_slice(slice_name)
+        end
+
+        self
+      end
+
+      def each(&block)
+        slices.each_value(&block)
+      end
+
+      def to_a
+        slices.values
+      end
+
+      private
+
+      # Attempts to load a slice class defined in `config/slices/[slice_name].rb`, then
+      # registers the slice with the matching class, if found.
+      def load_slice(slice_name)
+        slice_const_name = inflector.camelize(slice_name)
+        slice_require_path = root.join("config", "slices", slice_name).to_s
+
+        begin
+          require(slice_require_path)
+        rescue LoadError => e
+          raise e unless e.path == slice_require_path
+        end
+
+        slice_class =
+          begin
+            inflector.constantize("#{slice_const_name}::Slice")
+          rescue NameError # rubocop:disable Lint/SuppressedException
+          end
+
+        register(slice_name, slice_class)
+      end
+
+      def build_slice(slice_name, &block)
+        slice_module =
+          begin
+            slice_module_name = inflector.camelize(slice_name.to_s)
+            inflector.constantize(slice_module_name)
+          rescue NameError
+            Object.const_set(inflector.camelize(slice_module_name), Module.new)
+          end
+
+        slice_module.const_set(:Slice, Class.new(Hanami::Slice, &block))
+      end
+
+      def root
+        application.root
+      end
+
+      def inflector
+        application.inflector
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+require "hanami/view/context"
+require_relative "../../errors"
+require_relative "../../slice_configurable"
+require_relative "slice_configured_context"
+
+module Hanami
+  class Application
+    class View < Hanami::View
+      # View context for views in Hanami applications.
+      #
+      # @api public
+      # @since 2.0.0
+      class Context < Hanami::View::Context
+        extend Hanami::SliceConfigurable
+
+        # @api private
+        def self.configure_for_slice(slice)
+          extend SliceConfiguredContext.new(slice)
+        end
+
+        # @see SliceConfiguredContext#define_new
+        def initialize(**kwargs)
+          defaults = {content: {}}
+
+          super(**kwargs, **defaults)
+        end
+
+        def inflector
+          _options.fetch(:inflector)
+        end
+
+        def routes
+          _options.fetch(:routes)
+        end
+
+        def settings
+          _options.fetch(:settings)
+        end
+
+        def assets
+          unless _options[:assets]
+            raise Hanami::ComponentLoadError, "hanami-assets gem is required to access assets"
+          end
+
+          _options[:assets]
+        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
+
+        def current_path
+          request.fullpath
+        end
+
+        def csrf_token
+          request.session[Hanami::Action::CSRFProtection::CSRF_TOKEN]
+        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
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+
+module Hanami
+  class Application
+    class View < Hanami::View
+      # Provides slice-specific configuration and behavior for any view context class
+      # defined within a slice's module namespace.
+      #
+      # @api private
+      # @since 2.0.0
+      class SliceConfiguredContext < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(_context_class)
+          define_new
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        # Defines a {.new} method on the context class that resolves key components from
+        # the application container and provides them to {#initialize} as injected
+        # dependencies.
+        #
+        # This includes the following application components:
+        #
+        #   - the configured inflector as `inflector`
+        #   - "settings" from the application container as `settings`
+        #   - "routes" from the application container as `routes`
+        #   - "assets" from the application container as `assets`
+        def define_new
+          inflector = slice.inflector
+          resolve_settings = method(:resolve_settings)
+          resolve_routes = method(:resolve_routes)
+          resolve_assets = method(:resolve_assets)
+
+          define_method :new do |**kwargs|
+            kwargs[:inflector] ||= inflector
+            kwargs[:settings] ||= resolve_settings.()
+            kwargs[:routes] ||= resolve_routes.()
+            kwargs[:assets] ||= resolve_assets.()
+
+            super(**kwargs)
+          end
+        end
+
+        def resolve_settings
+          slice.application[:settings] if slice.application.key?(:settings)
+        end
+
+        def resolve_routes
+          slice.application[:routes_helper] if slice.application.key?(:routes_helper)
+        end
+
+        def resolve_assets
+          slice.application[:assets] if slice.application.key?(:assets)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+
+module Hanami
+  class Application
+    class View < Hanami::View
+      # Provides slice-specific configuration and behavior for any view class defined
+      # within a slice's module namespace.
+      #
+      # @api private
+      # @since 2.0.0
+      class SliceConfiguredView < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(view_class)
+          configure_view(view_class)
+          define_inherited
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize
+        def configure_view(view_class)
+          view_class.settings.each do |setting|
+            if slice.application.config.views.respond_to?(:"#{setting}")
+              view_class.config.public_send(
+                :"#{setting}=",
+                slice.application.config.views.public_send(:"#{setting}")
+              )
+            end
+          end
+
+          view_class.config.inflector = inflector
+          view_class.config.paths = prepare_paths(slice, view_class.config.paths)
+          view_class.config.template = template_name(view_class)
+
+          if (part_namespace = namespace_from_path(slice.application.config.views.parts_path))
+            view_class.config.part_namespace = part_namespace
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def define_inherited
+          template_name = method(:template_name)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+            subclass.config.template = template_name.(subclass)
+          end
+        end
+
+        def prepare_paths(slice, configured_paths)
+          configured_paths.map { |path|
+            if path.dir.relative?
+              slice.root.join(path.dir)
+            else
+              path
+            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 => exception
+          end
+        end
+
+        def template_name(view_class)
+          slice
+            .inflector
+            .underscore(view_class.name)
+            .sub(/^#{slice.slice_name.path}\//, "")
+            .sub(/^#{view_class.config.template_inference_base}\//, "")
+        end
+
+        def inflector
+          slice.inflector
+        end
+      end
+    end
+  end
+end