hanami 2.0.0.alpha7 → 2.0.0.beta1

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

@@ -1,50 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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

@@ -1,87 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# # frozen_string_literal: true
-
-# require "hanami/application/router"
-
-# Hanami.application.register_provider :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

@@ -1,60 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-# 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

data/lib/hanami/application/slice_registrar.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../constants"
-require_relative "../slice"
-
-module Hanami
-  class Application
-    # @api private
-    class SliceRegistrar
-      attr_reader :application, :slices
-      private :application, :slices
-
-      def initialize(application)
-        @application = application
-        @slices = {}
-      end
-
-      def register(name, slice_class = nil, &block)
-        if slices.key?(name.to_sym)
-          raise SliceLoadError, "Slice '#{name}' is already registered"
-        end
-
-        # TODO: raise error unless name meets format (i.e. single level depth only)
-
-        slices[name.to_sym] = slice_class || build_slice(name, &block)
-      end
-
-      def [](name)
-        slices.fetch(name) do
-          raise SliceLoadError, "Slice '#{name}' not found"
-        end
-      end
-
-      def freeze
-        slices.freeze
-        super
-      end
-
-      def load_slices
-        slice_configs = Dir[root.join(CONFIG_DIR, "slices", "*#{RB_EXT}")]
-          .map { |file| File.basename(file, RB_EXT) }
-
-        slice_dirs = Dir[File.join(root, SLICES_DIR, "*")]
-          .select { |path| File.directory?(path) }
-          .map { |path| File.basename(path) }
-
-        (slice_dirs + slice_configs).uniq.sort.each do |slice_name|
-          load_slice(slice_name)
-        end
-
-        self
-      end
-
-      def each(&block)
-        slices.each_value(&block)
-      end
-
-      def to_a
-        slices.values
-      end
-
-      private
-
-      # Attempts to load a slice class defined in `config/slices/[slice_name].rb`, then
-      # registers the slice with the matching class, if found.
-      def load_slice(slice_name)
-        slice_const_name = inflector.camelize(slice_name)
-        slice_require_path = root.join("config", "slices", slice_name).to_s
-
-        begin
-          require(slice_require_path)
-        rescue LoadError => e
-          raise e unless e.path == slice_require_path
-        end
-
-        slice_class =
-          begin
-            inflector.constantize("#{slice_const_name}::Slice")
-          rescue NameError => e
-            raise e unless e.name == :Slice
-          end
-
-        register(slice_name, slice_class)
-      end
-
-      def build_slice(slice_name, &block)
-        slice_module =
-          begin
-            slice_module_name = inflector.camelize(slice_name.to_s)
-            inflector.constantize(slice_module_name)
-          rescue NameError
-            Object.const_set(inflector.camelize(slice_module_name), Module.new)
-          end
-
-        slice_module.const_set(:Slice, Class.new(Hanami::Slice, &block))
-      end
-
-      def root
-        application.root
-      end
-
-      def inflector
-        application.inflector
-      end
-    end
-  end
-end