hanami 2.0.0.alpha5 → 2.0.0.alpha7.1

data/lib/hanami/application.rb

@@ -1,13 +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/slice_registrar"
 
 module Hanami
   # Hanami application class
@@ -18,10 +18,13 @@ module Hanami
 
     class << self
       def inherited(klass)
+        super
         @_mutex.synchronize do
           klass.class_eval do
-            @_mutex         = Mutex.new
+            @_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
           end
@@ -37,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
 
@@ -47,76 +52,50 @@ module Hanami
         @_configuration
       end
 
-      alias config configuration
-
-      def init # rubocop:disable Metrics/MethodLength
-        return self if inited?
-
-        configuration.finalize!
-
-        @autoloader = Zeitwerk::Loader.new
-        autoloader.inflector = Autoloader::InflectorAdapter.new(inflector)
+      alias_method :config, :configuration
 
-        load_settings
+      def prepare(provider_name = nil)
+        container.prepare(provider_name) and return self if provider_name
 
-        @container = prepare_container
-        @deps_module = prepare_deps_module
+        return self if prepared?
 
-        load_slices
-        slices.values.each(&:init)
-        slices.freeze
+        configuration.finalize!
 
-        autoloader.setup
+        prepare_all
 
-        @inited = true
+        @prepared = true
         self
       end
 
       def boot(&block)
         return self if booted?
 
-        init
+        prepare
 
         container.finalize!(&block)
 
-        slices.values.each(&:boot)
+        slices.each(&:boot)
 
         @booted = true
         self
       end
 
       def shutdown
+        slices.each(&:shutdown)
         container.shutdown!
+        self
       end
 
-      def inited?
-        @inited
+      def prepared?
+        !!@prepared
       end
 
       def booted?
-        @booted
-      end
-
-      def autoloader
-        raise "Application not init'ed" unless defined?(@autoloader)
-
-        @autoloader
-      end
-
-      def container
-        raise "Application not init'ed" unless defined?(@container)
-
-        @container
-      end
-
-      def deps
-        raise "Application not init'ed" unless defined?(@deps_module)
-
-        @deps_module
+        !!@booted
       end
 
       def router
-        raise "Application not init'ed" unless inited?
+        raise "Application not yet prepared" unless prepared?
 
         @_mutex.synchronize do
           @_router ||= load_router
@@ -128,47 +107,39 @@ module Hanami
       end
 
       def slices
-        @slices ||= {}
-      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
+        @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)
+      def resolve(...)
+        container.resolve(...)
       end
 
       def settings
@@ -201,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
@@ -221,94 +192,59 @@ 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
-
-          config.root = configuration.root
-          config.bootable_dirs = [
-            "config/boot",
-            Pathname(__dir__).join("application/container/boot").realpath,
-          ]
+      def prepare_container_base_config
+        container.config.root = configuration.root
+        container.config.inflector = configuration.inflector
 
-          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"
@@ -321,9 +257,6 @@ module Hanami
         Settings.new
       end
 
-      MODULE_DELIMITER = "::"
-      private_constant :MODULE_DELIMITER
-
       def autodiscover_application_constant(constants)
         inflector.constantize([namespace_name, *constants].join(MODULE_DELIMITER))
       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.rb

@@ -13,6 +13,7 @@ require_relative "configuration/middleware"
 require_relative "configuration/router"
 require_relative "configuration/sessions"
 require_relative "configuration/source_dirs"
+require_relative "constants"
 
 module Hanami
   # Hanami application configuration
@@ -26,8 +27,7 @@ module Hanami
     DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
     private_constant :DEFAULT_ENVIRONMENTS
 
-    MODULE_DELIMITER = "::"
-    private_constant :MODULE_DELIMITER
+    attr_reader :env
 
     attr_reader :actions
     attr_reader :middleware
@@ -41,7 +41,7 @@ module Hanami
       @namespace = application_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
 
       @environments = DEFAULT_ENVIRONMENTS.clone
-      config.env = env
+      @env = env
 
       # Some default setting values must be assigned at initialize-time to ensure they
       # have appropriate values for the current application
@@ -117,16 +117,9 @@ module Hanami
       inflector.underscore(@namespace).to_sym
     end
 
-    setting :env
-
-    def env=(new_env)
-      config.env = env
-      apply_env_config(new_env)
-    end
-
     setting :root, constructor: -> path { Pathname(path) }
 
-    setting :inflector, default: Dry::Inflector.new, cloneable: true
+    setting :inflector, default: Dry::Inflector.new
 
     def inflections(&block)
       self.inflector = Dry::Inflector.new(&block)
@@ -148,20 +141,8 @@ module Hanami
 
     setting :settings_store, default: Application::Settings::DotenvStore
 
-    setting :slices_dir, default: "slices"
-
-    setting :slices_namespace, default: Object
-
-    # TODO: convert into a dedicated object with explicit behaviour around blocks per
-    # slice, etc.
-    setting :slices, default: {}, constructor: :dup.to_proc
-
     setting :source_dirs, default: Configuration::SourceDirs.new, cloneable: true
 
-    def slice(slice_name, &block)
-      slices[slice_name] = block
-    end
-
     setting :base_url, default: "http://0.0.0.0:2300", constructor: -> url { URI(url) }
 
     def for_each_middleware(&blk)

data/lib/hanami/constants.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @api private
+  MODULE_DELIMITER = "::"
+  private_constant :MODULE_DELIMITER
+
+  # @api private
+  CONFIG_DIR = "config"
+  private_constant :CONFIG_DIR
+
+  # @api private
+  SLICES_DIR = "slices"
+  private_constant :SLICES_DIR
+
+  # @api private
+  LIB_DIR = "lib"
+  private_constant :LIB_DIR
+
+  # @api private
+  RB_EXT = ".rb"
+  private_constant :RB_EXT
+end

data/lib/hanami/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @since 2.0.0
+  Error = Class.new(StandardError)
+
+  # @since 2.0.0
+  ApplicationLoadError = Class.new(Error)
+
+  # @since 2.0.0
+  SliceLoadError = Class.new(Error)
+end

data/lib/hanami/{init.rb → prepare.rb}

@@ -2,4 +2,4 @@
 
 require_relative "setup"
 
-Hanami.init
+Hanami.prepare