hanami 2.0.0.alpha2 → 2.0.0.alpha3

data/lib/hanami/configuration/sessions.rb

@@ -9,8 +9,11 @@ module Hanami
     #
     # @since 2.0.0
     class Sessions
+      NULL_SESSION_OPTION = :null
+      private_constant :NULL_SESSION_OPTION
+
       def self.null
-        NULL_STORAGE
+        self.class.new(NULL_SESSION_OPTION)
       end
 
       attr_reader :storage, :options
@@ -23,7 +26,7 @@ module Hanami
       end
 
       def enabled?
-        storage != NULL_STORAGE
+        storage != NULL_SESSION_OPTION
       end
 
       def middleware
@@ -32,9 +35,6 @@ module Hanami
 
       private
 
-      NULL_STORAGE = :null
-      private_constant :NULL_STORAGE
-
       def storage_middleware
         require_storage
 

data/lib/hanami/configuration.rb

@@ -3,9 +3,15 @@
 require "uri"
 require "concurrent/hash"
 require "concurrent/array"
+require "dry/configurable"
 require "dry/inflector"
 require "pathname"
-require "zeitwerk"
+
+require_relative "application/settings/dotenv_store"
+require_relative "configuration/logger"
+require_relative "configuration/middleware"
+require_relative "configuration/router"
+require_relative "configuration/sessions"
 
 module Hanami
   # Hanami application configuration
@@ -14,207 +20,124 @@ module Hanami
   #
   # rubocop:disable Metrics/ClassLength
   class Configuration
-    require_relative "configuration/middleware"
-    require_relative "configuration/router"
-    require_relative "configuration/sessions"
+    include Dry::Configurable
+
+    DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
+    private_constant :DEFAULT_ENVIRONMENTS
 
     attr_reader :actions
+    attr_reader :middleware
+    attr_reader :router
     attr_reader :views
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-    def initialize(env:)
-      @settings = Concurrent::Hash.new
-
-      self.autoloader = Zeitwerk::Loader.new
+    attr_reader :environments
+    private :environments
 
-      self.env = env
-      self.environments = DEFAULT_ENVIRONMENTS.clone
+    def initialize(env:)
+      @environments = DEFAULT_ENVIRONMENTS.clone
+      config.env = env
 
+      # Some default setting values must be assigned at initialize-time to ensure they
+      # have appropriate values for the current application
       self.root = Dir.pwd
-      self.slices_dir = DEFAULT_SLICES_DIR
-      settings[:slices] = {}
-
-      self.settings_path = DEFAULT_SETTINGS_PATH
-      self.settings_loader_options = {}
-
-      self.base_url = DEFAULT_BASE_URL
-
-      self.logger   = DEFAULT_LOGGER.clone
-      self.rack_logger_filter_params = DEFAULT_RACK_LOGGER_FILTER_PARAMS.clone
-      self.sessions = DEFAULT_SESSIONS
-
-      self.router     = Router.new(base_url)
-      self.middleware = Middleware.new
-
-      self.inflections = Dry::Inflector.new
+      self.settings_store = Application::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
       rescue LoadError => e
         raise e unless e.path == require_path
-        Object.new
+        require_relative "configuration/null_configuration"
+        NullConfiguration.new
       end
 
+      @middleware = Middleware.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
-        Object.new
+        require_relative "configuration/null_configuration"
+        NullConfiguration.new
       end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-    def finalize
-      environment_for(env).each do |blk|
-        instance_eval(&blk)
-      end
-
-      # Finalize nested configuration
-      #
-      # TODO: would be good to just create empty configurations for actions/views
-      #       instead of plain objects
-      actions.finalize! if actions.respond_to?(:finalize!)
-      views.finalize! if views.respond_to?(:finalize!)
-
-      self
-    end
-
-    def environment(name, &blk)
-      environment_for(name).push(blk)
-    end
-
-    def autoloader=(loader)
-      settings[:autoloader] = loader || nil
-    end
-
-    def autoloader
-      settings.fetch(:autoloader)
-    end
-
-    def env=(value)
-      settings[:env] = value
-    end
 
-    def env
-      settings.fetch(:env)
+      yield self if block_given?
     end
 
-    def root=(root)
-      settings[:root] = Pathname(root)
-    end
-
-    def root
-      settings.fetch(:root)
-    end
-
-    def slices_dir=(dir)
-      settings[:slices_dir] = dir
-    end
-
-    def slices_dir
-      settings.fetch(:slices_dir)
-    end
-
-    def slices_namespace=(namespace)
-      settings[:slices_namespace] = namespace
-    end
+    def environment(env_name, &block)
+      environments[env_name] << block
+      apply_env_config
 
-    def slices_namespace
-      settings.fetch(:slices_namespace) { Object }
+      self
     end
 
-    def slice(slice_name, &block)
-      settings[:slices][slice_name] = block
-    end
+    def finalize!
+      apply_env_config
 
-    def slices
-      settings[:slices]
-    end
+      # Finalize nested configurations
+      actions.finalize!
+      views.finalize!
+      logger.finalize!
+      router.finalize!
 
-    def settings_path=(value)
-      settings[:settings_path] = value
+      super
     end
 
-    def settings_path
-      settings.fetch(:settings_path)
-    end
+    setting :env
 
-    def settings_loader=(loader)
-      settings[:settings_loader] = loader
+    def env=(new_env)
+      config.env = env
+      apply_env_config(new_env)
     end
 
-    def settings_loader
-      settings.fetch(:settings_loader) {
-        require "hanami/application/settings/loader"
-        settings[:settings_loader] = Application::Settings::Loader
-      }
-    end
+    setting :root, constructor: -> path { Pathname(path) }
 
-    def settings_loader_options=(options)
-      settings[:settings_loader_options] = options
-    end
+    setting :inflector, default: Dry::Inflector.new, cloneable: true
 
-    def settings_loader_options
-      settings[:settings_loader_options]
+    def inflections(&block)
+      self.inflector = Dry::Inflector.new(&block)
     end
 
-    def base_url=(value)
-      settings[:base_url] = URI.parse(value)
-    end
+    setting :logger, default: Configuration::Logger.new, cloneable: true
 
-    def base_url
-      settings.fetch(:base_url)
+    def logger=(logger_instance)
+      @logger_instance = logger_instance
     end
 
-    def logger=(options)
-      settings[:logger] = options
+    def logger_instance
+      @logger_instance || logger.logger_class.new(**logger.options)
     end
 
-    def logger
-      settings.fetch(:logger)
-    end
+    setting :settings_path, default: File.join("config", "settings")
 
-    def rack_logger_filter_params=(params)
-      settings[:rack_logger_filter_params] = params
-    end
+    setting :settings_class_name, default: "Settings"
 
-    def rack_logger_filter_params
-      settings[:rack_logger_filter_params]
-    end
+    setting :settings_store, default: Application::Settings::DotenvStore
 
-    def router=(value)
-      settings[:router] = value
-    end
+    setting :slices_dir, default: "slices"
 
-    def router
-      settings.fetch(:router)
-    end
+    setting :slices_namespace, default: Object
 
-    def sessions=(*args)
-      settings[:sessions] = Sessions.new(args)
-    end
+    # TODO: convert into a dedicated object with explicit behaviour around blocks per
+    # slice, etc.
+    setting :slices, default: {}, constructor: :dup.to_proc
 
-    def sessions
-      settings.fetch(:sessions)
-    end
+    # TODO: turn this into a richer "source dirs" setting that can support enabling
+    # of container component loading as an opt in behvior
+    setting :component_dir_paths, default: %w[actions repositories views]
 
-    def middleware
-      settings.fetch(:middleware)
-    end
-
-    def inflections(&blk)
-      if blk.nil?
-        settings.fetch(:inflections)
-      else
-        settings[:inflections] = Dry::Inflector.new(&blk)
-      end
+    def slice(slice_name, &block)
+      slices[slice_name] = block
     end
 
-    alias inflector inflections
+    setting :base_url, default: "http://0.0.0.0:2300", constructor: -> url { URI(url) }
 
     def for_each_middleware(&blk)
       stack = middleware.stack.dup
@@ -223,48 +146,26 @@ module Hanami
       stack.each(&blk)
     end
 
-    protected
+    setting :sessions, default: :null, constructor: -> *args { Sessions.new(*args) }
 
-    def environment_for(name)
-      settings[:environments][name]
-    end
+    private
 
-    def environments=(values)
-      settings[:environments] = values
+    def apply_env_config(env = self.env)
+      environments[env].each do |block|
+        instance_eval(&block)
+      end
     end
 
-    def middleware=(value)
-      settings[:middleware] = value
+    def method_missing(name, *args, &block)
+      if config.respond_to?(name)
+        config.public_send(name, *args, &block)
+      else
+        super
+      end
     end
 
-    def inflections=(value)
-      settings[:inflections] = value
+    def respond_to_missing?(name, _incude_all = false)
+      config.respond_to?(name) || super
     end
-
-    private
-
-    DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
-    private_constant :DEFAULT_ENVIRONMENTS
-
-    DEFAULT_SLICES_DIR = "slices"
-    private_constant :DEFAULT_SLICES_DIR
-
-    DEFAULT_BASE_URL = "http://0.0.0.0:2300"
-    private_constant :DEFAULT_BASE_URL
-
-    DEFAULT_LOGGER = { level: :debug }.freeze
-    private_constant :DEFAULT_LOGGER
-
-    DEFAULT_RACK_LOGGER_FILTER_PARAMS = %w[_csrf password password_confirmation].freeze
-    private_constant :DEFAULT_RACK_LOGGER_FILTER_PARAMS
-
-    DEFAULT_SETTINGS_PATH = File.join("config", "settings")
-    private_constant :DEFAULT_SETTINGS_PATH
-
-    DEFAULT_SESSIONS = Sessions.null
-    private_constant :DEFAULT_SESSIONS
-
-    attr_reader :settings
   end
-  # rubocop:enable Metrics/ClassLength
 end

data/lib/hanami/slice.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
+require "dry/system/loader/autoloading"
 require "pathname"
 
 module Hanami
@@ -103,29 +104,57 @@ module Hanami
         config.name = name
         config.inflector = application.configuration.inflector
 
-        if application.configuration.autoloader
-          require "dry/system/loader/autoloading"
-          config.component_dirs.loader = Dry::System::Loader::Autoloading
-          config.component_dirs.add_to_load_path = false
-        end
+        config.component_dirs.loader = Dry::System::Loader::Autoloading
+        config.component_dirs.add_to_load_path = false
 
         if root&.directory?
           config.root = root
           config.bootable_dirs = ["config/boot"]
 
+          # Add the "lib" component dir; all slices will load components from lib
           if root.join("lib").directory?
-            config.component_dirs.add "lib" do |dir|
-              dir.default_namespace = namespace_path.tr(File::SEPARATOR, config.namespace_separator)
+            config.component_dirs.add("lib") do |component_dir|
+              # 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: namespace_path)
+
+              application.autoloader.push_dir(root.join("lib"), namespace: namespace)
             end
+          end
+
+          # Add component dirs for each configured component path
+          application.configuration.component_dir_paths.each do |slice_dir|
+            next unless root.join(slice_dir).directory?
+
+            config.component_dirs.add(slice_dir) do |component_dir|
+              # 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(namespace_path, slice_dir)
 
-            application.configuration.autoloader&.push_dir(root.join("lib"))
+              autoloader_namespace = begin
+                inflector.constantize(inflector.camelize(dir_namespace_path))
+              rescue NameError
+                namespace.const_set(inflector.camelize(slice_dir), Module.new)
+              end
+
+              component_dir.namespaces.root(const: dir_namespace_path, key: slice_dir)
+
+              application.autoloader.push_dir(
+                container.root.join(slice_dir),
+                namespace: autoloader_namespace
+              )
+            end
           end
         end
       end
 
-      # Force after configure hook to run
-      container.configure do; end
-
       if namespace
         namespace.const_set :Container, container
         namespace.const_set :Deps, container.injector

data/lib/hanami/version.rb

@@ -8,7 +8,7 @@ module Hanami
   module Version
     # @since 0.9.0
     # @api private
-    VERSION = "2.0.0.alpha2"
+    VERSION = "2.0.0.alpha3"
 
     # @since 0.9.0
     # @api private

data/lib/hanami.rb

@@ -73,6 +73,10 @@ module Hanami
     end
   end
 
+  def self.shutdown
+    application.shutdown
+  end
+
   def self.bundler_groups
     [:plugins]
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha2
+  version: 2.0.0.alpha3
 platform: ruby
 authors:
 - Luca Guidi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-04 00:00:00.000000000 Z
+date: 2021-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,6 +30,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.1
 - !ruby/object:Gem::Dependency
   name: dry-core
   requirement: !ruby/object:Gem::Requirement
@@ -50,20 +70,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: dry-monitor
   requirement: !ruby/object:Gem::Requirement
@@ -87,7 +107,7 @@ dependencies:
         version: '0.19'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.21.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -97,7 +117,7 @@ dependencies:
         version: '0.19'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.21.0
 - !ruby/object:Gem::Dependency
   name: hanami-cli
   requirement: !ruby/object:Gem::Requirement
@@ -204,14 +224,13 @@ files:
 - lib/hanami/application/container/boot/rack_monitor.rb
 - lib/hanami/application/container/boot/settings.rb
 - lib/hanami/application/router.rb
+- lib/hanami/application/routes.rb
 - lib/hanami/application/routing/middleware/stack.rb
 - lib/hanami/application/routing/resolver.rb
 - lib/hanami/application/routing/resolver/node.rb
 - lib/hanami/application/routing/resolver/trie.rb
 - lib/hanami/application/settings.rb
-- lib/hanami/application/settings/definition.rb
-- lib/hanami/application/settings/loader.rb
-- lib/hanami/application/settings/struct.rb
+- lib/hanami/application/settings/dotenv_store.rb
 - lib/hanami/boot.rb
 - lib/hanami/cli/application/cli.rb
 - lib/hanami/cli/application/command.rb
@@ -222,7 +241,9 @@ files:
 - lib/hanami/cli/commands/command.rb
 - lib/hanami/cli/commands/server.rb
 - lib/hanami/configuration.rb
+- lib/hanami/configuration/logger.rb
 - lib/hanami/configuration/middleware.rb
+- lib/hanami/configuration/null_configuration.rb
 - lib/hanami/configuration/router.rb
 - lib/hanami/configuration/sessions.rb
 - lib/hanami/init.rb

data/lib/hanami/application/settings/definition.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/utils/basic_object"
-
-module Hanami
-  class Application
-    module Settings
-      # Application settings definition DSL
-      #
-      # @since 2.0.0
-      # @api private
-      class Definition < Hanami::Utils::BasicObject
-        attr_reader :settings
-
-        def initialize(&block)
-          @settings = []
-          instance_eval(&block) if block
-        end
-
-        def setting(name, *args)
-          @settings << [name, args]
-        end
-      end
-    end
-  end
-end