hanami 2.0.0.alpha1 → 2.0.0.alpha5

data/lib/hanami/application/routes.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    # Application routes
+    #
+    # Users are expected to inherit from this class to define their application
+    # routes.
+    #
+    # @example
+    #   # config/routes.rb
+    #   # frozen_string_literal: true
+    #
+    #   require "hanami/application/routes"
+    #
+    #   module MyApp
+    #     class Routes < Hanami::Application::Routes
+    #       define do
+    #         slice :main, at: "/" do
+    #           root to: "home.show"
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   See {Hanami::Application::Router} for the syntax allowed within the
+    #   `define` block.
+    #
+    # @see Hanami::Application::Router
+    # @since 2.0.0
+    class Routes
+      # Defines application routes
+      #
+      # @yield DSL syntax to define application routes executed in the context
+      # of {Hanami::Application::Router}
+      #
+      # @return [Proc]
+      def self.define(&block)
+        @_routes = block
+      end
+
+      # @api private
+      def self.routes
+        @_routes || raise(<<~MSG)
+          Routes need to be defined before being able to fetch them. E.g.,
+            define do
+              slice :main, at: "/" do
+                root to: "home.show"
+              end
+            end
+        MSG
+      end
+    end
+  end
+end

data/lib/hanami/application/routes_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    # Hanami application routes helpers
+    #
+    # An instance of this class gets registered in the container
+    # (`routes_helper` key) once the Hanami application is booted. You can use
+    # it to get the route helpers for your application.
+    #
+    # @example
+    #   MyApp::Application["routes_helper"].path(:root) # => "/"
+    #
+    # @see Hanami::Router::UrlHelpers
+    # @since 2.0.0
+    class RoutesHelper
+      # @since 2.0.0
+      # @api private
+      def initialize(router)
+        @router = router
+      end
+
+      # @see Hanami::Router::UrlHelpers#path
+      def path(*args, **kwargs, &block)
+        @router.path(*args, **kwargs, &block)
+      end
+
+      # @see Hanami::Router::UrlHelpers#url
+      def url(*args, **kwargs, &block)
+        @router.url(*args, **kwargs, &block)
+      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/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/routing/resolver.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Application
+    module Routing
+      # Hanami application router endpoint resolver
+      #
+      # @since 2.0.0
+      class Resolver
+        ENDPOINT_KEY_NAMESPACE = "actions"
+
+        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
+          @slice_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)
+          slice_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 :slice_registry
+
+        # @api private
+        # @since 2.0.0
+        def resolve_string_identifier(path, identifier)
+          slice_name = slice_registry.find(path) or raise "missing slice for #{path.inspect} (#{identifier.inspect})"
+          slice = slices[slice_name]
+          endpoint_key = "#{ENDPOINT_KEY_NAMESPACE}.#{identifier}"
+
+          # Lazily resolve endpoint from the slice to reduce router initialization time,
+          # and break potential endless loops from the resolved endpoint itself requiring
+          # access to router-related concerns
+          -> (*args) { slice[endpoint_key].call(*args) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# # frozen_string_literal: true
+
+# require "hanami/application/router"
+
+# Hanami.application.register_bootable :router do
+#   start do
+#     configuration = Hanami.application.configuration
+
+#     routes = begin
+#       require File.join(configuration.root, configuration.router.routes_path)
+#       routes_class = Hanami.application.send(:autodiscover_application_constant, configuration.router.routes_class_name) # WIP private
+#       routes_class.routes
+#     rescue LoadError
+#       proc {}
+#     end
+
+#     resolver = configuration.router.resolver.new(
+#       slices: Hanami.application.slices,
+#       inflector: Hanami.application.inflector # TODO: use container[:inflector]?
+#     )
+
+#     router = Hanami::Application::Router.new(
+#       routes: routes,
+#       resolver: resolver,
+#       **configuration.router.options,
+#     ) do
+#       use Hanami.application[:rack_monitor]
+
+#       Hanami.application.config.for_each_middleware do |m, *args, &block|
+#         use(m, *args, &block)
+#       end
+#     end
+
+#     register :router, router
+#   end
+# end

data/lib/hanami/application/settings/dotenv_store.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+module Hanami
+  class Application
+    class Settings
+      # Default application settings store.
+      #
+      # Uses [dotenv](https://github.com/bkeepers/dotenv) (if available) to load
+      # .env files and then loads settings from ENV. For a given `HANAMI_ENV`
+      # environment, the following `.env` files are looked up in the following order:
+      #
+      # - .env.{environment}.local
+      # - .env.local (except if the environment is `test`)
+      # - .env.{environment}
+      # - .env
+      #
+      # @since 2.0.0
+      # @api private
+      class DotenvStore
+        Undefined = Dry::Core::Constants::Undefined
+
+        attr_reader :store,
+                    :hanami_env
+
+        def initialize(store: ENV, hanami_env: Hanami.env)
+          @store = store
+          @hanami_env = hanami_env
+        end
+
+        def fetch(name, default_value = Undefined, &block)
+          name = name.to_s.upcase
+          args = (default_value == Undefined) ? [name] : [name, default_value]
+
+          store.fetch(*args, &block)
+        end
+
+        def with_dotenv_loaded
+          require "dotenv"
+          Dotenv.load(*dotenv_files) if defined?(Dotenv)
+          self
+        rescue LoadError
+          self
+        end
+
+        private
+
+        def dotenv_files
+          [
+            ".env.#{hanami_env}.local",
+            (".env.local" unless hanami_env == :test),
+            ".env.#{hanami_env}",
+            ".env"
+          ].compact
+        end
+      end
+    end
+  end
+end

data/lib/hanami/application/settings.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/core/constants"
+
+module Hanami
+  class Application
+    # Application settings
+    #
+    # Users are expected to inherit from this class to define their application
+    # settings.
+    #
+    # @example
+    #   # config/settings.rb
+    #   # frozen_string_literal: true
+    #
+    #   require "hanami/application/settings"
+    #   require "my_app/types"
+    #
+    #   module MyApp
+    #     class Settings < Hanami::Application::Settings
+    #       setting :database_url
+    #       setting :feature_flag, default: false, constructor: Types::Params::Bool
+    #     end
+    #   end
+    #
+    # Settings are defined with
+    # [dry-configurable](https://dry-rb.org/gems/dry-configurable/), so you can
+    # take a look there to see the supported syntax.
+    # 
+    # Users work with an instance of this class made available within the
+    # `settings` key in the container. The instance gets its settings populated
+    # from a configurable store, which defaults to
+    # {Hanami::Application::Settings::DotenvStore}.
+    #
+    # A different store can be set through the `settings_store` Hanami
+    # configuration option. All it needs to do is implementing a `#fetch` method
+    # with the same signature as `Hash#fetch`.
+    #
+    # @see Hanami::Application::Settings::DotenvStore
+    # @since 2.0.0
+    class Settings
+      # Exception for errors in the definition of settings.
+      #
+      # Its message collects all the individual errors that can be raised for
+      # each setting.
+      InvalidSettingsError = Class.new(StandardError) do
+        def initialize(errors)
+          @errors = errors
+        end
+
+        def to_s
+          <<~STR.strip
+              Could not initialize settings. The following settings were invalid:
+
+              #{@errors.map { |setting, message| "#{setting}: #{message}" }.join("\n")}
+          STR
+        end
+      end
+
+      # @api private
+      EMPTY_STORE = Dry::Core::Constants::EMPTY_HASH
+
+      include Dry::Configurable
+
+      # @api private
+      def initialize(store = EMPTY_STORE)
+        errors = config._settings.map(&:name).reduce({}) do |errs, name|
+          public_send("#{name}=", store.fetch(name) { Dry::Core::Constants::Undefined })
+          errs
+        rescue => e # rubocop:disable Style/RescueStandardError
+          errs.merge(name => e)
+        end
+
+        raise InvalidSettingsError, errors if errors.any?
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _include_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end