hanami 2.0.0.alpha1 → 2.0.0.alpha5

data/lib/hanami/configuration.rb

@@ -3,7 +3,16 @@
 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"
+require_relative "configuration/source_dirs"
 
 module Hanami
   # Hanami application configuration
@@ -12,142 +21,149 @@ module Hanami
   #
   # rubocop:disable Metrics/ClassLength
   class Configuration
-    require "hanami/configuration/cookies"
-    require "hanami/configuration/sessions"
-    require "hanami/configuration/middleware"
-    require "hanami/configuration/security"
+    include Dry::Configurable
+
+    DEFAULT_ENVIRONMENTS = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
+    private_constant :DEFAULT_ENVIRONMENTS
 
-    # rubocop:disable Metrics/MethodLength
-    def initialize(env:)
-      @settings = Concurrent::Hash.new
+    MODULE_DELIMITER = "::"
+    private_constant :MODULE_DELIMITER
 
-      self.env = env
-      self.environments = DEFAULT_ENVIRONMENTS.clone
+    attr_reader :actions
+    attr_reader :middleware
+    attr_reader :router
+    attr_reader :views, :assets
 
-      self.base_url = DEFAULT_BASE_URL
+    attr_reader :environments
+    private :environments
 
-      self.logger   = DEFAULT_LOGGER.clone
-      self.routes   = DEFAULT_ROUTES
-      self.cookies  = DEFAULT_COOKIES
-      self.sessions = DEFAULT_SESSIONS
+    def initialize(application_name:, env:)
+      @namespace = application_name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER)
 
-      self.default_request_format  = DEFAULT_REQUEST_FORMAT
-      self.default_response_format = DEFAULT_RESPONSE_FORMAT
+      @environments = DEFAULT_ENVIRONMENTS.clone
+      config.env = env
 
-      self.middleware = Middleware.new
-      self.security   = Security.new
+      # 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
 
-      self.inflections = Dry::Inflector.new
-    end
-    # rubocop:enable Metrics/MethodLength
+      config.logger = Configuration::Logger.new(env: env, application_name: method(:application_name))
 
-    def finalize
-      environment_for(env).each do |blk|
-        instance_eval(&blk)
+      @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
 
-      self
-    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
 
-    def environment(name, &blk)
-      environment_for(name).push(blk)
-    end
+      @middleware = Middleware.new
 
-    def env=(value)
-      settings[:env] = value
-    end
+      @router = Router.new(self)
 
-    def env
-      settings.fetch(:env)
-    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
+        require_relative "configuration/null_configuration"
+        NullConfiguration.new
+      end
 
-    def base_url=(value)
-      settings[:base_url] = URI.parse(value)
+      yield self if block_given?
     end
 
-    def base_url
-      settings.fetch(:base_url)
-    end
+    def environment(env_name, &block)
+      environments[env_name] << block
+      apply_env_config
 
-    def logger=(options)
-      settings[:logger] = options
+      self
     end
 
-    def logger
-      settings.fetch(:logger)
-    end
+    def finalize!
+      apply_env_config
 
-    def routes=(value)
-      settings[:routes] = value
-    end
+      # Finalize nested configurations
+      assets.finalize!
+      actions.finalize!
+      views.finalize!
+      logger.finalize!
+      router.finalize!
 
-    def routes
-      settings.fetch(:routes)
+      super
     end
 
-    def cookies=(options)
-      settings[:cookies] = Cookies.new(options)
+    def namespace
+      inflector.constantize(@namespace)
     end
 
-    def cookies
-      settings.fetch(:cookies)
+    def application_name
+      inflector.underscore(@namespace).to_sym
     end
 
-    def sessions=(*args)
-      settings[:sessions] = Sessions.new(args)
-    end
+    setting :env
 
-    def sessions
-      settings.fetch(:sessions)
+    def env=(new_env)
+      config.env = env
+      apply_env_config(new_env)
     end
 
-    def default_request_format=(value)
-      settings[:default_request_format] = value
-    end
+    setting :root, constructor: -> path { Pathname(path) }
 
-    def default_request_format
-      settings.fetch(:default_request_format)
-    end
+    setting :inflector, default: Dry::Inflector.new, cloneable: true
 
-    def default_response_format=(value)
-      settings[:default_response_format] = value
+    def inflections(&block)
+      self.inflector = Dry::Inflector.new(&block)
     end
 
-    def default_response_format
-      settings.fetch(:default_response_format)
-    end
+    setting :logger, cloneable: true
 
-    def middleware
-      settings.fetch(:middleware)
+    def logger=(logger_instance)
+      @logger_instance = logger_instance
     end
 
-    def security=(value)
-      settings[:security] = value
+    def logger_instance
+      @logger_instance || logger.instance
     end
 
-    def security
-      settings.fetch(:security)
-    end
+    setting :settings_path, default: File.join("config", "settings")
 
-    def inflections(&blk)
-      if blk.nil?
-        settings.fetch(:inflections)
-      else
-        settings[:inflections] = Dry::Inflector.new(&blk)
-      end
-    end
+    setting :settings_class_name, default: "Settings"
 
-    def router_settings
-      bu = base_url
+    setting :settings_store, default: Application::Settings::DotenvStore
 
-      {
-        scheme: bu.scheme,
-        host: bu.host,
-        port: bu.port,
-        inflector: inflections
-      }
+    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)
       stack = middleware.stack.dup
       stack += sessions.middleware if sessions.enabled?
@@ -155,51 +171,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_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_COOKIES = Cookies.null
-    private_constant :DEFAULT_COOKIES
-
-    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
 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,189 @@
+# 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 component dirs for each configured component path
+          application.configuration.source_dirs.component_dirs.each do |component_dir|
+            next unless root.join(component_dir.path).directory?
+
+            component_dir = component_dir.dup
+
+            # 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, to be registered as
+              # "foo"
+              component_dir.namespaces.delete_root
+              component_dir.namespaces.add_root(key: nil, const: namespace_path)
+
+              config.component_dirs.add(component_dir)
+
+              application.autoloader.push_dir(root.join("lib"), namespace: namespace)
+            else
+              # Expect component files in the root of non-lib/ component dirs to define
+              # classes inside a namespace matching that dir.
+              #
+              # e.g. "actions/foo.rb" should define SliceNamespace::Actions::Foo, to be
+              # registered as "actions.foo"
+
+              dir_namespace_path = File.join(namespace_path, component_dir.path)
+
+              autoloader_namespace = begin
+                inflector.constantize(inflector.camelize(dir_namespace_path))
+              rescue NameError
+                namespace.const_set(inflector.camelize(component_dir.path), Module.new)
+              end
+
+              component_dir.namespaces.delete_root
+              component_dir.namespaces.add_root(const: dir_namespace_path, key: component_dir.path) # TODO: do we need to swap path delimiters for key delimiters here?
+
+              config.component_dirs.add(component_dir)
+
+              application.autoloader.push_dir(
+                container.root.join(component_dir.path),
+                namespace: autoloader_namespace
+              )
+            end
+          end
+
+          # Pass configured autoload dirs to the autoloader
+          application.configuration.source_dirs.autoload_paths.each do |autoload_path|
+            next unless root.join(autoload_path).directory?
+
+            dir_namespace_path = File.join(namespace_path, autoload_path)
+
+            autoloader_namespace = begin
+              inflector.constantize(inflector.camelize(dir_namespace_path))
+            rescue NameError
+              namespace.const_set(inflector.camelize(autoload_path), Module.new)
+            end
+
+            application.autoloader.push_dir(
+              container.root.join(autoload_path),
+              namespace: autoloader_namespace
+            )
+          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

data/lib/hanami/version.rb

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

data/lib/hanami/web/rack_logger.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "json"
+require "rack/request"
+require "hanami/utils/hash"
+
+module Hanami
+  module Web
+    # Rack logger for Hanami applications
+    class RackLogger
+      attr_reader :logger
+      attr_reader :filter_params
+
+      def initialize(logger, filter_params: [])
+        @logger = logger
+        @filter_params = filter_params
+      end
+
+      def attach(rack_monitor)
+        rack_monitor.on :stop do |event|
+          log_request event[:env], event[:status], event[:time]
+        end
+
+        rack_monitor.on :error do |event|
+          log_exception event[:exception]
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def log_request(env, status, time)
+        data = {
+          http: env[HTTP_VERSION],
+          verb: env[REQUEST_METHOD],
+          status: status,
+          ip: env[HTTP_X_FORWARDED_FOR] || env[REMOTE_ADDR],
+          path: env[SCRIPT_NAME] + env[PATH_INFO].to_s,
+          length: extract_content_length(env),
+          params: extract_params(env),
+          elapsed: time,
+        }
+
+        logger.info JSON.generate(data)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def log_exception(exception)
+        logger.error exception.message
+        logger.error exception.backtrace.join("\n")
+      end
+
+      private
+
+      HTTP_VERSION = "HTTP_VERSION"
+      REQUEST_METHOD = "REQUEST_METHOD"
+      HTTP_X_FORWARDED_FOR = "HTTP_X_FORWARDED_FOR"
+      REMOTE_ADDR = "REMOTE_ADDR"
+      SCRIPT_NAME = "SCRIPT_NAME"
+      PATH_INFO = "PATH_INFO"
+      RACK_ERRORS = "rack.errors"
+      QUERY_HASH = "rack.request.query_hash"
+      FORM_HASH = "rack.request.form_hash"
+      ROUTER_PARAMS = "router.params"
+      CONTENT_LENGTH = "Content-Length"
+
+      def extract_content_length(env)
+        value = env[CONTENT_LENGTH]
+        !value || value.to_s == "0" ? "-" : value
+      end
+
+      def extract_params(env)
+        result = env.fetch(QUERY_HASH, {})
+        result.merge!(env.fetch(FORM_HASH, {}))
+        result.merge!(Hanami::Utils::Hash.deep_stringify(env.fetch(ROUTER_PARAMS, {})))
+        result
+      end
+
+      FILTERED = "[FILTERED]"
+
+      # rubocop:disable Metrics/MethodLength
+      def filter(params)
+        params.each_with_object({}) do |(k, v), h|
+          if filter_params.include?(k)
+            h.update(k => FILTERED)
+          elsif v.is_a?(Hash)
+            h.update(k => filter(v))
+          elsif v.is_a?(Array)
+            h.update(k => v.map { |m| m.is_a?(Hash) ? filter(m) : m })
+          else
+            h[k] = v
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end