hanami 2.0.0.alpha7.1 → 2.0.0.beta1.1

data/lib/hanami/configuration/views.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/view"
+
+module Hanami
+  class Configuration
+    # Hanami actions configuration
+    #
+    # @since 2.0.0
+    class Views
+      include Dry::Configurable
+
+      setting :parts_path, default: "views/parts"
+
+      attr_reader :base_configuration
+      protected :base_configuration
+
+      def initialize(*)
+        super
+
+        @base_configuration = Hanami::View.config.dup
+
+        configure_defaults
+      end
+
+      def initialize_copy(source)
+        super
+        @base_configuration = source.base_configuration.dup
+      end
+
+      # Returns the list of available settings
+      #
+      # @return [Set]
+      #
+      # @since 2.0.0
+      # @api private
+      def settings
+        self.class.settings + View.settings - NON_FORWARDABLE_METHODS
+      end
+
+      def finalize!
+        return self if frozen?
+
+        base_configuration.finalize!
+
+        super
+      end
+
+      private
+
+      def configure_defaults
+        self.paths = ["templates"]
+        self.template_inference_base = "views"
+        self.layout = "app"
+      end
+
+      # An inflector for views is not configurable via `config.views.inflector` on an
+      # `Hanami::App`. The app-wide inflector is already configurable
+      # there as `config.inflector` and will be used as the default inflector for views.
+      #
+      # A custom inflector may still be provided in an `Hanami::View` subclass, via
+      # `config.inflector=`.
+      NON_FORWARDABLE_METHODS = %i[inflector inflector=].freeze
+      private_constant :NON_FORWARDABLE_METHODS
+
+      def method_missing(name, *args, &block)
+        return super if NON_FORWARDABLE_METHODS.include?(name)
+
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        elsif base_configuration.respond_to?(name)
+          base_configuration.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _include_all = false)
+        return false if NON_FORWARDABLE_METHODS.include?(name)
+
+        config.respond_to?(name) || base_configuration.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/configuration.rb

@@ -7,88 +7,134 @@ require "dry/configurable"
 require "dry/inflector"
 require "pathname"
 
-require_relative "application/settings/dotenv_store"
+require_relative "constants"
 require_relative "configuration/logger"
-require_relative "configuration/middleware"
 require_relative "configuration/router"
 require_relative "configuration/sessions"
-require_relative "configuration/source_dirs"
-require_relative "constants"
+require_relative "settings/dotenv_store"
+require_relative "slice/routing/middleware/stack"
 
 module Hanami
-  # Hanami application configuration
+  # Hanami app configuration
   #
   # @since 2.0.0
-  #
-  # rubocop:disable Metrics/ClassLength
   class Configuration
     include Dry::Configurable
 
+    setting :root, constructor: ->(path) { Pathname(path) if path }
+
+    setting :no_auto_register_paths, default: %w[entities]
+
+    setting :inflector, default: Dry::Inflector.new
+
+    setting :settings_store, default: Hanami::Settings::DotenvStore
+
+    setting :slices do
+      setting :shared_component_keys, default: %w[
+        inflector
+        logger
+        notifications
+        rack.monitor
+        routes
+        settings
+      ]
+    end
+
+    setting :base_url, default: "http://0.0.0.0:2300", constructor: ->(url) { URI(url) }
+
+    setting :sessions, default: :null, constructor: ->(*args) { Sessions.new(*args) }
+
+    setting :logger, cloneable: true
+
     DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
     private_constant :DEFAULT_ENVIRONMENTS
 
+    # @return [Symbol] The name of the application
+    #
+    # @api public
+    attr_reader :app_name
+
+    # @return [String] The current environment
+    #
+    # @api public
     attr_reader :env
 
+    # @return [Hanami::Configuration::Actions]
+    #
+    # @api public
     attr_reader :actions
+
+    # @return [Hanami::Slice::Routing::Middleware::Stack]
+    #
+    # @api public
     attr_reader :middleware
+
+    # @api private
+    alias_method :middleware_stack, :middleware
+
+    # @return [Hanami::Configuration::Router]
+    #
+    # @api public
     attr_reader :router
-    attr_reader :views, :assets
 
+    # @return [Hanami::Configuration::Views]
+    #
+    # @api public
+    attr_reader :views
+
+    # @return [Hanami::Assets::AppConfiguration]
+    #
+    # @api public
+    attr_reader :assets
+
+    # @return [Concurrent::Hash] A hash of default environments
+    #
+    # @api private
     attr_reader :environments
     private :environments
 
-    def initialize(application_name:, env:)
-      @namespace = application_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
+    # @api private
+    def initialize(app_name:, env:)
+      @app_name = app_name
 
       @environments = DEFAULT_ENVIRONMENTS.clone
       @env = env
 
       # Some default setting values must be assigned at initialize-time to ensure they
-      # have appropriate values for the current application
+      # have appropriate values for the current app
       self.root = Dir.pwd
-      self.settings_store = Application::Settings::DotenvStore.new.with_dotenv_loaded
-
-      config.logger = Configuration::Logger.new(env: env, application_name: method(:application_name))
-
-      @assets = begin
-        require_path = "hanami/assets/application_configuration"
-        require require_path
-        Hanami::Assets::ApplicationConfiguration.new
-      rescue LoadError => e
-        raise e unless e.path == require_path
-        require_relative "configuration/null_configuration"
-        NullConfiguration.new
-      end
+      self.settings_store = Hanami::Settings::DotenvStore.new.with_dotenv_loaded
 
-      # Config for actions (same for views, below) may not be available if the gem isn't
-      # loaded; fall back to a null config object if it's missing
-      @actions = begin
-        require_path = "hanami/action/application_configuration"
-        require require_path
-        Hanami::Action::ApplicationConfiguration.new(assets_server_url: assets.server_url)
-      rescue LoadError => e
-        raise e unless e.path == require_path
-        require_relative "configuration/null_configuration"
-        NullConfiguration.new
-      end
+      config.logger = Configuration::Logger.new(env: env, app_name: app_name)
+
+      @assets = load_dependent_config("hanami/assets/app_configuration") {
+        Hanami::Assets::AppConfiguration.new
+      }
+
+      @actions = load_dependent_config("hanami/action") {
+        require_relative "configuration/actions"
+        Actions.new
+      }
 
-      @middleware = Middleware.new
+      @middleware = Slice::Routing::Middleware::Stack.new
 
       @router = Router.new(self)
 
-      @views = begin
-        require_path = "hanami/view/application_configuration"
-        require require_path
-        Hanami::View::ApplicationConfiguration.new
-      rescue LoadError => e
-        raise e unless e.path == require_path
-        require_relative "configuration/null_configuration"
-        NullConfiguration.new
-      end
+      @views = load_dependent_config("hanami/view") {
+        require_relative "configuration/views"
+        Views.new
+      }
 
       yield self if block_given?
     end
 
+    # Apply configuration for the given environment
+    #
+    # @param env [String] the environment name
+    #
+    # @return [Hanami::Configuration]
+    #
+    # @api public
     def environment(env_name, &block)
       environments[env_name] << block
       apply_env_config
@@ -96,6 +142,34 @@ module Hanami
       self
     end
 
+    # Configure application's inflections
+    #
+    # @see https://dry-rb.org/gems/dry-inflector
+    #
+    # @return [Dry::Inflector]
+    #
+    # @api public
+    def inflections(&block)
+      self.inflector = Dry::Inflector.new(&block)
+    end
+
+    # @api private
+    def initialize_copy(source)
+      super
+
+      @app_name = app_name.dup
+      @environments = environments.dup
+
+      @assets = source.assets.dup
+      @actions = source.actions.dup
+      @middleware = source.middleware.dup
+      @router = source.router.dup.tap do |router|
+        router.instance_variable_set(:@base_configuration, self)
+      end
+      @views = source.views.dup
+    end
+
+    # @api private
     def finalize!
       apply_env_config
 
@@ -109,59 +183,41 @@ module Hanami
       super
     end
 
-    def namespace
-      inflector.constantize(@namespace)
-    end
-
-    def application_name
-      inflector.underscore(@namespace).to_sym
-    end
-
-    setting :root, constructor: -> path { Pathname(path) }
-
-    setting :inflector, default: Dry::Inflector.new
-
-    def inflections(&block)
-      self.inflector = Dry::Inflector.new(&block)
-    end
-
-    setting :logger, cloneable: true
-
+    # Set a default global logger instance
+    #
+    # @api public
     def logger=(logger_instance)
       @logger_instance = logger_instance
     end
 
+    # Return configured logger instance
+    #
+    # @api public
     def logger_instance
       @logger_instance || logger.instance
     end
 
-    setting :settings_path, default: File.join("config", "settings")
-
-    setting :settings_class_name, default: "Settings"
-
-    setting :settings_store, default: Application::Settings::DotenvStore
-
-    setting :source_dirs, default: Configuration::SourceDirs.new, cloneable: true
-
-    setting :base_url, default: "http://0.0.0.0:2300", constructor: -> url { URI(url) }
-
-    def for_each_middleware(&blk)
-      stack = middleware.stack.dup
-      stack += sessions.middleware if sessions.enabled?
-
-      stack.each(&blk)
-    end
-
-    setting :sessions, default: :null, constructor: -> *args { Sessions.new(*args) }
-
     private
 
+    # @api private
     def apply_env_config(env = self.env)
       environments[env].each do |block|
         instance_eval(&block)
       end
     end
 
+    # @api private
+    def load_dependent_config(require_path, &block)
+      require require_path
+      yield
+    rescue LoadError => e
+      raise e unless e.path == require_path
+
+      require_relative "configuration/null_configuration"
+      NullConfiguration.new
+    end
+
+    # @api private
     def method_missing(name, *args, &block)
       if config.respond_to?(name)
         config.public_send(name, *args, &block)
@@ -170,6 +226,7 @@ module Hanami
       end
     end
 
+    # @api private
     def respond_to_missing?(name, _incude_all = false)
       config.respond_to?(name) || super
     end

data/lib/hanami/constants.rb

@@ -1,22 +1,50 @@
 # frozen_string_literal: true
 
 module Hanami
+  # @api private
+  CONTAINER_KEY_DELIMITER = "."
+  private_constant :CONTAINER_KEY_DELIMITER
+
   # @api private
   MODULE_DELIMITER = "::"
   private_constant :MODULE_DELIMITER
 
+  # @api private
+  PATH_DELIMITER = "/"
+  private_constant :PATH_DELIMITER
+
   # @api private
   CONFIG_DIR = "config"
   private_constant :CONFIG_DIR
 
   # @api private
-  SLICES_DIR = "slices"
-  private_constant :SLICES_DIR
+  APP_DIR = "app"
+  private_constant :APP_DIR
 
   # @api private
   LIB_DIR = "lib"
   private_constant :LIB_DIR
 
+  # @api private
+  SLICES_DIR = "slices"
+  private_constant :SLICES_DIR
+
+  # @api private
+  ROUTES_PATH = File.join(CONFIG_DIR, "routes")
+  private_constant :ROUTES_PATH
+
+  # @api private
+  ROUTES_CLASS_NAME = "Routes"
+  private_constant :ROUTES_CLASS_NAME
+
+  # @api private
+  SETTINGS_PATH = File.join(CONFIG_DIR, "settings")
+  private_constant :SETTINGS_PATH
+
+  # @api private
+  SETTINGS_CLASS_NAME = "Settings"
+  private_constant :SETTINGS_CLASS_NAME
+
   # @api private
   RB_EXT = ".rb"
   private_constant :RB_EXT

data/lib/hanami/errors.rb

@@ -5,8 +5,11 @@ module Hanami
   Error = Class.new(StandardError)
 
   # @since 2.0.0
-  ApplicationLoadError = Class.new(Error)
+  AppLoadError = Class.new(Error)
 
   # @since 2.0.0
   SliceLoadError = Class.new(Error)
+
+  # @since 2.0.0
+  ComponentLoadError = Class.new(Error)
 end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "hanami/action"
+
+module Hanami
+  module Extensions
+    module 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::Extensions::Action::InstanceMethods#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.() },
+              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
+          identifier = actions_config.view_context_identifier
+
+          if slice.key?(identifier)
+            slice[identifier]
+          elsif slice.app.key?(identifier)
+            slice.app[identifier]
+          end
+        end
+
+        def resolve_routes
+          slice.app["routes"] if slice.app.key?("routes")
+        end
+
+        def actions_config
+          slice.config.actions
+        end
+      end
+    end
+  end
+end

data/lib/hanami/extensions/action.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "hanami/action"
+require_relative "../slice_configurable"
+require_relative "action/slice_configured_action"
+
+module Hanami
+  module Extensions
+    # Extended behavior for actions intended for use within an Hanami app.
+    #
+    # @see Hanami::Action
+    #
+    # @api public
+    # @since 2.0.0
+    module Action
+      def self.included(action_class)
+        super
+
+        action_class.extend(Hanami::SliceConfigurable)
+        action_class.extend(ClassMethods)
+        action_class.prepend(InstanceMethods)
+      end
+
+      module ClassMethods
+        def configure_for_slice(slice)
+          extend SliceConfiguredAction.new(slice)
+        end
+      end
+
+      module InstanceMethods
+        attr_reader :view, :view_context, :routes
+
+        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 finish(req, res, halted)
+          res.render(view, **req.params) if !halted && auto_render?(res)
+          super
+        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
+
+        # 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
+end
+
+Hanami::Action.include(Hanami::Extensions::Action)