hanami 1.3.5 → 2.0.0.alpha4

data/lib/hanami/configuration/sessions.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "hanami/utils/string"
+require "hanami/utils/class"
+
+module Hanami
+  class Configuration
+    # Hanami configuration for HTTP sessions
+    #
+    # @since 2.0.0
+    class Sessions
+      NULL_SESSION_OPTION = :null
+      private_constant :NULL_SESSION_OPTION
+
+      def self.null
+        self.class.new(NULL_SESSION_OPTION)
+      end
+
+      attr_reader :storage, :options
+
+      def initialize(*args)
+        storage, options, = Array(args.dup).flatten
+
+        @storage = storage
+        @options = options || {}
+      end
+
+      def enabled?
+        storage != NULL_SESSION_OPTION
+      end
+
+      def middleware
+        [[storage_middleware, options]]
+      end
+
+      private
+
+      def storage_middleware
+        require_storage
+
+        name = Utils::String.classify(storage)
+        Utils::Class.load!(name, Rack::Session)
+      end
+
+      def require_storage
+        require "rack/session/#{storage}"
+      end
+    end
+  end
+end

data/lib/hanami/configuration.rb

@@ -1,215 +1,182 @@
-require 'concurrent'
-require 'hanami/application'
-require 'hanami/utils/class'
-require 'hanami/utils/string'
+# frozen_string_literal: true
+
+require "uri"
+require "concurrent/hash"
+require "concurrent/array"
+require "dry/configurable"
+require "dry/inflector"
+require "pathname"
+
+require_relative "application/settings/dotenv_store"
+require_relative "configuration/logger"
+require_relative "configuration/middleware"
+require_relative "configuration/router"
+require_relative "configuration/sessions"
 
 module Hanami
-  # @api private
+  # Hanami application configuration
+  #
+  # @since 2.0.0
+  #
+  # rubocop:disable Metrics/ClassLength
   class Configuration
-    require "hanami/configuration/app"
-    require "hanami/configuration/middleware"
+    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, :assets
+
+    attr_reader :environments
+    private :environments
+
+    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.settings_store = Application::Settings::DotenvStore.new.with_dotenv_loaded
+
+      @assets = begin
+        require_path = "hanami/assets/application_configuration"
+        require require_path
+        Hanami::Assets::ApplicationConfiguration.new
+      rescue LoadError => e
+        raise e unless e.path == require_path
+        require_relative "configuration/null_configuration"
+        NullConfiguration.new
+      end
+
+      # 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(assets_server_url: assets.server_url)
+      rescue LoadError => e
+        raise e unless e.path == require_path
+        require_relative "configuration/null_configuration"
+        NullConfiguration.new
+      end
 
-    # @api private
-    def initialize(&blk)
-      @settings = Concurrent::Map.new
-      instance_eval(&blk)
+      @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
+        require_relative "configuration/null_configuration"
+        NullConfiguration.new
+      end
+
+      yield self if block_given?
     end
 
-    # Mount a Hanami::Application or a Rack app
-    #
-    # @param app [#call] an application compatible with Rack SPEC
-    # @param options [Hash] a set of options
-    # @option :at [String] options the mount point
-    # @option :host [String] options the mount point
-    #
-    # @since 0.9.0
-    #
-    # @example
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     mount Beta::Application, at: '/', host: 'beta.bookshelf.com'
-    #     mount Admin::Application, at: '/api'
-    #     mount Web::Application, at: '/'
-    #
-    #     # ...
-    #   end
-    def mount(app, options)
-      mounted[app] = App.new(app, options)
+    def environment(env_name, &block)
+      environments[env_name] << block
+      apply_env_config
+
+      self
     end
 
-    # Configure database
-    #
-    # @param blk [Proc] the database configuration
-    #
-    # @see Hanami::Model.configure
-    #
-    # @example
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     model do
-    #       adapter :sql, ENV['DATABASE_URL']
-    #
-    #       migrations 'db/migrations'
-    #       schema     'db/schema.sql'
-    #     end
-    #
-    #     # ...
-    #   end
-    def model(&blk)
-      if block_given?
-        settings.put_if_absent(:model, blk)
-      else
-        settings.fetch(:model)
-      end
+    def finalize!
+      apply_env_config
+
+      # Finalize nested configurations
+      assets.finalize!
+      actions.finalize!
+      views.finalize!
+      logger.finalize!
+      router.finalize!
+
+      super
     end
 
-    # Configure mailer
-    #
-    # @param blk [Proc] the mailer configuration
-    #
-    # @see Hanami::Mailer.configure
-    #
-    # @example
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     mailer do
-    #       root 'lib/bookshelf/mailers'
-    #
-    #       # See https://guides.hanamirb.org/mailers/delivery
-    #       delivery :test
-    #     end
-    #
-    #     # ...
-    #   end
-    def mailer(&blk)
-      mailer_settings.push(blk) if block_given?
+    setting :env
+
+    def env=(new_env)
+      config.env = env
+      apply_env_config(new_env)
     end
 
-    # @since next
-    # @api private
-    def mailer_settings
-      settings.fetch_or_store(:mailers, [])
+    setting :root, constructor: -> path { Pathname(path) }
+
+    setting :inflector, default: Dry::Inflector.new, cloneable: true
+
+    def inflections(&block)
+      self.inflector = Dry::Inflector.new(&block)
     end
 
-    # @since 0.9.0
-    # @api private
-    def mounted
-      settings.fetch_or_store(:mounted, {})
+    setting :logger, default: Configuration::Logger.new, cloneable: true
+
+    def logger=(logger_instance)
+      @logger_instance = logger_instance
     end
 
-    # @since 1.2.0
-    #
-    # @example
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     middleware.use MyRackMiddleware
-    #   end
-    def middleware
-      settings.fetch_or_store(:middleware, Configuration::Middleware.new)
+    def logger_instance
+      @logger_instance || logger.logger_class.new(**logger.options)
     end
 
-    # Setup Early Hints feature
-    #
-    # @since 1.2.0
-    #
-    # @example Enable for all the environments
-    #   # config/environment.rb
-    #   Hanami.configure do
-    #     early_hints true
-    #   end
-    #
-    # @example Enable only for production
-    #   # config/environment.rb
-    #   Hanami.configure do
-    #     environment :production do
-    #       early_hints true
-    #     end
-    #   end
-    def early_hints(value = nil)
-      if value.nil?
-        settings.fetch(:early_hints, false)
-      else
-        settings[:early_hints] = value
-      end
+    setting :settings_path, default: File.join("config", "settings")
+
+    setting :settings_class_name, default: "Settings"
+
+    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
+
+    # 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 slice(slice_name, &block)
+      slices[slice_name] = block
     end
 
-    # @since 0.9.0
-    # @api private
-    def apps
-      mounted.each_pair do |klass, app|
-        yield(app) if klass <= Hanami::Application
+    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
+
+    def apply_env_config(env = self.env)
+      environments[env].each do |block|
+        instance_eval(&block)
       end
     end
 
-    # Configure logger
-    #
-    # @since 1.0.0
-    #
-    # @param options [Array] a set of options
-    #
-    # @see Hanami.logger
-    # @see Hanami::Logger
-    #
-    # @see https://guides.hanamirb.org/projects/logging
-    #
-    # @example Basic Usage
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     # ...
-    #     environment :development do
-    #       logger level: :debug
-    #     end
-    #   end
-    #
-    # @example Daily Rotation
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     # ...
-    #     environment :development do
-    #       logger 'daily', level: :debug
-    #     end
-    #   end
-    def logger(*options)
-      if options.empty?
-        settings.fetch(:logger, nil)
+    def method_missing(name, *args, &block)
+      if config.respond_to?(name)
+        config.public_send(name, *args, &block)
       else
-        settings[:logger] = options
+        super
       end
     end
 
-    # Configure settings for the current environment
-    # @since 1.0.0
-    #
-    # @param name [Symbol] the name of the Hanami environment
-    #
-    # @see Hanami.env
-    #
-    # @example Configure Logging for Different Environments
-    #   # config/environment.rb
-    #   # ...
-    #   Hanami.configure do
-    #     # ...
-    #     environment :development do
-    #       logger level: :debug
-    #     end
-    #
-    #     environment :production do
-    #       logger level: :info, formatter: :json
-    #     end
-    #   end
-    def environment(name)
-      yield if ENV['HANAMI_ENV'] == name.to_s
+    def respond_to_missing?(name, _incude_all = false)
+      config.respond_to?(name) || super
     end
-
-    private
-
-    # @api private
-    attr_reader :settings
   end
 end

data/lib/hanami/init.rb

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

data/lib/hanami/server.rb

@@ -1,4 +1,7 @@
-require 'rack'
+# frozen_string_literal: true
+
+require "hanami"
+require "rack"
 
 module Hanami
   # Rack compatible server.
@@ -13,81 +16,14 @@ module Hanami
   # @since 0.8.0
   # @api private
   class Server < ::Rack::Server
-    # @api private
-    attr_reader :options
-
-    # @since 0.8.0
-    # @api private
-    #
-    # @see Hanami::Environment#initialize
-    def initialize
-      @options = _extract_options
-      setup
-    end
-
     # Primarily this removes the ::Rack::Chunked middleware
     # which is the cause of Safari content-length bugs.
     #
     # @since 0.8.0
     def middleware
-      mw = Hash.new { |e, m| e[m] = [] }
+      mw = ::Hash.new { |e, m| e[m] = [] }
       mw["development"].concat([::Rack::ShowExceptions, ::Rack::Lint])
-      require 'hanami/assets/static'
-      mw["development"].push(::Hanami::Assets::Static)
       mw
     end
-
-    # @api private
-    def start
-      preload
-      super
-    end
-
-    private
-
-    # @api private
-    def setup
-      return unless code_reloading?
-      @app = Shotgun::Loader.new(rackup)
-    end
-
-    # @api private
-    def environment
-      Components['environment']
-    end
-
-    # @since 0.8.0
-    # @api private
-    def code_reloading?
-      Hanami.code_reloading?
-    end
-
-    # @api private
-    def rackup
-      environment.rackup.to_s
-    end
-
-    # @api private
-    def preload
-      if code_reloading?
-        Shotgun.enable_copy_on_write
-        Shotgun.preload
-      else
-        Hanami.boot
-      end
-    end
-
-    # Options for Rack::Server superclass
-    #
-    # @since 0.8.0
-    # @api private
-    def _extract_options
-      environment.to_options.merge(
-        config:      rackup,
-        Host:        environment.host,
-        Port:        environment.port,
-        AccessLog:   []
-      )
-    end
   end
 end

data/lib/hanami/setup.rb

@@ -1,3 +1,9 @@
-require 'hanami'
+# frozen_string_literal: true
 
-::Bundler.require(*Hanami::Environment.new.bundler_groups)
+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,167 @@
+# frozen_string_literal: true
+
+require "dry/system/container"
+require "dry/system/loader/autoloading"
+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
+
+        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 |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)
+
+              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
+
+      if namespace
+        namespace.const_set :Container, container
+        namespace.const_set :Deps, container.injector
+      end
+
+      container
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+  end
+end