hanami 2.0.0.alpha1 → 2.0.0.alpha2

data/lib/hanami/cli/commands/command.rb

@@ -15,7 +15,7 @@ module Hanami
       # Abstract command
       #
       # @since 1.1.0
-      class Command < Hanami::CLI::Command
+      class Command < Dry::CLI::Command
         # @since 1.1.0
         # @api private
         def self.inherited(component)
@@ -72,9 +72,9 @@ module Hanami
           def call(**options)
             # FIXME: merge ENV vars (like HANAMI_ENV) into **options
             super(options)
-          rescue StandardError => e
-            warn e.message
-            warn e.backtrace.join("\n\t")
+          rescue StandardError => exception
+            warn exception.message
+            warn exception.backtrace.join("\n\t")
             exit(1)
           end
         end

data/lib/hanami/configuration.rb

@@ -4,6 +4,8 @@ require "uri"
 require "concurrent/hash"
 require "concurrent/array"
 require "dry/inflector"
+require "pathname"
+require "zeitwerk"
 
 module Hanami
   # Hanami application configuration
@@ -12,40 +14,72 @@ module Hanami
   #
   # rubocop:disable Metrics/ClassLength
   class Configuration
-    require "hanami/configuration/cookies"
-    require "hanami/configuration/sessions"
-    require "hanami/configuration/middleware"
-    require "hanami/configuration/security"
+    require_relative "configuration/middleware"
+    require_relative "configuration/router"
+    require_relative "configuration/sessions"
 
-    # rubocop:disable Metrics/MethodLength
+    attr_reader :actions
+    attr_reader :views
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def initialize(env:)
       @settings = Concurrent::Hash.new
 
+      self.autoloader = Zeitwerk::Loader.new
+
       self.env = env
       self.environments = DEFAULT_ENVIRONMENTS.clone
 
+      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.routes   = DEFAULT_ROUTES
-      self.cookies  = DEFAULT_COOKIES
+      self.rack_logger_filter_params = DEFAULT_RACK_LOGGER_FILTER_PARAMS.clone
       self.sessions = DEFAULT_SESSIONS
 
-      self.default_request_format  = DEFAULT_REQUEST_FORMAT
-      self.default_response_format = DEFAULT_RESPONSE_FORMAT
-
+      self.router     = Router.new(base_url)
       self.middleware = Middleware.new
-      self.security   = Security.new
 
       self.inflections = Dry::Inflector.new
+
+      @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
+      end
+
+      @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
+      end
     end
-    # rubocop:enable Metrics/MethodLength
+    # 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
 
@@ -53,6 +87,14 @@ module Hanami
       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
@@ -61,6 +103,65 @@ module Hanami
       settings.fetch(:env)
     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 slices_namespace
+      settings.fetch(:slices_namespace) { Object }
+    end
+
+    def slice(slice_name, &block)
+      settings[:slices][slice_name] = block
+    end
+
+    def slices
+      settings[:slices]
+    end
+
+    def settings_path=(value)
+      settings[:settings_path] = value
+    end
+
+    def settings_path
+      settings.fetch(:settings_path)
+    end
+
+    def settings_loader=(loader)
+      settings[:settings_loader] = loader
+    end
+
+    def settings_loader
+      settings.fetch(:settings_loader) {
+        require "hanami/application/settings/loader"
+        settings[:settings_loader] = Application::Settings::Loader
+      }
+    end
+
+    def settings_loader_options=(options)
+      settings[:settings_loader_options] = options
+    end
+
+    def settings_loader_options
+      settings[:settings_loader_options]
+    end
+
     def base_url=(value)
       settings[:base_url] = URI.parse(value)
     end
@@ -77,20 +178,20 @@ module Hanami
       settings.fetch(:logger)
     end
 
-    def routes=(value)
-      settings[:routes] = value
+    def rack_logger_filter_params=(params)
+      settings[:rack_logger_filter_params] = params
     end
 
-    def routes
-      settings.fetch(:routes)
+    def rack_logger_filter_params
+      settings[:rack_logger_filter_params]
     end
 
-    def cookies=(options)
-      settings[:cookies] = Cookies.new(options)
+    def router=(value)
+      settings[:router] = value
     end
 
-    def cookies
-      settings.fetch(:cookies)
+    def router
+      settings.fetch(:router)
     end
 
     def sessions=(*args)
@@ -101,34 +202,10 @@ module Hanami
       settings.fetch(:sessions)
     end
 
-    def default_request_format=(value)
-      settings[:default_request_format] = value
-    end
-
-    def default_request_format
-      settings.fetch(:default_request_format)
-    end
-
-    def default_response_format=(value)
-      settings[:default_response_format] = value
-    end
-
-    def default_response_format
-      settings.fetch(:default_response_format)
-    end
-
     def middleware
       settings.fetch(:middleware)
     end
 
-    def security=(value)
-      settings[:security] = value
-    end
-
-    def security
-      settings.fetch(:security)
-    end
-
     def inflections(&blk)
       if blk.nil?
         settings.fetch(:inflections)
@@ -137,16 +214,7 @@ module Hanami
       end
     end
 
-    def router_settings
-      bu = base_url
-
-      {
-        scheme: bu.scheme,
-        host: bu.host,
-        port: bu.port,
-        inflector: inflections
-      }
-    end
+    alias inflector inflections
 
     def for_each_middleware(&blk)
       stack = middleware.stack.dup
@@ -178,27 +246,24 @@ module Hanami
     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_ROUTES = File.join("config", "routes")
-    private_constant :DEFAULT_ROUTES
+    DEFAULT_RACK_LOGGER_FILTER_PARAMS = %w[_csrf password password_confirmation].freeze
+    private_constant :DEFAULT_RACK_LOGGER_FILTER_PARAMS
 
-    DEFAULT_COOKIES = Cookies.null
-    private_constant :DEFAULT_COOKIES
+    DEFAULT_SETTINGS_PATH = File.join("config", "settings")
+    private_constant :DEFAULT_SETTINGS_PATH
 
     DEFAULT_SESSIONS = Sessions.null
     private_constant :DEFAULT_SESSIONS
 
-    DEFAULT_REQUEST_FORMAT = :html
-    private_constant :DEFAULT_REQUEST_FORMAT
-
-    DEFAULT_RESPONSE_FORMAT = :html
-    private_constant :DEFAULT_RESPONSE_FORMAT
-
     attr_reader :settings
   end
   # rubocop:enable Metrics/ClassLength

data/lib/hanami/configuration/middleware.rb

@@ -10,8 +10,8 @@ module Hanami
         @stack = []
       end
 
-      def use(middleware, *args)
-        stack.push([middleware, *args])
+      def use(middleware, *args, &block)
+        stack.push([middleware, *args, block].compact)
       end
 
       attr_reader :stack

data/lib/hanami/configuration/router.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Configuration
+    # Hanami router configuration
+    #
+    # @since 2.0.0
+    # @api private
+    class Router
+      # @api private
+      # @since 2.0.0
+      attr_writer :routes
+
+      # @api private
+      # @since 2.0.0
+      attr_reader :routes
+
+      # @api private
+      # @since 2.0.0
+      attr_writer :resolver
+
+      # @api private
+      # @since 2.0.0
+      def initialize(base_url, routes: DEFAULT_ROUTES)
+        @base_url = base_url
+        @routes = routes
+      end
+
+      # @api private
+      # @since 2.0.0
+      def resolver
+        @resolver ||= begin
+                        require_relative "../application/routing/resolver"
+                        Application::Routing::Resolver
+                      end
+      end
+
+      # @api private
+      # @since 2.0.0
+      def options
+        { base_url: @base_url }
+      end
+
+      # @api private
+      # @since 2.0.0
+      DEFAULT_ROUTES = File.join("config", "routes")
+      private_constant :DEFAULT_ROUTES
+    end
+  end
+end

data/lib/hanami/init.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "setup"
+
+Hanami.init

data/lib/hanami/setup.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "hanami"
+
+begin
+  require File.join(Dir.pwd, "config/application")
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end

data/lib/hanami/slice.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "dry/system/container"
+require "pathname"
+
+module Hanami
+  # Distinct area of concern within an Hanami application
+  #
+  # @since 2.0.0
+  class Slice
+    attr_reader :application, :name, :namespace, :root
+
+    def initialize(application, name:, namespace: nil, root: nil, container: nil)
+      @application = application
+      @name = name.to_sym
+      @namespace = namespace
+      @root = root ? Pathname(root) : root
+      @container = container || define_container
+    end
+
+    def inflector
+      application.inflector
+    end
+
+    def namespace_path
+      @namespace_path ||= inflector.underscore(namespace.to_s)
+    end
+
+    def init
+      container.import application: application.container
+
+      slice_block = application.configuration.slices[name]
+      instance_eval(&slice_block) if slice_block
+    end
+
+    def boot
+      container.finalize! do
+        container.config.env = application.container.config.env
+      end
+
+      @booted = true
+      self
+    end
+
+    # rubocop:disable Style/DoubleNegation
+    def booted?
+      !!@booted
+    end
+    # rubocop:enable Style/DoubleNegation
+
+    def container
+      @container ||= define_container
+    end
+
+    def import(*slice_names)
+      raise "Cannot import after booting" if booted?
+
+      slice_names.each do |slice_name|
+        container.import slice_name.to_sym => application.slices.fetch(slice_name.to_sym).container
+      end
+    end
+
+    def register(*args, &block)
+      container.register(*args, &block)
+    end
+
+    def register_bootable(*args, &block)
+      container.boot(*args, &block)
+    end
+
+    def init_bootable(*args)
+      container.init(*args)
+    end
+
+    def start_bootable(*args)
+      container.start(*args)
+    end
+
+    def key?(*args)
+      container.key?(*args)
+    end
+
+    def keys
+      container.keys
+    end
+
+    def [](*args)
+      container[*args]
+    end
+
+    def resolve(*args)
+      container.resolve(*args)
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def define_container
+      container = Class.new(Dry::System::Container)
+      container.use :env
+
+      container.configure do |config|
+        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
+
+        if root&.directory?
+          config.root = root
+          config.bootable_dirs = ["config/boot"]
+
+          if root.join("lib").directory?
+            config.component_dirs.add "lib" do |dir|
+              dir.default_namespace = namespace_path.tr(File::SEPARATOR, config.namespace_separator)
+            end
+
+            application.configuration.autoloader&.push_dir(root.join("lib"))
+          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
+      end
+
+      container
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+  end
+end