hanami 2.0.0.alpha4 → 2.0.0.alpha7

data/lib/hanami/application.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
-require "dry/system/loader/autoloading"
 require "hanami/configuration"
 require "pathname"
 require "rack"
 require "zeitwerk"
+require_relative "constants"
 require_relative "slice"
-require_relative "application/autoloader/inflector_adapter"
-require_relative "application/router"
-require_relative "application/routes"
-require_relative "application/settings"
+require_relative "application/slice_registrar"
 
 module Hanami
   # Hanami application class
@@ -21,13 +18,15 @@ module Hanami
 
     class << self
       def inherited(klass)
+        super
         @_mutex.synchronize do
           klass.class_eval do
-            @_mutex         = Mutex.new
-            @_configuration = Hanami::Configuration.new(env: Hanami.env)
+            @_mutex = Mutex.new
+            @_configuration = Hanami::Configuration.new(application_name: name, env: Hanami.env)
+            @autoloader = Zeitwerk::Loader.new
+            @container = Class.new(Dry::System::Container)
 
             extend ClassMethods
-            include InstanceMethods
           end
 
           klass.send :prepare_base_load_path
@@ -41,9 +40,11 @@ module Hanami
     #
     # rubocop:disable Metrics/ModuleLength
     module ClassMethods
+      attr_reader :autoloader, :container
+
       def self.extended(klass)
         klass.class_eval do
-          @inited = @booted = false
+          @prepared = @booted = false
         end
       end
 
@@ -51,129 +52,102 @@ module Hanami
         @_configuration
       end
 
-      alias config configuration
+      alias_method :config, :configuration
+
+      def prepare(provider_name = nil)
+        container.prepare(provider_name) and return self if provider_name
 
-      def init # rubocop:disable Metrics/MethodLength
-        return self if inited?
+        return self if prepared?
 
         configuration.finalize!
 
-        @autoloader = Zeitwerk::Loader.new
-        autoloader.inflector = Autoloader::InflectorAdapter.new(inflector)
+        prepare_all
 
-        load_settings
+        @prepared = true
+        self
+      end
 
-        @container = prepare_container
-        @deps_module = prepare_deps_module
+      def boot(&block)
+        return self if booted?
 
-        load_slices
-        slices.values.each(&:init)
-        slices.freeze
+        prepare
 
-        autoloader.setup
+        container.finalize!(&block)
 
-        @inited = true
+        slices.each(&:boot)
+
+        @booted = true
         self
       end
 
-      def inited?
-        @inited
+      def shutdown
+        slices.each(&:shutdown)
+        container.shutdown!
+        self
       end
 
-      def autoloader
-        raise "Application not init'ed" unless defined?(@autoloader)
-
-        @autoloader
+      def prepared?
+        !!@prepared
       end
 
-      def container
-        raise "Application not init'ed" unless defined?(@container)
-
-        @container
+      def booted?
+        !!@booted
       end
 
-      def deps
-        raise "Application not init'ed" unless defined?(@deps_module)
+      def router
+        raise "Application not yet prepared" unless prepared?
 
-        @deps_module
+        @_mutex.synchronize do
+          @_router ||= load_router
+        end
       end
 
-      def slices
-        @slices ||= {}
+      def rack_app
+        @rack_app ||= router.to_rack_app
       end
 
-      def register_slice(name, **slice_args)
-        raise "Slice +#{name}+ already registered" if slices.key?(name.to_sym)
-
-        slice = Slice.new(self, name: name, **slice_args)
-        slice.namespace.const_set :Slice, slice if slice.namespace # rubocop:disable Style/SafeNavigation
-        slices[name.to_sym] = slice
+      def slices
+        @slices ||= SliceRegistrar.new(self)
       end
 
-      def register(*args, **opts, &block)
-        container.register(*args, **opts, &block)
+      def register_slice(...)
+        slices.register(...)
       end
 
-      def register_bootable(*args, **opts, &block)
-        container.boot(*args, **opts, &block)
+      def register(...)
+        container.register(...)
       end
 
-      def init_bootable(*args)
-        container.init(*args)
+      def register_provider(...)
+        container.register_provider(...)
       end
 
-      def start_bootable(*args)
-        container.start(*args)
+      def start(...)
+        container.start(...)
       end
 
-      def key?(*args)
-        container.key?(*args)
+      def key?(...)
+        container.key?(...)
       end
 
       def keys
         container.keys
       end
 
-      def [](*args)
-        container[*args]
+      def [](...)
+        container.[](...)
       end
 
-      def resolve(*args)
-        container.resolve(*args)
-      end
-
-      def boot(&block)
-        return self if booted?
-
-        init
-
-        load_router
-
-        container.finalize!(&block)
-
-        slices.values.each(&:boot)
-
-        @booted = true
-        self
-      end
-
-      def booted?
-        @booted
-      end
-
-      def shutdown
-        container.shutdown!
+      def resolve(...)
+        container.resolve(...)
       end
 
       def settings
         @_settings ||= load_settings
       end
 
-      MODULE_DELIMITER = "::"
-      private_constant :MODULE_DELIMITER
-
       def namespace
-        inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
+        configuration.namespace
       end
 
       def namespace_name
@@ -185,7 +159,7 @@ module Hanami
       end
 
       def application_name
-        inflector.underscore(namespace).to_sym
+        configuration.application_name
       end
 
       def root
@@ -198,10 +172,10 @@ module Hanami
 
       # @api private
       def component_provider(component)
-        raise "Hanami.application must be inited before detecting providers" unless inited?
+        raise "Hanami.application must be prepared before detecting providers" unless prepared?
 
-        # [Admin, Main, MyApp] or [MyApp::Admin, MyApp::Main, MyApp]
-        providers = slices.values + [self]
+        # e.g. [Admin, Main, MyApp]
+        providers = slices.to_a + [self]
 
         component_class = component.is_a?(Class) ? component : component.class
         component_name = component_class.name
@@ -211,41 +185,6 @@ module Hanami
         providers.detect { |provider| component_name.include?(provider.namespace.to_s) }
       end
 
-      def router
-        @_mutex.synchronize do
-          @_router ||= load_router
-        end
-      end
-
-      def load_router
-        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
-      end
-
-      def routes
-        require File.join(configuration.root, configuration.router.routes_path)
-        routes_class = autodiscover_application_constant(configuration.router.routes_class_name)
-        routes_class.routes
-      rescue LoadError
-        proc {}
-      end
-
-      def resolver
-        config.router.resolver.new(
-          slices: slices,
-          inflector: inflector
-        )
-      end
-
       private
 
       def prepare_base_load_path
@@ -253,96 +192,63 @@ module Hanami
         $LOAD_PATH.unshift base_path unless $LOAD_PATH.include?(base_path)
       end
 
-      def prepare_container
-        define_container.tap do |container|
-          configure_container container
-        end
-      end
-
-      def prepare_deps_module
-        define_deps_module
+      def prepare_all
+        load_settings
+        prepare_container_plugins
+        prepare_container_base_config
+        prepare_container_consts
+        container.configured!
+        prepare_slices
+        # For the application, the autoloader must be prepared after the slices, since
+        # they'll be configuring the autoloader with their own dirs
+        prepare_autoloader
       end
 
-      def define_container
-        require "#{application_name}/container"
-        namespace.const_get :Container
-      rescue LoadError, NameError
-        namespace.const_set :Container, Class.new(Dry::System::Container)
+      def prepare_container_plugins
+        container.use(:env, inferrer: -> { Hanami.env })
+        container.use(:zeitwerk, loader: autoloader, run_setup: false, eager_load: false)
+        container.use(:notifications)
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-      def configure_container(container)
-        container.use :env, inferrer: -> { Hanami.env }
-        container.use :notifications
-
-        container.configure do |config|
-          config.inflector = configuration.inflector
+      def prepare_container_base_config
+        container.config.root = configuration.root
+        container.config.inflector = configuration.inflector
 
-          config.root = configuration.root
-          config.bootable_dirs = [
-            "config/boot",
-            Pathname(__dir__).join("application/container/boot").realpath,
-          ]
-
-          config.component_dirs.loader = Dry::System::Loader::Autoloading
-          config.component_dirs.add_to_load_path = false
-        end
+        container.config.provider_dirs = [
+          "config/providers",
+          Pathname(__dir__).join("application/container/providers").realpath,
+        ]
+      end
 
+      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)
         end
-
-        # Add lib/ to to the $LOAD_PATH so other files there (outside the app namespace)
-        # are require-able
-        container.add_to_load_path!("lib") if root.join("lib").directory?
-
-        container
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      def define_deps_module
-        require "#{application_name}/deps"
-        namespace.const_get :Deps
-      rescue LoadError, NameError
+      def prepare_container_consts
+        namespace.const_set :Container, container
         namespace.const_set :Deps, container.injector
       end
 
-      def load_slices
-        Dir[File.join(slices_path, "*")]
-          .select(&File.method(:directory?))
-          .each(&method(:load_slice))
-      end
-
-      def slices_path
-        File.join(root, config.slices_dir)
+      def prepare_slices
+        slices.load_slices.each(&:prepare)
+        slices.freeze
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def load_slice(slice_path)
-        slice_path = Pathname(slice_path)
-
-        slice_name = slice_path.relative_path_from(Pathname(slices_path)).to_s
-        slice_const_name = inflector.camelize(slice_name)
-
-        if config.slices_namespace.const_defined?(slice_const_name)
-          slice_module = config.slices_namespace.const_get(slice_const_name)
-
-          raise "Cannot use slice +#{slice_const_name}+ since it is not a module" unless slice_module.is_a?(Module)
-        else
-          slice_module = Module.new
-          config.slices_namespace.const_set inflector.camelize(slice_name), slice_module
+      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)
         end
 
-        register_slice(
-          slice_name,
-          namespace: slice_module,
-          root: slice_path.realpath
-        )
+        autoloader.setup
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def load_settings
+        require_relative "application/settings"
+
         prepare_base_load_path
         require File.join(configuration.root, configuration.settings_path)
         settings_class = autodiscover_application_constant(configuration.settings_class_name)
@@ -354,24 +260,40 @@ module Hanami
       def autodiscover_application_constant(constants)
         inflector.constantize([namespace_name, *constants].join(MODULE_DELIMITER))
       end
-    end
-    # rubocop:enable Metrics/ModuleLength
 
-    # Application instance interface
-    module InstanceMethods
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def initialize(application = self.class)
+      def load_router
         require_relative "application/router"
 
-        application.boot
+        Router.new(
+          routes: load_routes,
+          resolver: router_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
+      end
+
+      def load_routes
+        require_relative "application/routes"
 
-        @app = application.router.to_rack_app
+        require File.join(configuration.root, configuration.router.routes_path)
+        routes_class = autodiscover_application_constant(configuration.router.routes_class_name)
+        routes_class.routes
+      rescue LoadError
+        proc {}
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-      def call(env)
-        @app.call(env)
+      def router_resolver
+        config.router.resolver.new(
+          slices: slices,
+          inflector: inflector
+        )
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/hanami/boot/source_dirs.rb

@@ -0,0 +1,44 @@
+module Hanami
+  module Boot
+    module SourceDirs
+      def self.setup_component_dir!(component_dir, slice, container)
+        # TODO: this `== "lib"` check should be codified into a method somewhere
+        if component_dir.path == "lib"
+          # Expect component files in the root of the lib
+          # component dir to define classes inside the slice's namespace.
+          #
+          # e.g. "lib/foo.rb" should define SliceNamespace::Foo, and will be
+          # registered as "foo"
+          component_dir.namespaces.root(key: nil, const: slice.namespace_path)
+
+          slice.application.autoloader.push_dir(slice.root.join("lib"), namespace: slice.namespace)
+
+          container.config.component_dirs.add(component_dir)
+        else
+          # Expect component files in the root of these component dirs to define
+          # classes inside a namespace matching the dir.
+          #
+          # e.g. "actions/foo.rb" should define SliceNamespace::Actions::Foo, and
+          # will be registered as "actions.foo"
+
+          dir_namespace_path = File.join(slice.namespace_path, component_dir.path)
+
+          autoloader_namespace = begin
+            slice.inflector.constantize(slice.inflector.camelize(dir_namespace_path))
+          rescue NameError
+            slice.namespace.const_set(slice.inflector.camelize(component_dir.path), Module.new)
+          end
+
+          # TODO: do we need to do something special to clear out any previously configured root namespace here?
+          component_dir.namespaces.root(const: dir_namespace_path, key: component_dir.path) # TODO: do we need to swap path delimiters for key delimiters here?
+          container.config.component_dirs.add(component_dir)
+
+          slice.application.autoloader.push_dir(
+            slice.root.join(component_dir.path),
+            namespace: autoloader_namespace
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hanami/cli/application/cli.rb

@@ -26,7 +26,7 @@ module Hanami
             # of the boot process respect the provided env
             ENV["HANAMI_ENV"] = arguments[:env] if arguments[:env]
 
-            require "hanami/init"
+            require "hanami/prepare"
             application = Hanami.application
 
             [command.with_application(application), arguments]

data/lib/hanami/configuration/actions.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# require_relative "application_configuration/cookies"
+# require_relative "application_configuration/sessions"
+# require_relative "application_configuration/content_security_policy"
+# require_relative "configuration"
+# require_relative "view_name_inferrer"
+
+module Hanami
+  class Configuration
+    class Actions
+      include Dry::Configurable
+
+      setting :cookies, default: {}, constructor: -> options { Cookies.new(options) }
+      setting :sessions, constructor: proc { |storage, *options| Sessions.new(storage, *options) }
+      setting :csrf_protection
+
+      setting :name_inference_base, default: "actions"
+      setting :view_context_identifier, default: "view.context"
+      setting :view_name_inferrer, default: ViewNameInferrer
+      setting :view_name_inference_base, default: "views"
+
+      attr_accessor :content_security_policy
+
+      def initialize(*, **options)
+        super()
+
+        @base_configuration = Configuration.new
+        @content_security_policy = ContentSecurityPolicy.new do |csp|
+          if assets_server_url = options[:assets_server_url]
+            csp[:script_src] += " #{assets_server_url}"
+            csp[:style_src] += " #{assets_server_url}"
+          end
+        end
+
+        configure_defaults
+      end
+
+      def finalize!
+        # A nil value for `csrf_protection` means it has not been explicitly configured
+        # (neither true nor false), so we can default it to whether sessions are enabled
+        self.csrf_protection = sessions.enabled? if csrf_protection.nil?
+
+        if self.content_security_policy
+          self.default_headers["Content-Security-Policy"] = self.content_security_policy.to_str
+        end
+      end
+
+      # Returns the list of available settings
+      #
+      # @return [Set]
+      #
+      # @since 2.0.0
+      # @api private
+      def settings
+        base_configuration.settings + self.class.settings
+      end
+
+      private
+
+      attr_reader :base_configuration
+
+      # Apply defaults for base configuration settings
+      def configure_defaults
+        self.default_request_format = :html
+        self.default_response_format = :html
+
+        self.default_headers = {
+          "X-Frame-Options" => "DENY",
+          "X-Content-Type-Options" => "nosniff",
+          "X-XSS-Protection" => "1; mode=block"
+        }
+      end
+
+      def method_missing(name, *args, &block)
+        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, _incude_all = false)
+        config.respond_to?(name) || base_configuration.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/configuration/logger.rb

@@ -13,14 +13,58 @@ module Hanami
 
       protected :config
 
+      setting :application_name
+
+      setting :level
+
+      setting :stream
+
+      setting :formatter
+
+      setting :colors
+
+      setting :filters, default: %w[_csrf password password_confirmation].freeze
+
+      setting :options, default: [], constructor: ->(value) { Array(value).flatten }, cloneable: true
+
       setting :logger_class, default: Hanami::Logger
 
-      setting :options, default: {level: :debug}
+      def initialize(env:, application_name:)
+        @env = env
+        @application_name = application_name
+
+        config.level = case env
+                       when :production
+                         :info
+                       else
+                         :debug
+                       end
 
-      # Currently used for logging of Rack requests only.
-      #
-      # TODO: incorporate this into the standard logging some way or another
-      setting :filter_params, default: %w[_csrf password password_confirmation].freeze
+        config.stream = case env
+                        when :test
+                          File.join("log", "#{env}.log")
+                        else
+                          $stdout
+                        end
+
+        config.formatter = case env
+                           when :production
+                             :json
+                           end
+
+        config.colors = case env
+                        when :production, :test
+                          false
+                        end
+      end
+
+      def finalize!
+        config.application_name = @application_name.call
+      end
+
+      def instance
+        logger_class.new(application_name, *options, stream: stream, level: level, formatter: formatter, filter: filters, colorizer: colors)
+      end
 
       private