hanami 1.3.1 → 2.0.0.alpha2

data/lib/hanami/configuration/middleware.rb

@@ -1,40 +1,20 @@
-require "concurrent"
+# frozen_string_literal: true
 
 module Hanami
-  # @api private
   class Configuration
-    # Middleware configuration
-    # @since 1.2.0
+    # Hanami application configured Rack middleware
+    #
+    # @since 2.0.0
     class Middleware
-      # @api private
-      # @since 1.2.0
       def initialize
-        @middleware = Concurrent::Array.new
+        @stack = []
       end
 
-      # Use a Rack middleware
-      #
-      # @param middleware [#call] a Rack middleware
-      # @param args [Array<Object>] an optional set of options
-      # @param blk [Proc] an optional block to pass to the middleware
-      #
-      # @since 1.2.0
-      #
-      # @example
-      #   # config/environment.rb
-      #   # ...
-      #   Hanami.configure do
-      #     middleware.use MyRackMiddleware
-      #   end
-      def use(middleware, *args, &blk)
-        @middleware.push([middleware, args, blk])
+      def use(middleware, *args, &block)
+        stack.push([middleware, *args, block].compact)
       end
 
-      # @api private
-      # @since 1.2.0
-      def each(&blk)
-        @middleware.each(&blk)
-      end
+      attr_reader :stack
     end
   end
 end

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/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
+      def self.null
+        NULL_STORAGE
+      end
+
+      attr_reader :storage, :options
+
+      def initialize(*args)
+        storage, options, = Array(args.dup).flatten
+
+        @storage = storage
+        @options = options || {}
+      end
+
+      def enabled?
+        storage != NULL_STORAGE
+      end
+
+      def middleware
+        [[storage_middleware, options]]
+      end
+
+      private
+
+      NULL_STORAGE = :null
+      private_constant :NULL_STORAGE
+
+      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/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,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

data/lib/hanami/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hanami
   # Hanami version
   #
@@ -6,7 +8,7 @@ module Hanami
   module Version
     # @since 0.9.0
     # @api private
-    VERSION = '1.3.1'.freeze
+    VERSION = "2.0.0.alpha2"
 
     # @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