hanami 2.0.0.alpha8 → 2.0.0.beta1

data/lib/hanami/extensions.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+if Hanami.bundled?("hanami-controller")
+  require_relative "./extensions/action"
+end
+
+if Hanami.bundled?("hanami-view")
+  require_relative "./extensions/view"
+  require_relative "./extensions/view/context"
+end

data/lib/hanami/providers/inflector.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Inflector < Dry::System::Provider::Source
+      def start
+        register :inflector, Hanami.app.inflector
+      end
+    end
+  end
+end

data/lib/hanami/providers/logger.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Logger < Dry::System::Provider::Source
+      def start
+        register :logger, Hanami.app.configuration.logger_instance
+      end
+    end
+  end
+end

data/lib/hanami/providers/rack.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Rack < Dry::System::Provider::Source
+      def prepare
+        require "dry/monitor"
+        require "hanami/web/rack_logger"
+      end
+
+      def start
+        target.start :logger
+
+        notifications = target[:notifications]
+
+        monitor_middleware = Dry::Monitor::Rack::Middleware.new(notifications)
+
+        rack_logger = Hanami::Web::RackLogger.new(target[:logger])
+        rack_logger.attach(monitor_middleware)
+
+        register "monitor", monitor_middleware
+      end
+    end
+  end
+end

data/lib/hanami/providers/routes.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Routes < Dry::System::Provider::Source
+      def self.for_slice(slice)
+        Class.new(self) do |klass|
+          klass.instance_variable_set(:@slice, slice)
+        end
+      end
+
+      def self.slice
+        @slice || Hanami.app
+      end
+
+      def prepare
+        require "hanami/slice/routes_helper"
+      end
+
+      def start
+        # Register a lazy instance of RoutesHelper to ensure we don't load prematurely
+        # load the router during the process of booting. This ensures the router's
+        # resolver can run strict action key checks once when it runs on a fully booted
+        # slice.
+        register :routes do
+          Hanami::Slice::RoutesHelper.new(self.class.slice.router)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/providers/settings.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "dry/system/provider/source"
+
+module Hanami
+  module Providers
+    class Settings < Dry::System::Provider::Source
+      def self.for_slice(slice)
+        Class.new(self) do |klass|
+          klass.instance_variable_set(:@slice, slice)
+        end
+      end
+
+      def self.slice
+        @slice || Hanami.app
+      end
+
+      def start
+        register :settings, self.class.slice.settings
+      end
+    end
+  end
+end

data/lib/hanami/rake_tasks.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "hanami/cli/rake_tasks"
+require "hanami/cli/command_line"
+
+Hanami::CLI::RakeTasks.register_tasks do
+  @_hanami_command_line = Hanami::CLI::CommandLine.new
+
+  desc "Load the app environment"
+  task :environment do
+    require "hanami/prepare"
+  end
+
+  # Ruby ecosystem compatibility
+  #
+  # Most of the SaaS automatic tasks are designed after Ruby on Rails.
+  # They expect the following Rake tasks to be present:
+  #
+  #   * db:migrate
+  #   * assets:precompile
+  #
+  # See https://github.com/heroku/heroku-buildpack-ruby/issues/442
+  #
+  # ===
+  #
+  # These Rake tasks aren't listed when someone runs `rake -T`, because we
+  # want to encourage developers to use `hanami` commands.
+  #
+  # In order to migrate the database or precompile assets a developer should
+  # use:
+  #
+  #   * hanami db migrate
+  #   * hanami assets precompile
+  #
+  # This is the preferred way to run Hanami command line tasks.
+  # Please use them when you're in control of your deployment environment.
+  #
+  # If you're not in control and your deployment requires these "standard"
+  # Rake tasks, they are here to solve this only specific problem.
+  namespace :db do
+    task :migrate do
+      # TODO(@jodosha): Enable when we'll integrate with ROM
+      # run_hanami_command("db migrate")
+    end
+  end
+
+  namespace :assets do
+    task :precompile do
+      # TODO(@jodosha): Enable when we'll integrate with hanami-assets
+      # run_hanami_command("assets precompile")
+    end
+  end
+
+  private
+
+  def run_hanami_command(command)
+    @_hanami_command_line.call(command)
+  end
+end
+
+Hanami::CLI::RakeTasks.install_tasks

data/lib/hanami/routes.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Hanami
+  # App routes
+  #
+  # Users are expected to inherit from this class to define their app
+  # routes.
+  #
+  # @example
+  #   # config/routes.rb
+  #   # frozen_string_literal: true
+  #
+  #   require "hanami/routes"
+  #
+  #   module MyApp
+  #     class Routes < Hanami::Routes
+  #       define do
+  #         root to: "home.show"
+  #       end
+  #     end
+  #   end
+  #
+  #   See {Hanami::Slice::Router} for the syntax allowed within the
+  #   `define` block.
+  #
+  # @see Hanami::Slice::Router
+  # @since 2.0.0
+  class Routes
+    # Defines app routes
+    #
+    # @yield DSL syntax to define app routes executed in the context
+    # of {Hanami::Slice::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

data/lib/hanami/server.rb

@@ -10,7 +10,7 @@ module Hanami
   #
   #   `bundle exec hanami server`
   #
-  # It runs the application, by using the server specified in your `Gemfile`
+  # It runs the app, by using the server specified in your `Gemfile`
   # (eg. Puma or Unicorn).
   #
   # @since 0.8.0

data/lib/hanami/settings/dotenv_store.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+module Hanami
+  class Settings
+    # Default app 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

data/lib/hanami/settings.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "dry/core/constants"
+
+module Hanami
+  # App settings
+  #
+  # Users are expected to inherit from this class to define their app settings.
+  #
+  # @example
+  #   # config/settings.rb
+  #   # frozen_string_literal: true
+  #
+  #   require "hanami/settings"
+  #   require "my_app/types"
+  #
+  #   module MyApp
+  #     class Settings < Hanami::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::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::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

data/lib/hanami/setup.rb

@@ -4,6 +4,8 @@ require "bundler/setup"
 require "hanami"
 
 begin
-  require File.join(Dir.pwd, "config/application")
-rescue LoadError # rubocop:disable Lint/SuppressedException
+  app_require_path = File.join(Dir.pwd, "config/app")
+  require app_require_path
+rescue LoadError => e
+  raise e unless e.path == app_require_path
 end

data/lib/hanami/{application → slice}/router.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
 require "hanami/router"
-require "hanami/application/routing/middleware/stack"
+require_relative "routing/middleware/stack"
 
 module Hanami
-  class Application
-    # Hanami application router
+  class Slice
+    # Hanami app router
     # @since 2.0.0
     class Router < ::Hanami::Router
+      # @api private
+      attr_reader :middleware_stack
+
       # @since 2.0.0
       # @api private
       def initialize(routes:, middleware_stack: Routing::Middleware::Stack.new, **kwargs, &blk)
@@ -27,32 +30,34 @@ module Hanami
 
       # @since 2.0.0
       # @api private
-      def use(middleware, *args, &blk)
-        @middleware_stack.use(middleware, *args, &blk)
+      def use(...)
+        middleware_stack.use(...)
       end
 
       # @since 2.0.0
       # @api private
       def scope(*args, &blk)
-        @middleware_stack.with(args.first) do
+        middleware_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)
+      def slice(slice_name, at:, &blk)
+        blk ||= @resolver.find_slice(slice_name).routes
 
-        scope(path, &blk)
+        prev_resolver = @resolver
+        @resolver = @resolver.to_slice(slice_name)
+
+        scope(prefixed_path(at), &blk)
+      ensure
+        @resolver = prev_resolver
       end
 
       # @since 2.0.0
       # @api private
       def to_rack_app
-        return self if @middleware_stack.empty?
-
-        @middleware_stack.to_rack_app(self)
+        middleware_stack.to_rack_app(self)
       end
     end
   end

data/lib/hanami/slice/routes_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Slice
+    # Hanami app routes helpers
+    #
+    # An instance of this class will be registered with slice (at the "routes" key). You
+    # can use it to access the route helpers for your app.
+    #
+    # @example
+    #   MyApp::App["routes"].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(...)
+        router.path(...)
+      end
+
+      # @see Hanami::Router::UrlHelpers#url
+      def url(...)
+        router.url(...)
+      end
+
+      private
+
+      attr_reader :router
+    end
+  end
+end

data/lib/hanami/{application → slice}/routing/middleware/stack.rb

@@ -3,7 +3,7 @@
 require "rack/builder"
 
 module Hanami
-  class Application
+  class Slice
     module Routing
       # Hanami::Applicatione::Router middleware stack
       #
@@ -20,6 +20,10 @@ module Hanami
           ROOT_PREFIX = "/"
           private_constant :ROOT_PREFIX
 
+          # @since 2.0.0
+          # @api private
+          attr_reader :stack
+
           # @since 2.0.0
           # @api private
           def initialize
@@ -29,8 +33,35 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def use(middleware, *args, &blk)
-            @stack[@prefix].push([middleware, args, blk])
+          def initialize_copy(source)
+            super
+            @prefix = source.instance_variable_get(:@prefix).dup
+            @stack = stack.dup
+          end
+
+          # @since 2.0.0
+          # @api private
+          def use(middleware, *args, before: nil, after: nil, &blk)
+            item = [middleware, args, blk]
+
+            if before
+              @stack[@prefix].insert((idx = index_of(before)).zero? ? 0 : idx - 1, item)
+            elsif after
+              @stack[@prefix].insert(index_of(after) + 1, item)
+            else
+              @stack[@prefix].push([middleware, args, blk])
+            end
+
+            self
+          end
+
+          # @since 2.0.0
+          # @api private
+          def update(other)
+            other.stack.each do |prefix, items|
+              stack[prefix].concat(items)
+            end
+            self
           end
 
           # @since 2.0.0
@@ -45,7 +76,7 @@ module Hanami
 
           # @since 2.0.0
           # @api private
-          def to_rack_app(app) # rubocop:disable Metrics/MethodLength
+          def to_rack_app(app)
             s = self
 
             Rack::Builder.new do
@@ -58,7 +89,7 @@ module Hanami
 
                 run app
               end
-            end.to_app
+            end
           end
 
           # @since 2.0.0
@@ -82,6 +113,13 @@ module Hanami
               builder.map(prefix, &blk)
             end
           end
+
+          private
+
+          # @since 2.0.0
+          def index_of(middleware)
+            @stack[@prefix].index { |(m, *)| m.equal?(middleware) }
+          end
         end
       end
     end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Slice
+    module Routing
+      # @since 2.0.0
+      class UnknownActionError < Hanami::Error
+        def initialize(identifier)
+          super("unknown action referenced in router: `#{identifier.inspect}'")
+        end
+      end
+
+      # @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
+
+      # Hanami app router endpoint resolver
+      #
+      # @since 2.0.0
+      class Resolver
+        SLICE_ACTIONS_KEY_NAMESPACE = "actions"
+
+        # @api private
+        # @since 2.0.0
+        def initialize(slice:)
+          @slice = slice
+        end
+
+        # @api private
+        # @since 2.0.0
+        def find_slice(slice_name)
+          slice.slices[slice_name]
+        end
+
+        # @api private
+        # @since 2.0.0
+        def to_slice(slice_name)
+          self.class.new(slice: find_slice(slice_name))
+        end
+
+        # @api private
+        # @since 2.0.0
+        def call(_path, endpoint)
+          endpoint =
+            case endpoint
+            when String
+              resolve_slice_action(endpoint)
+            when Class
+              endpoint.respond_to?(:call) ? endpoint : endpoint.new
+            else
+              endpoint
+            end
+
+          unless endpoint.respond_to?(:call)
+            raise NotCallableEndpointError.new(endpoint)
+          end
+
+          endpoint
+        end
+
+        private
+
+        # @api private
+        # @since 2.0.0
+        attr_reader :slice
+
+        # @api private
+        # @since 2.0.0
+        def resolve_slice_action(key)
+          action_key = "#{SLICE_ACTIONS_KEY_NAMESPACE}.#{key}"
+
+          ensure_action_in_slice(action_key)
+
+          # Lazily resolve action from the slice to reduce router initialization time, and
+          # circumvent endless loops from the action requiring access to router-related
+          # concerns (which may not be fully loaded at the time of reading the routes)
+          -> (*args) {
+            action = slice.resolve(action_key) do
+              raise UnknownActionError.new(key)
+            end
+
+            action.call(*args)
+          }
+        end
+
+        def ensure_action_in_slice(key)
+          return unless slice.booted?
+
+          raise UnknownActionError.new(key) unless slice.key?(key)
+        end
+      end
+    end
+  end
+end