hanami 2.0.0.alpha8 → 2.0.0.beta1

data/lib/hanami/configuration.rb

@@ -7,51 +7,108 @@ 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
   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
 
-    attr_reader :application_name
+    # @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
 
-    # rubocop:disable Metrics/AbcSize
-    def initialize(application_name:, env:)
-      @application_name = application_name
+    # @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
+      self.settings_store = Hanami::Settings::DotenvStore.new.with_dotenv_loaded
 
-      config.logger = Configuration::Logger.new(env: env, application_name: application_name)
+      config.logger = Configuration::Logger.new(env: env, app_name: app_name)
 
-      @assets = load_dependent_config("hanami/assets/application_configuration") {
-        Hanami::Assets::ApplicationConfiguration.new
+      @assets = load_dependent_config("hanami/assets/app_configuration") {
+        Hanami::Assets::AppConfiguration.new
       }
 
       @actions = load_dependent_config("hanami/action") {
@@ -59,7 +116,7 @@ module Hanami
         Actions.new
       }
 
-      @middleware = Middleware.new
+      @middleware = Slice::Routing::Middleware::Stack.new
 
       @router = Router.new(self)
 
@@ -70,8 +127,14 @@ module Hanami
 
       yield self if block_given?
     end
-    # rubocop:enable Metrics/AbcSize
 
+    # 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
@@ -79,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
 
@@ -92,51 +183,30 @@ module Hanami
       super
     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
@@ -147,6 +217,7 @@ module Hanami
       NullConfiguration.new
     end
 
+    # @api private
     def method_missing(name, *args, &block)
       if config.respond_to?(name)
         config.public_send(name, *args, &block)
@@ -155,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,6 +1,7 @@
 # frozen_string_literal: true
 
 module Hanami
+  # @api private
   CONTAINER_KEY_DELIMITER = "."
   private_constant :CONTAINER_KEY_DELIMITER
 
@@ -8,6 +9,7 @@ module Hanami
   MODULE_DELIMITER = "::"
   private_constant :MODULE_DELIMITER
 
+  # @api private
   PATH_DELIMITER = "/"
   private_constant :PATH_DELIMITER
 
@@ -16,13 +18,33 @@ module Hanami
   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,7 +5,7 @@ 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)

data/lib/hanami/{application → extensions}/action/slice_configured_action.rb

@@ -3,8 +3,8 @@
 require "hanami/action"
 
 module Hanami
-  class Application
-    class Action < Hanami::Action
+  module Extensions
+    module Action
       # Provides slice-specific configuration and behavior for any action class defined
       # within a slice's module namespace.
       #
@@ -30,7 +30,7 @@ module Hanami
 
         private
 
-        # @see Hanami::Application::Action#initialize
+        # @see Hanami::Extensions::Action::InstanceMethods#initialize
         def define_new
           resolve_view = method(:resolve_paired_view)
           resolve_view_context = method(:resolve_view_context)
@@ -39,7 +39,7 @@ module Hanami
           define_method(:new) do |**kwargs|
             super(
               view: kwargs.fetch(:view) { resolve_view.(self) },
-              view_context: kwargs.fetch(:view_context) { resolve_view_context.(self) },
+              view_context: kwargs.fetch(:view_context) { resolve_view_context.() },
               routes: kwargs.fetch(:routes) { resolve_routes.() },
               **kwargs,
             )
@@ -80,22 +80,22 @@ module Hanami
           end
         end
 
-        def resolve_view_context(_action_class)
+        def resolve_view_context
           identifier = actions_config.view_context_identifier
 
           if slice.key?(identifier)
             slice[identifier]
-          elsif slice.application.key?(identifier)
-            slice.application[identifier]
+          elsif slice.app.key?(identifier)
+            slice.app[identifier]
           end
         end
 
         def resolve_routes
-          slice.application[:routes_helper] if slice.application.key?(:routes_helper)
+          slice.app["routes"] if slice.app.key?("routes")
         end
 
         def actions_config
-          slice.application.config.actions
+          slice.config.actions
         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)

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

@@ -0,0 +1,106 @@
+# 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
+  module Extensions
+    module View
+      # View context for views in Hanami apps.
+      #
+      # @api public
+      # @since 2.0.0
+      module Context
+        def self.included(context_class)
+          super
+
+          context_class.extend(Hanami::SliceConfigurable)
+          context_class.extend(ClassMethods)
+          context_class.prepend(InstanceMethods)
+        end
+
+        module ClassMethods
+          def configure_for_slice(slice)
+            extend SliceConfiguredContext.new(slice)
+          end
+        end
+
+        module InstanceMethods
+          # @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
+end
+
+Hanami::View::Context.include(Hanami::Extensions::View::Context)

data/lib/hanami/{application → extensions}/view/slice_configured_context.rb

@@ -3,8 +3,8 @@
 require "hanami/view"
 
 module Hanami
-  class Application
-    class View < Hanami::View
+  module Extensions
+    module View
       # Provides slice-specific configuration and behavior for any view context class
       # defined within a slice's module namespace.
       #
@@ -29,15 +29,15 @@ module Hanami
         private
 
         # Defines a {.new} method on the context class that resolves key components from
-        # the application container and provides them to {#initialize} as injected
+        # the app container and provides them to {#initialize} as injected
         # dependencies.
         #
-        # This includes the following application components:
+        # This includes the following app 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`
+        #   - "settings" from the app container as `settings`
+        #   - "routes" from the app container as `routes`
+        #   - "assets" from the app container as `assets`
         def define_new
           inflector = slice.inflector
           resolve_settings = method(:resolve_settings)
@@ -55,15 +55,15 @@ module Hanami
         end
 
         def resolve_settings
-          slice.application[:settings] if slice.application.key?(:settings)
+          slice.app[:settings] if slice.app.key?(:settings)
         end
 
         def resolve_routes
-          slice.application[:routes_helper] if slice.application.key?(:routes_helper)
+          slice.app["routes"] if slice.app.key?("routes")
         end
 
         def resolve_assets
-          slice.application[:assets] if slice.application.key?(:assets)
+          slice.app[:assets] if slice.app.key?(:assets)
         end
       end
     end

data/lib/hanami/{application → extensions}/view/slice_configured_view.rb

@@ -3,8 +3,8 @@
 require "hanami/view"
 
 module Hanami
-  class Application
-    class View < Hanami::View
+  module Extensions
+    module View
       # Provides slice-specific configuration and behavior for any view class defined
       # within a slice's module namespace.
       #
@@ -32,10 +32,10 @@ module Hanami
         # rubocop:disable Metrics/AbcSize
         def configure_view(view_class)
           view_class.settings.each do |setting|
-            if slice.application.config.views.respond_to?(:"#{setting}")
+            if slice.config.views.respond_to?(:"#{setting}")
               view_class.config.public_send(
                 :"#{setting}=",
-                slice.application.config.views.public_send(:"#{setting}")
+                slice.config.views.public_send(:"#{setting}")
               )
             end
           end
@@ -44,7 +44,7 @@ module Hanami
           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))
+          if (part_namespace = namespace_from_path(slice.config.views.parts_path))
             view_class.config.part_namespace = part_namespace
           end
         end
@@ -62,7 +62,13 @@ module Hanami
         def prepare_paths(slice, configured_paths)
           configured_paths.map { |path|
             if path.dir.relative?
-              slice.root.join(path.dir)
+              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

data/lib/hanami/extensions/view.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "hanami/view"
+require_relative "../slice_configurable"
+require_relative "view/slice_configured_view"
+
+module Hanami
+  module Extensions
+    # Extended behavior for actions intended for use within an Hanami app.
+    #
+    # @see Hanami::View
+    #
+    # @api public
+    # @since 2.0.0
+    module View
+      def self.included(view_class)
+        super
+
+        view_class.extend(Hanami::SliceConfigurable)
+        view_class.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # @api private
+        def configure_for_slice(slice)
+          extend SliceConfiguredView.new(slice)
+        end
+      end
+    end
+  end
+end
+
+Hanami::View.include(Hanami::Extensions::View)