hanami 2.0.0.beta1.1 → 2.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 768139dff49ba3a91a5aadccc7ae8aa1257ea04ce4497ba98e74780b84fd59c5
-  data.tar.gz: 06b9195a50933ee13ab2046e223f20e61535a2e909a4a26a00c0198af7d5c017
+  metadata.gz: 52462a1be45d338394f82872ac25bd8fc6e34f5b90991e74928342d0905d377d
+  data.tar.gz: 221af8ef1ba7993d6eb0678c0536513fca19f68b83bcf13d2fa5664747b83b98
 SHA512:
-  metadata.gz: 430e49a492be7463d755be92c580861d155586bc8ef009eba96b28a39670b576bc8230cc8d8529bd3e2ecc5950814f19bc5bb8d1f0210ccd466cd8f23b0ece7e
-  data.tar.gz: fb3c215103035f5c9af333792f5df2833952f0d7a8175d46d5f49683a824149be154430899f5aa485cd79c51183d4169b5d302b859b88239d7694da87707a01f
+  metadata.gz: f2e0f16b7bee12601ebe28645be73219dd97647d4dc2ddfa47af25ac974092afa8d4b4ec849e0f7866e266c6dd7f39ddf31aa19b857083fb1841f19b98affdbf
+  data.tar.gz: 1b2ad0280e15291bba6fdf5efaf75bb10555eba655087ea53a9c5c7e8a5522335e0e07e0f2bf81f2b2c4ce638c14a58bbe2d8c827a792a5d2fc17111245bb75a

data/CHANGELOG.md

@@ -2,8 +2,89 @@
 
 The web, with simplicity.
 
+## v2.0.0.beta3 - 2022-09-21
+
+### Changed
+
+- [Piotr Solnica] Simplify routes definition, by removing `routes` block from `config/routes.rb`
+
+### Added
+
+## 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,6 +138,7 @@ 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]

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/null_configuration.rb

@@ -5,8 +5,8 @@ require "dry/configurable"
 module Hanami
   class Configuration
     # NullConfiguration can serve as a fallback configuration object when out-of-gem
-    # configuration objects are not available (specifically, when the hanami-controller or
-    # hanami-view gems are not loaded)
+    # configuration objects are not available (specifically, when the
+    # hanami-controller, hanami-router or hanami-view gems are not loaded)
     class NullConfiguration
       include Dry::Configurable
     end

data/lib/hanami/configuration.rb

@@ -9,9 +9,8 @@ require "pathname"
 
 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 +26,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,27 +99,28 @@ 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)
 
-      @assets = load_dependent_config("hanami/assets/app_configuration") {
-        Hanami::Assets::AppConfiguration.new
-      }
+      # TODO: Make assets configuration dependent
+      require "hanami/assets/app_configuration"
+      @assets = Hanami::Assets::AppConfiguration.new
 
-      @actions = load_dependent_config("hanami/action") {
+      @actions = load_dependent_config("hanami-controller") {
         require_relative "configuration/actions"
         Actions.new
       }
 
-      @middleware = Slice::Routing::Middleware::Stack.new
-
-      @router = Router.new(self)
+      @router = load_dependent_config("hanami-router") {
+        require_relative "configuration/router"
+        @middleware = Slice::Routing::Middleware::Stack.new
+        Router.new(self)
+      }
 
-      @views = load_dependent_config("hanami/view") {
+      @views = load_dependent_config("hanami-view") {
         require_relative "configuration/views"
         Views.new
       }
@@ -199,7 +199,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,17 +210,15 @@ module Hanami
     end
 
     # @api private
-    def load_dependent_config(require_path, &block)
-      require require_path
-      yield
-    rescue LoadError => e
-      raise e unless e.path == require_path
-
-      require_relative "configuration/null_configuration"
-      NullConfiguration.new
+    def load_dependent_config(gem_name)
+      if Hanami.bundled?(gem_name)
+        yield
+      else
+        require_relative "configuration/null_configuration"
+        NullConfiguration.new
+      end
     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