hanami 2.0.0.alpha7.1 → 2.0.0.alpha8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8db2d523a265dd089048a2a944ccf8b1d5d46a36d496be5638f4807fe3c451ad
-  data.tar.gz: fe510075e1e4d362e6c6419aab0d0b001eb8bf80329d51f7546f9955abf08cf6
+  metadata.gz: 36c07c10545a327f0eab55e1a23e3a6f1b258dd7c4db890d16155d98a132bb90
+  data.tar.gz: 02a8dbd6f028e198dead1d972aef4a78b04246b3201e2c90f94e2827f4582906
 SHA512:
-  metadata.gz: 1af19f64f99af6997e772e25d49a5e835ea9e8ebac64aaab637fe56a0c91ea1b87d4a13d04b26145b58573d12478bd435183873e4cf7378e2b2046866e9a0fa4
-  data.tar.gz: d7be6b435ac445a23ceb616180493c863715dca8a039a81e2ab3af0aa49d60f73806625909dbee05aad4b1bab77b7b77fc6c94600f937cbe7e5af206f67efa82
+  metadata.gz: 938be86da6f4c1d5e797db8f0cc185feb2ac070c4d8ba10f48b6bbe922f8b1fd8b618c9871306a7f3d2d75c34a8fab857949d7f18dd04bb833be092fbb8ced27
+  data.tar.gz: 459f220765e02c024fe4b1a5e17ec7a13bba10e2cb3f1b64dfa059cd351bea4cffcd47be1ca5a1cd8b2c89757f20dbcaaa7e77fbfdacb05c9fc87345974e7ec0

data/CHANGELOG.md

@@ -1,6 +1,21 @@
 # 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

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/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

data/lib/hanami/application/view.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+require_relative "../slice_configurable"
+require_relative "view/slice_configured_view"
+
+module Hanami
+  class Application
+    # Superclass for views intended for use within an Hanami application.
+    #
+    # @see Hanami::View
+    #
+    # @api public
+    # @since 2.0.0
+    class View < Hanami::View
+      extend Hanami::SliceConfigurable
+
+      # @api private
+      def self.configure_for_slice(slice)
+        extend SliceConfiguredView.new(slice)
+      end
+    end
+  end
+end

data/lib/hanami/application/view_name_inferrer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../constants"
+
+module Hanami
+  class Application
+    # Infers a view name for automatically rendering within actions.
+    #
+    # @api private
+    # @since 2.0.0
+    class ViewNameInferrer
+      ALTERNATIVE_NAMES = {
+        "create" => "new",
+        "update" => "edit"
+      }.freeze
+
+      class << self
+        # Returns an array of container keys for views matching the given action.
+        #
+        # Also provides alternative view keys for common RESTful actions.
+        #
+        # @example
+        #   ViewNameInferrer.call(action_name: "Main::Actions::Posts::Create", slice: Main::Slice)
+        #   # => ["views.posts.create", "views.posts.new"]
+        #
+        # @param action_name [String] action class name
+        # @param slice [Hanami::Slice, Hanami::Application] Hanami slice containing the action
+        #
+        # @return [Array<string>] array of paired view container keys
+        def call(action_class_name:, slice:)
+          action_key_base = slice.application.config.actions.name_inference_base
+          view_key_base = slice.application.config.actions.view_name_inference_base
+
+          action_name_key = action_name_key(action_class_name, slice, action_key_base)
+
+          view_key = [view_key_base, action_name_key].compact.join(CONTAINER_KEY_DELIMITER)
+
+          [view_key, alternative_view_key(view_key)].compact
+        end
+
+        private
+
+        def action_name_key(action_name, slice, key_base)
+          slice
+            .inflector
+            .underscore(action_name)
+            .sub(%r{^#{slice.slice_name.path}#{PATH_DELIMITER}}, "")
+            .sub(%r{^#{key_base}#{PATH_DELIMITER}}, "")
+            .gsub("/", CONTAINER_KEY_DELIMITER)
+        end
+
+        def alternative_view_key(view_key)
+          parts = view_key.split(CONTAINER_KEY_DELIMITER)
+
+          alternative_name = ALTERNATIVE_NAMES[parts.last]
+          return unless alternative_name
+
+          [parts[0..-2], alternative_name].join(CONTAINER_KEY_DELIMITER)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application.rb

@@ -7,6 +7,7 @@ require "rack"
 require "zeitwerk"
 require_relative "constants"
 require_relative "slice"
+require_relative "slice_name"
 require_relative "application/slice_registrar"
 
 module Hanami
@@ -17,21 +18,25 @@ module Hanami
     @_mutex = Mutex.new
 
     class << self
-      def inherited(klass)
+      def inherited(subclass)
         super
+
         @_mutex.synchronize do
-          klass.class_eval do
+          subclass.class_eval do
             @_mutex = Mutex.new
-            @_configuration = Hanami::Configuration.new(application_name: name, env: Hanami.env)
+            @application_name = SliceName.new(subclass, inflector: -> { subclass.inflector })
+            @configuration = Hanami::Configuration.new(application_name: @application_name, env: Hanami.env)
             @autoloader = Zeitwerk::Loader.new
             @container = Class.new(Dry::System::Container)
 
+            @prepared = @booted = false
+
             extend ClassMethods
           end
 
-          klass.send :prepare_base_load_path
+          subclass.send :prepare_base_load_path
 
-          Hanami.application = klass
+          Hanami.application = subclass
         end
       end
     end
@@ -40,20 +45,16 @@ module Hanami
     #
     # rubocop:disable Metrics/ModuleLength
     module ClassMethods
-      attr_reader :autoloader, :container
-
-      def self.extended(klass)
-        klass.class_eval do
-          @prepared = @booted = false
-        end
-      end
+      attr_reader :application_name, :configuration, :autoloader, :container
 
-      def configuration
-        @_configuration
-      end
+      alias_method :slice_name, :application_name
 
       alias_method :config, :configuration
 
+      def application
+        self
+      end
+
       def prepare(provider_name = nil)
         container.prepare(provider_name) and return self if provider_name
 
@@ -147,19 +148,7 @@ module Hanami
       end
 
       def namespace
-        configuration.namespace
-      end
-
-      def namespace_name
-        namespace.name
-      end
-
-      def namespace_path
-        inflector.underscore(namespace)
-      end
-
-      def application_name
-        configuration.application_name
+        application_name.namespace
       end
 
       def root
@@ -170,21 +159,6 @@ module Hanami
         configuration.inflector
       end
 
-      # @api private
-      def component_provider(component)
-        raise "Hanami.application must be prepared before detecting providers" unless prepared?
-
-        # e.g. [Admin, Main, MyApp]
-        providers = slices.to_a + [self]
-
-        component_class = component.is_a?(Class) ? component : component.class
-        component_name = component_class.name
-
-        return unless component_name
-
-        providers.detect { |provider| component_name.include?(provider.namespace.to_s) }
-      end
-
       private
 
       def prepare_base_load_path
@@ -222,8 +196,8 @@ module Hanami
 
       def prepare_autoload_paths
         # Autoload classes defined in lib/[app_namespace]/
-        if root.join("lib", namespace_path).directory?
-          autoloader.push_dir(root.join("lib", namespace_path), namespace: namespace)
+        if root.join("lib", application_name.name).directory?
+          autoloader.push_dir(root.join("lib", application_name.name), namespace: namespace)
         end
       end
 
@@ -239,8 +213,8 @@ module Hanami
 
       def prepare_autoloader
         # Autoload classes defined in lib/[app_namespace]/
-        if root.join("lib", namespace_path).directory?
-          autoloader.push_dir(root.join("lib", namespace_path), namespace: namespace)
+        if root.join("lib", application_name.name).directory?
+          autoloader.push_dir(root.join("lib", application_name.name), namespace: namespace)
         end
 
         autoloader.setup
@@ -258,7 +232,7 @@ module Hanami
       end
 
       def autodiscover_application_constant(constants)
-        inflector.constantize([namespace_name, *constants].join(MODULE_DELIMITER))
+        inflector.constantize([application_name.namespace_name, *constants].join(MODULE_DELIMITER))
       end
 
       def load_router