hanami 2.0.0.beta1.1 → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 768139dff49ba3a91a5aadccc7ae8aa1257ea04ce4497ba98e74780b84fd59c5
-  data.tar.gz: 06b9195a50933ee13ab2046e223f20e61535a2e909a4a26a00c0198af7d5c017
+  metadata.gz: 9e9e5c35a72383ba29d2523a9b30da2a3170605bba5cee20562c897025a58524
+  data.tar.gz: 328e2e6aa30db94ce7dbae5f58d3ac0ce8435ec928ed71fa058345ca3a22553f
 SHA512:
-  metadata.gz: 430e49a492be7463d755be92c580861d155586bc8ef009eba96b28a39670b576bc8230cc8d8529bd3e2ecc5950814f19bc5bb8d1f0210ccd466cd8f23b0ece7e
-  data.tar.gz: fb3c215103035f5c9af333792f5df2833952f0d7a8175d46d5f49683a824149be154430899f5aa485cd79c51183d4169b5d302b859b88239d7694da87707a01f
+  metadata.gz: 769a484cea4c2594afaece8ae368e16003d02f988b6c015370b0b8236de477042611d71432da8d89d885ebabd3e0e013e7dd9299d0622897f44ac3d511980daf
+  data.tar.gz: e5808f8d9195cb242cbc02d136c993167ab124dabda9b239469841c981c621410d80ace966378157f22cdfd4aaf683f885257d96713561e2e12ce54cdadcab0f

data/CHANGELOG.md

@@ -2,8 +2,79 @@
 
 The web, with simplicity.
 
+## v2.0.0.beta2 - 2022-08-16
+
+### Added
+
+- [Tim Riley] Added `config.slices` setting to specify a list of slices to load. This may also be set via a comma-separated string in the `HANAMI_SLICES` env var. [#1189]
+
+  This is useful when only certain parts of your application are required for particular workloads. Specifying those slices directly improves boot time and minimizes memory usage, as well as ensuring clean boundaries between your slices.
+
+  For example, given an app with both `blog`, `shop` and `admin` slices, you can specify only the first two to load:
+
+  ```ruby
+  # config/app.rb
+
+  module AppName
+    class App < Hanami::App
+      config.slices = %w[blog shop]
+    end
+  end
+  ```
+
+  Or by setting `HANAMI_SLICES=blog,shop` in the env.
+
+  You can also specify arbitrarily nested slices using dot delimiters. For example, if you have an `admin` slice with nested `shop` and `blog` slices, you can specify `config.slices = %w[admin.shop]` to only load the admin slice and its nested shop slice.
+- [Tim Riley] Added `App.prepare_load_path`, which need only be called if you explicitly change your app's `config.root`. The `$LOAD_PATH` is otherwise still prepared automatically for the default `root` of `Dir.pwd`. [#1188]
+- [Marc Busqué, Tim Riley] Added `Hanami.setup` to find and load your Hanami app file (expected at `config/app.rb`). This will search in the current directory, and will search upwards through parent directories until the app file is found. [#1197]
+
+  This behavior allows `Hanami.setup` (and its counterpart convenience require, `require "hanami/setup"`) to work even when called
+  from a nested directory within your Hanami app.
+
+  Also added `Hanami.app_path`, returning the absolute path of the app file, if found.
+
+### Changed
+
+- [Tim Riley] Allow access to autoloaded constants from within `config/settings.rb` [#1186]
+
+  New Hanami apps generate a types module at `lib/[app_name]/types.rb`. Now you can access it within your settings class to type check your settings, e.g.
+
+  ```ruby
+  # config/settings.rb
+
+  module AppName
+    class Settings < Hanami::Settings
+      # By default, AppName::Types is defined at `lib/[app_name]/types.rb`, and can be autoloaded here
+      setting :some_flag, constructor: Types::Params::Bool
+    end
+  end
+  ```
+
+  For settings defined within a slice, you can access types (or any constant) defined within the slice:
+
+  ```ruby
+  # slices/slice_name/config/settings.rb
+
+  module SliceName
+    class Settings < Hanami::Settings
+      # SliceName::Types is expected to be defined at `slices/[slice_name]/types.rb`
+      setting :some_slice_flag, constructor: Types::Params::bool
+    end
+  end
+  ```
+- [Tim Riley] Every slice has a distinct `Zeitwerk::Loader` instance at `Slice.autoloader`. This change enabled the autoloading within settings described above. [#1186]
+- [Tim Riley] `Slice.settings` reader method has been removed. Access settings via `App["settings"]` or `Slice["settings"]` (after the slice has been prepared) instead. [#1186]
+- [Tim Riley] dry-types is no longer a dependency specified in the gemspec. This is made available to generated app via a line in their `Gemfile` instead. [#1186]
+
+### Fixed
+
+- [Tim Riley] `config` explicitly set in `Hanami::Action` or `Hanami::View` base classes (either app- or slice-level) is no longer overridden by slice-level configuration [#1193]
+- [Nikita Shilnikov] Load dry-monitor rack extension explicitly to avoid autoloading errors [#1198] [#1199]
+
 ## v2.0.0.beta1.1 - 2022-07-22
 
+### Changed
+
 - [Andrew Croome] Specified 2.0.0.beta dependencies for hanami-cli and hanami-utils (to prefer these over previously installed alpha versions) [#1187]
 
 ## v2.0.0.beta1 - 2022-07-20
@@ -57,10 +128,12 @@ The web, with simplicity.
 - [Luca Guidi] `Hanami.application` -> `Hanami.app`
 - [Luca Guidi] `config/application.rb` -> `config/app.rb`
 - [Luca Guidi] Remove `::Application::` namespace in public API class names (e.g. `Hanami::Application::Routes` -> `Hanami::Routes`) [#1172]
+- [Tim Riley] Removed `Hanami::Configuration#source_dirs` due to the new autoloading and auto-registration features [#1174]
 - [Tim Riley] Removed `Hanami::Configuration#settings_path`, `#settings_class_name` [#1175]
 - [Tim Riley] Removed `Hanami::Configuration::Router#routes_path`, and `#routes_class_name` [#1175]
 - [Tim Riley] Make `Hanami::App` to inherit from `Hanami::Slice` [#1162]
 
+
 ## v2.0.0.alpha8 - 2022-05-19
 
 ### Added

data/hanami.gemspec

@@ -34,10 +34,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "bundler",          ">= 1.16", "< 3"
   spec.add_dependency "dry-configurable", "~> 0.15"
   spec.add_dependency "dry-core",         "~> 0.7"
-  spec.add_dependency "dry-types",        "~> 1.5"
   spec.add_dependency "dry-inflector",    "~> 0.2", ">= 0.2.1"
   spec.add_dependency "dry-system",       "~> 0.25", ">= 0.25.0"
-  spec.add_dependency "dry-monitor",      "~> 0.6", ">= 0.6.0"
+  spec.add_dependency "dry-monitor",      "~> 0.6", ">= 0.6.3"
   spec.add_dependency "hanami-cli",       "~> 2.0.beta"
   spec.add_dependency "hanami-utils",     "~> 2.0.beta"
   spec.add_dependency "zeitwerk",         "~> 2.4"

data/lib/hanami/app.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "zeitwerk"
 require_relative "configuration"
 require_relative "constants"
 require_relative "slice"
@@ -31,29 +30,97 @@ module Hanami
       @_mutex.synchronize do
         subclass.class_eval do
           @configuration = Hanami::Configuration.new(app_name: slice_name, env: Hanami.env)
-          @autoloader = Zeitwerk::Loader.new
 
-          prepare_base_load_path
+          # Prepare the load path (based on the default root of `Dir.pwd`) as early as
+          # possible, so you can make a `require` inside the body of an `App` subclass,
+          # which may be useful for certain kinds of app configuration.
+          prepare_load_path
+
+          load_dotenv
         end
       end
     end
 
     # App class interface
     module ClassMethods
-      attr_reader :autoloader, :configuration
+      attr_reader :configuration
 
       def app_name
         slice_name
       end
 
+      # Prepares the $LOAD_PATH based on the app's configured root, prepending the `lib/`
+      # directory if it exists. If the lib directory is already added, this will do
+      # nothing.
+      #
+      # In ordinary circumstances, you should never have to call this method: this method
+      # is called immediately upon subclassing {Hanami::App}, as a convenicence to put
+      # lib/ (under the default root of `Dir.pwd`) on the load path automatically. This is
+      # helpful if you need to require files inside the subclass body for performing
+      # certain app configuration steps.
+      #
+      # If you change your app's `config.root` and you need to require files from its
+      # `lib/` directory within your {App} subclass body, you should call
+      # {.prepare_load_path} explicitly after setting the new root.
+      #
+      # Otherwise, this method is called again as part of the app {.prepare} step, so if
+      # you've changed your app's root and do _not_ need to require files within your {App}
+      # subclass body, then you don't need to call this method.
+      #
+      # @example
+      #   module MyApp
+      #     class App < Hanami::App
+      #       config.root = Pathname(__dir__).join("../src")
+      #       prepare_load_path
+      #
+      #       # You can make requires for your files here
+      #     end
+      #   end
+      #
+      # @return [self]
+      #
+      # @api public
+      # @since 2.0.0
+      def prepare_load_path
+        if (lib_path = root.join(LIB_DIR)).directory?
+          path = lib_path.realpath.to_s
+          $LOAD_PATH.prepend(path) unless $LOAD_PATH.include?(path)
+        end
+
+        self
+      end
+
       private
 
-      def prepare_base_load_path
-        base_path = root.join(LIB_DIR)
-        $LOAD_PATH.unshift(base_path) unless $LOAD_PATH.include?(base_path)
+      # Uses [dotenv](https://github.com/bkeepers/dotenv) (if available) to populate `ENV` from
+      # various `.env` files.
+      #
+      # For a given `HANAMI_ENV` environment, the `.env` files are looked up in the following order:
+      #
+      # - .env.{environment}.local
+      # - .env.local (unless the environment is `test`)
+      # - .env.{environment}
+      # - .env
+      #
+      # If dotenv is unavailable, the method exits and does nothing.
+      def load_dotenv
+        return unless Hanami.bundled?("dotenv")
+
+        hanami_env = Hanami.env
+        dotenv_files = [
+          ".env.#{hanami_env}.local",
+          (".env.local" unless hanami_env == :test),
+          ".env.#{hanami_env}",
+          ".env"
+        ].compact
+
+        require "dotenv"
+        Dotenv.load(*dotenv_files)
       end
 
       def prepare_all
+        prepare_load_path
+
         # Make app-wide notifications available as early as possible
         container.use(:notifications)
 
@@ -65,16 +132,9 @@ module Hanami
         # standard steps have been skipped via the empty method overrides below.
         prepare_app_component_dirs
         prepare_app_providers
-
-        # The autoloader must be setup after the container is configured, which is the
-        # point at which any component dirs from other slices are added to the autoloader
-        app = self
-        container.after(:configure) do
-          app.send(:prepare_app_autoloader)
-        end
       end
 
-      # Skip standard slice prepare steps that do not apply to the app slice
+      # Skip standard slice prepare steps that do not apply to the app
       def prepare_container_component_dirs; end
       def prepare_container_imports; end
 
@@ -122,7 +182,7 @@ module Hanami
         register_provider(:rack, source: Hanami::Providers::Rack, namespace: true)
       end
 
-      def prepare_app_autoloader
+      def prepare_autoloader
         # Component dirs are automatically pushed to the autoloader by dry-system's
         # zeitwerk plugin. This method adds other dirs that are not otherwise configured
         # as component dirs.

data/lib/hanami/assets/{application_configuration.rb → app_configuration.rb}

@@ -7,7 +7,7 @@ module Hanami
   module Assets
     # @since 2.0.0
     # @api public
-    class ApplicationConfiguration
+    class AppConfiguration
       include Dry::Configurable
 
       # @since 2.0.0

data/lib/hanami/configuration.rb

@@ -11,7 +11,7 @@ require_relative "constants"
 require_relative "configuration/logger"
 require_relative "configuration/router"
 require_relative "configuration/sessions"
-require_relative "settings/dotenv_store"
+require_relative "settings/env_store"
 require_relative "slice/routing/middleware/stack"
 
 module Hanami
@@ -27,18 +27,18 @@ module Hanami
 
     setting :inflector, default: Dry::Inflector.new
 
-    setting :settings_store, default: Hanami::Settings::DotenvStore
-
-    setting :slices do
-      setting :shared_component_keys, default: %w[
-        inflector
-        logger
-        notifications
-        rack.monitor
-        routes
-        settings
-      ]
-    end
+    setting :settings_store, default: Hanami::Settings::EnvStore.new
+
+    setting :shared_app_component_keys, default: %w[
+      inflector
+      logger
+      notifications
+      rack.monitor
+      routes
+      settings
+    ]
+
+    setting :slices
 
     setting :base_url, default: "http://0.0.0.0:2300", constructor: ->(url) { URI(url) }
 
@@ -100,10 +100,9 @@ module Hanami
       @environments = DEFAULT_ENVIRONMENTS.clone
       @env = env
 
-      # Some default setting values must be assigned at initialize-time to ensure they
-      # have appropriate values for the current app
+      # Apply default values that are only knowable at initialize-time (vs require-time)
       self.root = Dir.pwd
-      self.settings_store = Hanami::Settings::DotenvStore.new.with_dotenv_loaded
+      load_from_env
 
       config.logger = Configuration::Logger.new(env: env, app_name: app_name)
 
@@ -199,7 +198,10 @@ module Hanami
 
     private
 
-    # @api private
+    def load_from_env
+      self.slices = ENV["HANAMI_SLICES"]&.split(",")&.map(&:strip)
+    end
+
     def apply_env_config(env = self.env)
       environments[env].each do |block|
         instance_eval(&block)
@@ -207,7 +209,7 @@ module Hanami
     end
 
     # @api private
-    def load_dependent_config(require_path, &block)
+    def load_dependent_config(require_path)
       require require_path
       yield
     rescue LoadError => e
@@ -217,7 +219,6 @@ module Hanami
       NullConfiguration.new
     end
 
-    # @api private
     def method_missing(name, *args, &block)
       if config.respond_to?(name)
         config.public_send(name, *args, &block)
@@ -226,7 +227,6 @@ module Hanami
       end
     end
 
-    # @api private
     def respond_to_missing?(name, _incude_all = false)
       config.respond_to?(name) || super
     end

data/lib/hanami/extensions/action/slice_configured_action.rb

@@ -48,7 +48,50 @@ module Hanami
 
         def configure_action(action_class)
           action_class.config.settings.each do |setting|
-            action_class.config.public_send :"#{setting}=", actions_config.public_send(:"#{setting}")
+            # Configure the action from config on the slice, _unless it has already been configured
+            # by a parent slice_, and re-configuring it for this slice would make no change.
+            #
+            # In the case of most slices, its actions config is likely to be the same as its parent
+            # (since each slice copies its `config` from its parent), and if we re-apply the config
+            # here, then it may possibly overwrite config customisations explicitly made in parent
+            # action classes.
+            #
+            # For example, given an app-level base action class, with custom config:
+            #
+            #   module MyApp
+            #     class Action < Hanami::Action
+            #       config.default_response_format = :json
+            #     end
+            #   end
+            #
+            # And then an action in a slice inheriting from it:
+            #
+            #   module MySlice
+            #     module Actions
+            #       class SomeAction < MyApp::Action
+            #       end
+            #     end
+            #   end
+            #
+            # In this case, `SliceConfiguredAction` will be extended two times:
+            #
+            # 1. When `MyApp::Action` is defined
+            # 2. Again when `MySlice::Actions::SomeAction` is defined
+            #
+            # If we blindly re-configure all action settings each time `SliceConfiguredAction` is
+            # extended, then at the point of (2) above, we'd end up overwriting the custom
+            # `config.default_response_format` explicitly configured in the `MyApp::Action` base
+            # class, leaving `MySlice::Actions::SomeAction` with `config.default_response_format` of
+            # `:html` (the default at `Hanami.app.config.actions.default_response_format`), and not
+            # the `:json` value configured in its immediate superclass.
+            #
+            # This would be surprising behavior, and we want to avoid it.
+            slice_value = slice.config.actions.public_send(:"#{setting}")
+            parent_value = slice.parent.config.actions.public_send(:"#{setting}") if slice.parent
+
+            next if slice.parent && slice_value == parent_value
+
+            action_class.config.public_send(:"#{setting}=", slice_value)
           end
         end
 

data/lib/hanami/extensions/view/slice_configured_view.rb

@@ -32,12 +32,52 @@ module Hanami
         # rubocop:disable Metrics/AbcSize
         def configure_view(view_class)
           view_class.settings.each do |setting|
-            if slice.config.views.respond_to?(:"#{setting}")
-              view_class.config.public_send(
-                :"#{setting}=",
-                slice.config.views.public_send(:"#{setting}")
-              )
-            end
+            next unless slice.config.views.respond_to?(:"#{setting}")
+
+            # Configure the view from config on the slice, _unless it has already been configured by
+            # a parent slice_, and re-configuring it for this slice would make no change.
+            #
+            # In the case of most slices, its views config is likely to be the same as its parent
+            # (since each slice copies its `config` from its parent), and if we re-apply the config
+            # here, then it may possibly overwrite config customisations explicitly made in parent
+            # view classes.
+            #
+            # For example, given an app-level base view class, with custom config:
+            #
+            #   module MyApp
+            #     class View < Hanami::View
+            #       config.layout = "custom_layout"
+            #     end
+            #   end
+            #
+            # And then a view in a slice inheriting from it:
+            #
+            #   module MySlice
+            #     module Views
+            #       class SomeView < MyApp::View
+            #       end
+            #     end
+            #   end
+            #
+            # In this case, `SliceConfiguredView` will be extended two times:
+            #
+            # 1. When `MyApp::View` is defined
+            # 2. Again when `MySlice::Views::SomeView` is defined
+            #
+            # If we blindly re-configure all view settings each time `SliceConfiguredView` is
+            # extended, then at the point of (2) above, we'd end up overwriting the custom
+            # `config.layout` explicitly configured in the `MyApp::View` base class, leaving
+            # `MySlice::Views::SomeView` with `config.layout` of `"app"` (the default as specified
+            # at `Hanami.app.config.views.layout`), and not the `"custom_layout"` value configured
+            # in its immediate superclass.
+            #
+            # This would be surprising behavior, and we want to avoid it.
+            slice_value = slice.config.views.public_send(:"#{setting}")
+            parent_value = slice.parent.config.views.public_send(:"#{setting}") if slice.parent
+
+            next if slice.parent && slice_value == parent_value
+
+            view_class.config.public_send(:"#{setting}=", slice_value)
           end
 
           view_class.config.inflector = inflector
@@ -86,7 +126,7 @@ module Hanami
 
           begin
             inflector.constantize(inflector.camelize(path))
-          rescue NameError => exception
+          rescue NameError # rubocop: disable Lint/SuppressedException
           end
         end
 

data/lib/hanami/providers/rack.rb

@@ -8,6 +8,8 @@ module Hanami
       def prepare
         require "dry/monitor"
         require "hanami/web/rack_logger"
+
+        Dry::Monitor.load_extensions(:rack)
       end
 
       def start

data/lib/hanami/providers/settings.rb

@@ -1,22 +1,97 @@
 # frozen_string_literal: true
 
 require "dry/system/provider/source"
+require_relative "../constants"
+require_relative "../errors"
 
 module Hanami
   module Providers
+    # The settings provider loads and registers the "settings" component in app and slice
+    # containers.
+    #
+    # To register this provider with a slice container, you should use
+    # {.register_with_slice}, which will register the provider only if settings are
+    # defined for the slice.
+    #
+    # @see Slice::ClassMethods.prepare_container_providers
+    #
+    # @api private
+    # @since 2.0.0
     class Settings < Dry::System::Provider::Source
-      def self.for_slice(slice)
-        Class.new(self) do |klass|
-          klass.instance_variable_set(:@slice, slice)
+      class << self
+        # Registers the provider with the slice's container, but only if settings are
+        # defined for the slice.
+        def register_with_slice(slice)
+          return unless settings_defined?(slice)
+
+          slice.register_provider(:settings, source: with_slice(slice))
+        end
+
+        # Creates a new subclass of the provider for the given slice.
+        #
+        # You must do this before registering the provider with a container. The provider
+        # uses the slice to locate the settings definition based on the slice's config.
+        def with_slice(slice)
+          Class.new(self) do |klass|
+            klass.instance_variable_set(:@slice, slice)
+          end
+        end
+
+        # Returns the slice for the provider
+        def slice
+          unless @slice
+            raise SliceLoadError, "a slice must be given to #{self} via `.with_slice(slice)`"
+          end
+
+          @slice
+        end
+
+        private
+
+        # Returns true if settings are defined for the slice.
+        #
+        # Settings are considered defined if a `Settings` class is already defined in the
+        # slice namespace, or a `config/settings.rb` exists under the slice root.
+        def settings_defined?(slice)
+          slice.namespace.const_defined?(SETTINGS_CLASS_NAME) ||
+            slice.root.join("#{SETTINGS_PATH}#{RB_EXT}").file?
         end
       end
 
-      def self.slice
-        @slice || Hanami.app
+      def prepare
+        require_slice_settings unless slice_settings_class?
       end
 
       def start
-        register :settings, self.class.slice.settings
+        settings = slice_settings_class.new(slice.config.settings_store)
+
+        register :settings, settings
+      end
+
+      private
+
+      def slice
+        self.class.slice
+      end
+
+      def slice_settings_class?
+        slice.namespace.const_defined?(SETTINGS_CLASS_NAME)
+      end
+
+      def slice_settings_class
+        slice.namespace.const_get(SETTINGS_CLASS_NAME)
+      end
+
+      def require_slice_settings
+        require "hanami/settings"
+
+        slice_settings_require_path = File.join(slice.root, SETTINGS_PATH)
+
+        begin
+          require slice_settings_require_path
+        rescue LoadError => e
+          raise e unless e.path == slice_settings_require_path
+        end
       end
     end
   end

data/lib/hanami/settings/env_store.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "dry/core/constants"
+
+module Hanami
+  class Settings
+    # The default store for {Hanami:Settings}, loading setting values from `ENV`.
+    #
+    # If your app loads the dotenv gem, then `ENV` will also be populated from various `.env` files when
+    # you subclass `Hanami::App`.
+    #
+    # @since 2.0.0
+    # @api private
+    class EnvStore
+      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
+    end
+  end
+end

data/lib/hanami/settings.rb

@@ -22,26 +22,22 @@ module Hanami
   #     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.
+  # 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}.
+  # 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::EnvStore}.
   #
-  # 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`.
+  # 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.
+    # Its message collects all the individual errors that can be raised for each setting.
     InvalidSettingsError = Class.new(StandardError) do
       def initialize(errors)
         @errors = errors

data/lib/hanami/setup.rb

@@ -3,9 +3,4 @@
 require "bundler/setup"
 require "hanami"
 
-begin
-  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
+Hanami.setup