hanami 2.0.0.alpha2 → 2.0.0.alpha3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee3c6a367cfd05f2b18ae080da80b75a08a8680bd922ac8b00433e0c59f53f2b
-  data.tar.gz: 2de0d4102bf80606d130c04d83716370fe2c1c985986cd034ce232ff08e9be61
+  metadata.gz: f322cd4a751d83369d2d20f0f209bfb1dca92a78f6a3dd7c4027ea672df84e36
+  data.tar.gz: 801be572c3df6e61bfaee8b72f0a164dcbe83216f33c72972c67334f9b2619cf
 SHA512:
-  metadata.gz: a7d143ccf35f088d91fa1702d40b5aac22b3cada72cf566b239403d97fdd22b0839f93a1c20286853ae440ea4898902605b0bfbd3b05854f149de98ef9a78a83
-  data.tar.gz: 8f512b014ed54456df5beb0d3ecccbe260f0186d3ebfba7fb2fc51f9d80956b511ab87e08e1149dd2dd02d94939a1b260059f2cfcaa1ee34ca6681aee1408434
+  metadata.gz: 244ab662705c248857bc4d4e3f42b1de6dc92003fb3c8fe6d3cd006194be272d1aac36f570baa319a971dfcdd6f24eb691c270fa57b852fdbc4da863bc1908d1
+  data.tar.gz: 3d6b72d227de112fbedefb7f8f6fbcb1e010fb37bf3d97e5826b6fe134dc0facd2a36bba0ad5e2118f731ee2bb1d18ae4f7307377c0fd31e5b81a3e307c56ae0

data/CHANGELOG.md

@@ -1,6 +1,53 @@
 # Hanami
 The web, with simplicity.
 
+## v2.0.0.alpha3 - 2021-11-09
+### Added
+- [Luca Guidi] Added `Hanami.shutdown` to stop all bootable components in the application container
+- [Tim Riley] Added `component_dir_paths` application setting to allow for components to be loaded from additional directories inside each slice directory. To begin with, this defaults to `%w[actions repositories views]`. Components inside these directories are expected to be namespaced to match the directory name; e.g. given a `main` slice, `slices/main/actions/home.rb` is expected to define `Main::Actions::Home`, and will be registered in the slice container as `"actions.home"`.
+
+### Changed
+- [Tim Riley] A slice's classes can now be defined directly inside `slices/[slice_name]/lib/`; e.g. given a `main` slice, `slices/main/lib/example.rb` is expected to define `Main::Example`, and will be registered in the slice container as `"example"`
+- [Tim Riley] The root `lib/` directory is no longer configured as a component dir, and classes inside `lib/[app_namespace]/` will no longer be auto-registered into the container. If you need to share components, create them in their own slices as appropriate, and import those slices into the other slices that require them.
+- [Tim Riley] `lib/[app_namespace]/` is configured for autoloading, and `lib/` is added to `$LOAD_PATH` to support explicit requires for source files outside `lib/[app_namespace]/`.
+- [Tim Riley] (Internal) Ported `Hanami::Configuration` and related classes to use dry-configurable
+- [Tim Riley] Application inflector can be entirely replaced, if required, via `Hanami::Configuration#inflector=`. Custom inflection rules can still be provided to the default inflector via `Hanami::Configuration#inflections`.
+- [Marc Busqué] App settings are defined within a concrete class rather than an anonymous block, to allow for users to leverage the typical behavior of Ruby classes, such as for defining their own types module to use for coercing setting values. This class also relies on dry-configurable for its settings implementation, so the standard dry-configurable `setting` API is available, such as the `constructor:` and `default:` options.
+    ```ruby
+    # frozen_string_literal: true
+
+    require "dry/types"
+    require "hanami/application/settings"
+
+    module TestApp
+      class Settings < Hanami::Application::Settings
+        # Example usage of a types module (previously not possible inside the anonymous block)
+        Types = Dry.Types()
+
+        setting :session_secret, constructor: Types::String.constrained(min_size: 20)
+
+        setting :some_bool, constructor: Types::Params::Bool, default: false
+      end
+    end
+    ```
+- [Marc Busqué] Application `settings_loader` and `settings_loader_options` have been replaced with `settings_store`, which is an updated abstraction for providing setting values to work with the new `Hanami::Application::Settings` implementation noted above (see `Application::Settings::DotenvStore` for the default store, which provides the same behavior as previously)
+- [Marc Busqué] Routes are defined within a concrete class rather than an anonymous block, to provide consistency with the settings (noted above), as well a place for additional behavior (in future releases):
+    ```ruby
+    # 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
+    ```
+
 ## v2.0.0.alpha2 - 2021-05-04
 ### Added
 - [Luca Guidi] Official support for Ruby: MRI 3.0

data/README.md

@@ -2,6 +2,10 @@
 
 The web, with simplicity.
 
+## Version
+
+**This branch contains the code for `hanami` 2.0.x.**
+
 ## Frameworks
 
 Hanami is a **full-stack** Ruby web framework.
@@ -25,8 +29,8 @@ These components are designed to be used independently or together in a Hanami a
 ## Status
 
 [![Gem Version](https://badge.fury.io/rb/hanami.svg)](https://badge.fury.io/rb/hanami)
-[![CI](https://github.com/hanami/hanami/workflows/ci/badge.svg?branch=unstable)](https://github.com/hanami/hanami/actions?query=workflow%3Aci+branch%3Aunstable)
-[![Test Coverage](https://codecov.io/gh/hanami/hanami/branch/unstable/graph/badge.svg)](https://codecov.io/gh/hanami/hanami)
+[![CI](https://github.com/hanami/hanami/workflows/ci/badge.svg?branch=main)](https://github.com/hanami/hanami/actions?query=workflow%3Aci+branch%3Amain)
+[![Test Coverage](https://codecov.io/gh/hanami/hanami/branch/main/graph/badge.svg)](https://codecov.io/gh/hanami/hanami)
 [![Depfu](https://badges.depfu.com/badges/ba000e0f69e6ef1c44cd3038caaa1841/overview.svg)](https://depfu.com/github/hanami/hanami?project=Bundler)
 [![Inline Docs](http://inch-ci.org/github/hanami/hanami.svg)](http://inch-ci.org/github/hanami/hanami)
 

data/hanami.gemspec

@@ -22,10 +22,11 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.add_dependency "bundler",           ">= 1.16", "< 3"
+  spec.add_dependency "dry-configurable",  "~> 0.12", ">= 0.12.1"
   spec.add_dependency "dry-core",          "~> 0.4"
-  spec.add_dependency "dry-inflector",     "~> 0.1", ">= 0.1.2"
+  spec.add_dependency "dry-inflector",     "~> 0.2", ">= 0.2.1"
   spec.add_dependency "dry-monitor"
-  spec.add_dependency "dry-system",        "~> 0.19", ">= 0.19.0"
+  spec.add_dependency "dry-system",        "~> 0.19", ">= 0.21.0"
   spec.add_dependency "hanami-cli",        "~> 2.0.alpha"
   spec.add_dependency "hanami-utils",      "~> 2.0.alpha"
   spec.add_dependency "zeitwerk",          "~> 2.4"

data/lib/hanami/application/container/boot/logger.rb

@@ -2,7 +2,6 @@
 
 Hanami.application.register_bootable :logger do
   start do
-    require "hanami/logger"
-    register :logger, Hanami::Logger.new(**Hanami.application.configuration.logger)
+    register :logger, Hanami.application.configuration.logger_instance
   end
 end

data/lib/hanami/application/container/boot/rack_logger.rb

@@ -9,7 +9,7 @@ Hanami.application.register_bootable :rack_logger do |container|
 
     rack_logger = Hanami::Web::RackLogger.new(
       container[:logger],
-      filter_params: Hanami.application.configuration.rack_logger_filter_params
+      filter_params: Hanami.application.configuration.logger.filter_params
     )
 
     rack_logger.attach container[:rack_monitor]

data/lib/hanami/application/routes.rb

@@ -0,0 +1,54 @@
+# 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}
+      # @returns [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/routing/resolver.rb

@@ -72,7 +72,7 @@ module Hanami
         def resolve_string_identifier(path, identifier)
           slice_name = slices_registry.find(path) or raise "missing slice for #{path.inspect} (#{identifier.inspect})"
           slice = slices[slice_name]
-          action_key = "actions.#{identifier.gsub(/[#\/]/, '.')}"
+          action_key = "actions.#{identifier}"
 
           slice[action_key]
         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

@@ -1,22 +1,92 @@
 # frozen_string_literal: true
 
+require "dry/configurable"
 require "dry/core/constants"
-require_relative "settings/definition"
-require_relative "settings/struct"
 
 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
-    module Settings
-      Undefined = Dry::Core::Constants::Undefined
+    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
 
-      def self.build(loader, loader_options, &definition_block)
-        definition = Definition.new(&definition_block)
-        settings = loader.new(**loader_options).call(definition.settings)
+        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
 
-        Struct[settings.keys].new(settings)
+      def respond_to_missing?(name, _include_all = false)
+        config.respond_to?(name) || super
       end
     end
   end

data/lib/hanami/application.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require "dry/system/container"
+require "dry/system/loader/autoloading"
 require "hanami/configuration"
 require "pathname"
 require "rack"
+require "zeitwerk"
 require_relative "slice"
 require_relative "application/autoloader/inflector_adapter"
+require_relative "application/routes"
 require_relative "application/settings"
 
 module Hanami
@@ -52,7 +55,10 @@ module Hanami
       def init # rubocop:disable Metrics/MethodLength
         return self if inited?
 
-        configuration.finalize
+        configuration.finalize!
+
+        @autoloader = Zeitwerk::Loader.new
+        autoloader.inflector = Autoloader::InflectorAdapter.new(inflector)
 
         load_settings
 
@@ -63,10 +69,7 @@ module Hanami
         slices.values.each(&:init)
         slices.freeze
 
-        if configuration.autoloader
-          configuration.autoloader.inflector = Autoloader::InflectorAdapter.new(inflector)
-          configuration.autoloader.setup
-        end
+        autoloader.setup
 
         load_routes
 
@@ -78,6 +81,12 @@ module Hanami
         @inited
       end
 
+      def autoloader
+        raise "Application not init'ed" unless defined?(@autoloader)
+
+        @autoloader
+      end
+
       def container
         raise "Application not init'ed" unless defined?(@container)
 
@@ -151,32 +160,17 @@ module Hanami
         @booted
       end
 
-      def settings(&block) # rubocop:disable Metrics/MethodLength
-        if block
-          @_settings = Application::Settings.build(
-            configuration.settings_loader,
-            configuration.settings_loader_options,
-            &block
-          )
-        elsif instance_variable_defined?(:@_settings)
-          @_settings
-        else
-          # Load settings lazily so they can be used to configure the
-          # Hanami::Application subclass (before the application has inited)
-          load_settings
-          @_settings ||= nil
-        end
+      def shutdown
+        container.shutdown!
       end
 
-      def routes(&block)
-        @_mutex.synchronize do
-          if block.nil?
-            raise "Hanami.application.routes not configured" unless defined?(@_routes)
+      def settings
+        @_settings ||= load_settings
+      end
 
-            @_routes
-          else
-            @_routes = block
-          end
+      def routes
+        @_mutex.synchronize do
+          @_routes ||= load_routes
         end
       end
 
@@ -187,6 +181,10 @@ module Hanami
         inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
       end
 
+      def namespace_name
+        namespace.name
+      end
+
       def namespace_path
         inflector.underscore(namespace)
       end
@@ -256,21 +254,19 @@ module Hanami
             Pathname(__dir__).join("application/container/boot").realpath,
           ]
 
-          if configuration.autoloader
-            require "dry/system/loader/autoloading"
-            config.component_dirs.loader = Dry::System::Loader::Autoloading
-            config.component_dirs.add_to_load_path = false
-          end
-
-          if root.join("lib").directory?
-            config.component_dirs.add "lib" do |dir|
-              dir.default_namespace = application_name.to_s
-            end
+          config.component_dirs.loader = Dry::System::Loader::Autoloading
+          config.component_dirs.add_to_load_path = false
+        end
 
-            configuration.autoloader&.push_dir(root.join("lib"))
-          end
+        # Autoload classes defined in lib/[app_namespace]/
+        if root.join("lib", namespace_path).directory?
+          autoloader.push_dir(root.join("lib", namespace_path), namespace: namespace)
         end
 
+        # Add lib/ to to the $LOAD_PATH so other files there (outside the app namespace)
+        # are require-able
+        container.add_to_load_path!("lib") if root.join("lib").directory?
+
         container
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
@@ -317,14 +313,23 @@ module Hanami
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def load_routes
-        require File.join(configuration.root, configuration.router.routes)
+        require File.join(configuration.root, configuration.router.routes_path)
+        routes_class = autodiscover_application_constant(configuration.router.routes_class_name)
+        routes_class.routes
       rescue LoadError # rubocop:disable Lint/SuppressedException
       end
 
       def load_settings
         prepare_base_load_path
         require File.join(configuration.root, configuration.settings_path)
-      rescue LoadError # rubocop:disable Lint/SuppressedException
+        settings_class = autodiscover_application_constant(configuration.settings_class_name)
+        settings_class.new(configuration.settings_store)
+      rescue LoadError
+        Settings.new
+      end
+
+      def autodiscover_application_constant(constants)
+        inflector.constantize([namespace_name, *constants].join(MODULE_DELIMITER))
       end
     end
     # rubocop:enable Metrics/ModuleLength

data/lib/hanami/configuration/logger.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+require "hanami/logger"
+
+module Hanami
+  class Configuration
+    # Hanami logger configuration
+    #
+    # @since 2.0.0
+    class Logger
+      include Dry::Configurable
+
+      protected :config
+
+      setting :logger_class, default: Hanami::Logger
+
+      setting :options, default: {level: :debug}
+
+      # Currently used for logging of Rack requests only.
+      #
+      # TODO: incorporate this into the standard logging some way or another
+      setting :filter_params, default: %w[_csrf password password_confirmation].freeze
+
+      private
+
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _incude_all = false)
+        config.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/hanami/configuration/middleware.rb

@@ -6,6 +6,8 @@ module Hanami
     #
     # @since 2.0.0
     class Middleware
+      attr_reader :stack
+
       def initialize
         @stack = []
       end
@@ -13,8 +15,6 @@ module Hanami
       def use(middleware, *args, &block)
         stack.push([middleware, *args, block].compact)
       end
-
-      attr_reader :stack
     end
   end
 end

data/lib/hanami/configuration/null_configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+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)
+    class NullConfiguration
+      include Dry::Configurable
+    end
+  end
+end

data/lib/hanami/configuration/router.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "dry/configurable"
+require_relative "../application/routing/resolver"
+
 module Hanami
   class Configuration
     # Hanami router configuration
@@ -7,44 +10,43 @@ module Hanami
     # @since 2.0.0
     # @api private
     class Router
-      # @api private
-      # @since 2.0.0
-      attr_writer :routes
-
-      # @api private
-      # @since 2.0.0
-      attr_reader :routes
+      include Dry::Configurable
 
-      # @api private
-      # @since 2.0.0
-      attr_writer :resolver
+      # Base configuration is provided so router config can include the `base_url`
+      attr_reader :base_configuration
+      private :base_configuration
 
       # @api private
       # @since 2.0.0
-      def initialize(base_url, routes: DEFAULT_ROUTES)
-        @base_url = base_url
-        @routes = routes
+      def initialize(base_configuration)
+        @base_configuration = base_configuration
       end
 
-      # @api private
-      # @since 2.0.0
-      def resolver
-        @resolver ||= begin
-                        require_relative "../application/routing/resolver"
-                        Application::Routing::Resolver
-                      end
-      end
+      setting :routes_path, default: File.join("config", "routes")
+
+      setting :routes_class_name, default: "Routes"
+
+      setting :resolver, default: Application::Routing::Resolver
 
       # @api private
       # @since 2.0.0
       def options
-        { base_url: @base_url }
+        {base_url: base_configuration.base_url}
       end
 
-      # @api private
-      # @since 2.0.0
-      DEFAULT_ROUTES = File.join("config", "routes")
-      private_constant :DEFAULT_ROUTES
+      private
+
+      def method_missing(name, *args, &block)
+        if config.respond_to?(name)
+          config.public_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