hanami 1.3.1 → 2.0.0.alpha2

data/lib/hanami/application/autoloader/inflector_adapter.rb

@@ -0,0 +1,22 @@
+module Hanami
+  class Application
+    module Autoloader
+      # Allows the Hanami standard inflector (from dry-inflector) to be used with Zeitwerk
+      class InflectorAdapter
+        def initialize(inflector)
+          @inflector = inflector
+        end
+
+        def camelize(basename, _abspath)
+          # Discard unused `_abspath` argument before calling our own inflector's
+          # `#camelize` (which takes only one argument)
+          inflector.camelize(basename)
+        end
+
+        private
+
+        attr_reader :inflector
+      end
+    end
+  end
+end

data/lib/hanami/application/container/boot/inflector.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :inflector do
+  start do
+    register :inflector, Hanami.application.inflector
+  end
+end

data/lib/hanami/application/container/boot/logger.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :logger do
+  start do
+    require "hanami/logger"
+    register :logger, Hanami::Logger.new(**Hanami.application.configuration.logger)
+  end
+end

data/lib/hanami/application/container/boot/rack_logger.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :rack_logger do |container|
+  start do
+    require "hanami/web/rack_logger"
+
+    use :logger
+    use :rack_monitor
+
+    rack_logger = Hanami::Web::RackLogger.new(
+      container[:logger],
+      filter_params: Hanami.application.configuration.rack_logger_filter_params
+    )
+
+    rack_logger.attach container[:rack_monitor]
+
+    register :rack_logger, rack_logger
+  end
+end

data/lib/hanami/application/container/boot/rack_monitor.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :rack_monitor do |container|
+  start do
+    require "dry/monitor"
+    require "dry/monitor/rack/middleware"
+
+    middleware = Dry::Monitor::Rack::Middleware.new(container[:notifications])
+
+    register :rack_monitor, middleware
+  end
+end

data/lib/hanami/application/container/boot/settings.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Hanami.application.register_bootable :settings do
+  start do
+    register :settings, Hanami.application.settings
+  end
+end

data/lib/hanami/application/router.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "hanami/router"
+require "hanami/application/routing/middleware/stack"
+
+module Hanami
+  class Application
+    # Hanami application router
+    # @since 2.0.0
+    class Router < ::Hanami::Router
+      # @since 2.0.0
+      # @api private
+      def initialize(routes:, stack: Routing::Middleware::Stack.new, **kwargs, &blk)
+        @stack = stack
+        instance_eval(&blk)
+        super(**kwargs, &routes)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def freeze
+        return self if frozen?
+
+        remove_instance_variable(:@stack)
+        super
+      end
+
+      # @since 2.0.0
+      # @api private
+      def use(middleware, *args, &blk)
+        @stack.use(middleware, *args, &blk)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def scope(*args, &blk)
+        @stack.with(args.first) do
+          super
+        end
+      end
+
+      # @since 2.0.0
+      def slice(name, at:, &blk)
+        path = prefixed_path(at)
+        @resolver.register_slice_at_path(name, path)
+
+        scope(path, &blk)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def to_rack_app
+        return self if @stack.empty?
+
+        @stack.to_rack_app(self)
+      end
+    end
+  end
+end

data/lib/hanami/application/routing/middleware/stack.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "rack/builder"
+
+module Hanami
+  class Application
+    module Routing
+      # Hanami::Applicatione::Router middleware stack
+      #
+      # @since 2.0.0
+      # @api private
+      module Middleware
+        # Middleware stack
+        #
+        # @since 2.0.0
+        # @api private
+        class Stack
+          # @since 2.0.0
+          # @api private
+          ROOT_PREFIX = "/"
+          private_constant :ROOT_PREFIX
+
+          # @since 2.0.0
+          # @api private
+          def initialize
+            @prefix = ROOT_PREFIX
+            @stack = Hash.new { |hash, key| hash[key] = [] }
+          end
+
+          # @since 2.0.0
+          # @api private
+          def use(middleware, *args, &blk)
+            @stack[@prefix].push([middleware, args, blk])
+          end
+
+          # @since 2.0.0
+          # @api private
+          def with(path)
+            prefix = @prefix
+            @prefix = path
+            yield
+          ensure
+            @prefix = prefix
+          end
+
+          # @since 2.0.0
+          # @api private
+          def to_rack_app(app) # rubocop:disable Metrics/MethodLength
+            s = self
+
+            Rack::Builder.new do
+              s.each do |prefix, stack|
+                s.mapped(self, prefix) do
+                  stack.each do |middleware, args, blk|
+                    use(middleware, *args, &blk)
+                  end
+                end
+
+                run app
+              end
+            end.to_app
+          end
+
+          # @since 2.0.0
+          # @api private
+          def empty?
+            @stack.empty?
+          end
+
+          # @since 2.0.0
+          # @api private
+          def each(&blk)
+            @stack.each(&blk)
+          end
+
+          # @since 2.0.0
+          # @api private
+          def mapped(builder, prefix, &blk)
+            if prefix == ROOT_PREFIX
+              builder.instance_eval(&blk)
+            else
+              builder.map(prefix, &blk)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/routing/resolver.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    module Routing
+      # Hanami application router endpoint resolver
+      #
+      # @since 2.0.0
+      class Resolver
+        require_relative "resolver/trie"
+
+        # @since 2.0.0
+        class NotCallableEndpointError < StandardError
+          def initialize(endpoint)
+            super("#{endpoint.inspect} is not compatible with Rack. Please make sure it implements #call.")
+          end
+        end
+
+        # @api private
+        # @since 2.0.0
+        def initialize(slices:, inflector:)
+          @slices = slices
+          @inflector = inflector
+          @slices_registry = Trie.new
+        end
+
+        # @api private
+        # @since 2.0.0
+        #
+        # rubocop:disable Metrics/MethodLength
+        def call(path, identifier)
+          endpoint =
+            case identifier
+            when String
+              resolve_string_identifier(path, identifier)
+            when Class
+              identifier.respond_to?(:call) ? identifier : identifier.new
+            else
+              identifier
+            end
+
+          unless endpoint.respond_to?(:call) # rubocop:disable Style/IfUnlessModifier
+            raise NotCallableEndpointError.new(endpoint)
+          end
+
+          endpoint
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # @api private
+        # @since 2.0.0
+        def register_slice_at_path(name, path)
+          slices_registry.add(path, name)
+        end
+
+        private
+
+        # @api private
+        # @since 2.0.0
+        attr_reader :slices
+
+        # @api private
+        # @since 2.0.0
+        attr_reader :inflector
+
+        # @api private
+        # @since 2.0.0
+        attr_reader :slices_registry
+
+        # @api private
+        # @since 2.0.0
+        def resolve_string_identifier(path, identifier)
+          slice_name = slices_registry.find(path) or raise "missing slice for #{path.inspect} (#{identifier.inspect})"
+          slice = slices[slice_name]
+          action_key = "actions.#{identifier.gsub(/[#\/]/, '.')}"
+
+          slice[action_key]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/routing/resolver/node.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    module Routing
+      class Resolver
+        # Endpoint resolver node to register slices in a tree
+        #
+        # @api private
+        # @since 2.0.0
+        class Node
+          # @api private
+          # @since 2.0.0
+          attr_reader :slice
+
+          # @api private
+          # @since 2.0.0
+          def initialize
+            @slice = nil
+            @children = {}
+          end
+
+          # @api private
+          # @since 2.0.0
+          def put(segment)
+            @children[segment] ||= self.class.new
+          end
+
+          # @api private
+          # @since 2.0.0
+          def get(segment)
+            @children.fetch(segment) { self if leaf? }
+          end
+
+          # @api private
+          # @since 2.0.0
+          def leaf!(slice)
+            @slice = slice
+          end
+
+          # @api private
+          # @since 2.0.0
+          def leaf?
+            @slice
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/routing/resolver/trie.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "hanami/application/routing/resolver/node"
+
+module Hanami
+  class Application
+    module Routing
+      class Resolver
+        # Endpoint resolver trie to register slices
+        #
+        # @api private
+        # @since 2.0.0
+        class Trie
+          # @api private
+          # @since 2.0.0
+          def initialize
+            @root = Node.new
+          end
+
+          # @api private
+          # @since 2.0.0
+          def add(path, name)
+            node = @root
+            for_each_segment(path) do |segment|
+              node = node.put(segment)
+            end
+
+            node.leaf!(name)
+          end
+
+          # @api private
+          # @since 2.0.0
+          def find(path)
+            node = @root
+
+            for_each_segment(path) do |segment|
+              break unless node
+
+              node = node.get(segment)
+            end
+
+            return node.slice if node&.leaf?
+
+            nil
+          end
+
+          private
+
+          # @api private
+          # @since 2.0.0
+          def for_each_segment(path, &blk)
+            _, *segments = path.split(/\//)
+            segments.each(&blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/settings.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+require_relative "settings/definition"
+require_relative "settings/struct"
+
+module Hanami
+  class Application
+    # Application settings
+    #
+    # @since 2.0.0
+    module Settings
+      Undefined = Dry::Core::Constants::Undefined
+
+      def self.build(loader, loader_options, &definition_block)
+        definition = Definition.new(&definition_block)
+        settings = loader.new(**loader_options).call(definition.settings)
+
+        Struct[settings.keys].new(settings)
+      end
+    end
+  end
+end