hanami 2.0.0.alpha4 → 2.0.0.alpha7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2188bc3aee5a164b6610c6bc97fad9f0bba0384bf11a80be27228e7f19dad4e0
-  data.tar.gz: 7fa39987132cf6bfda0b0986a36894d08297c1df06b31354cfbeae934d73a813
+  metadata.gz: d8a7910a3dd4b6e7d82711df4f181de1e8c63fbb91981542d2eb067d2cfe06b4
+  data.tar.gz: 2d09e35743119e1e630f196780df68cf7b7685c2d6e3208fe0c7804816ccb45f
 SHA512:
-  metadata.gz: f7b1aad0186fcdaa94593ba4ff5d01cf4f8d4431aaffba173c3c795c2c0c76993a27da3aa503b0ce59fd67467615c86c50a4ab227986e38dd0986e91c30766a5
-  data.tar.gz: cd2d8b82bc7f98e906686fdab7299282b1c1be4b29278c9ee5b0f9b3cefbb7d31fa83013a840b2b9fa2b8e2b2f3f8c0582ca3587b35ced91f65db6f853d67cf7
+  metadata.gz: 51ecc6d32c036bfc2fae43498ca6f88bb937317e610d24e499a069b02ff4c8a49b253684ba4fe47d6f67e2c2fc2b0a989460fc1462b397ddd1a5ec539ace2b7c
+  data.tar.gz: aa3a1f17f9304605135391c3cb915f61cabbd5cbb2e4351e70be122353d36a85af979bbf4710ffdbfa27e1e77aea023f3de7ddda2b547399e1d96b396134da9c

data/CHANGELOG.md

@@ -1,6 +1,262 @@
 # Hanami
 The web, with simplicity.
 
+## v2.0.0.alpha7 - 2020-03-08
+
+## Added
+- [Tim Riley] Introduced `Hanami::ApplicationLoadError` and `Hanami::SliceLoadError` exceptions to represent errors encountered during application and slice loading.
+- [Tim Riley] `Hanami::Slice.shutdown` can be used to stop all the providers in a slice
+
+## Changed
+- [Tim Riley] Slices are now represented as concrete classes (such as `Main::Slice`) inheriting from `Hanami::Slice`, as opposed to _instances_ of `Hanami::Slice`. You may create your own definitions for these slices in `config/slices/[slice_name].rb`, which you can then use for customising per-slice config and behavior, e.g.
+
+    ```ruby
+    # config/slices/main.rb:
+
+    module Main
+      class Slice < Hanami::Slice
+        # slice config here
+      end
+    end
+    ```
+- [Tim Riley] Application-level `config.slice(slice_name, &block)` setting has been removed in favour of slice configuration within concrete slice class definitions
+- [Tim Riley] You can configure your slice imports inside your slice classes, e.g.
+
+    ```ruby
+    # config/slices/main.rb:
+
+    module Main
+      class Slice < Hanami::Slice
+        # Import all exported components from "search" slice
+        import from: :search
+      end
+    end
+    ```
+- [Tim Riley] You can configure your slice exports inside your slice classes, e.g.
+
+    ```ruby
+    # config/slices/search.rb:
+
+    module Search
+      class Slice < Hanami::Slice
+        # Export the "index_entity" component only
+        export ["index_entity"]
+      end
+    end
+    ```
+- [Tim Riley] For advanced cases, you can configure your slice's container via a `prepare_container` block:
+
+    ```ruby
+    # config/slices/search.rb:
+
+    module Search
+      class Slice < Hanami::Slice
+        prepare_container do |container|
+          # `container` object is available here, with
+          # slice-specific configuration already applied
+        end
+      end
+    end
+    ```
+- [Tim Riley] `Hanami::Application.shutdown` will now also shutdown all registered slices
+
+## v2.0.0.alpha6 - 2022-02-10
+### Added
+- [Luca Guidi] Official support for Ruby: MRI 3.1
+- [Tim Riley] Introduce partial Slice imports and exports. It allows to selectively export a functionality from a slice and import into another.
+
+    Import from `search` slice, uses `search` as the imported key namespace:
+
+    ```ruby
+    # config/application.rb
+
+    module MyApp
+      class Application < Hanami::Application
+        config.slice(:admin) do
+          import(from: :search)
+        end
+      end
+    end
+    ```
+
+    Import from `search` slice with custom namespace:
+
+    ```ruby
+    # config/application.rb
+
+    module MyApp
+      class Application < Hanami::Application
+        config.slice(:admin) do
+          import(from: :search, as: :search_engine)
+        end
+      end
+    end
+    ```
+
+    Import specific keys from `search` slice
+
+    ```ruby
+    # config/application.rb
+
+    module MyApp
+      class Application < Hanami::Application
+        config.slice(:admin) do
+          import(keys: ["run_query"], from: :search)
+        end
+      end
+    end
+    ```
+
+    Export only specific keys from `search` slice, and import them in `admin`
+
+    ```ruby
+    # config/application.rb
+
+    module MyApp
+      class Application < Hanami::Application
+        config.slice(:admin) do
+          import(from: :search)
+        end
+
+        config.slice(:search) do
+          container.config.exports = %w[run_query index_item]
+        end
+      end
+    end
+    ```
+
+### Fixed
+- [Luca Guidi] Ensure request logger to respect logger formatter option.
+
+### Changed
+- [Luca Guidi] Drop support for Ruby: MRI 2.6 and 2.7.
+- [Tim Riley] `Hanami.init` => `Hanami.prepare` and `hanami/init` => `hanami/prepare`
+- [Tim Riley] `Hanami.register_bootable` => `Hanami.register_provider`
+- [Tim Riley] `Hanami.start_bootable` => `Hanami.start`
+- [Tim Riley] `Hanami::Slice#init` => `Hanami::Slice#prepare`
+- [Tim Riley] `Hanami::Slice#register_bootable` => `Hanami::Slice#register_provider`
+- [Tim Riley] `Hanami::Slice#start_bootable` => `Hanami::Slice#start`
+
+## v2.0.0.alpha5 - 2022-01-12
+### Changed
+- [Luca Guidi] Sensible default configuration for application logger, with per-environment defaults:
+
+    The defaults are:
+
+    - In **production**, log for level `info`, send logs to `$stdout` in JSON format without colours
+    - In **development**, log for level `debug`, send logs to `$stdout` in single-line format with colours
+    - In **test**, log for level `debug`, send logs to `log/test.log` in single-line format without colours
+
+    To configure the logger:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.logger.level = :info
+
+        config.logger.stream = $stdout
+        config.logger.stream = "/path/to/file"
+        config.logger.stream = StringIO.new
+
+        config.logger.format = :json
+        config.logger.format = MyCustomFormatter.new
+
+        config.logger.color = false # disable coloring
+        config.logger.color = MyCustomColorizer.new
+
+        config.logger.filters << "secret" # add
+        config.logger.filters += ["yet", "another"] # add
+        config.logger.filters = ["foo"] # replace
+
+        # See https://ruby-doc.org/stdlib/libdoc/logger/rdoc/Logger.html
+        config.logger.options = ["daily"] # time based log rotation
+        config.logger.options = [0, 1048576] # size based log rotation
+      end
+    end
+    ```
+
+    To configure the logger for specific environments:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.environment(:staging) do
+          config.logger.level = :info
+        end
+      end
+    end
+    ```
+
+    To assign a custom replacement logger object:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        config.logger = MyCustomLogger.new
+      end
+    end
+    ```
+- [Tim Riley] Comprehensive `config.source_dirs` setting
+
+    This replaces the previous `component_dir_paths` setting, and contains two nested settings:
+
+    - `config.source_dirs.component_dirs` (backed by `Dry::System::Config::ComponentDirs`), for directories of source files intended to be registered as components
+    - `config.source_dirs.autoload_paths`, for directories of source files not intended for registration as components, but still to be made accessible by the autoloader
+
+    To add and configure your own additional component dirs:
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Adding a simple component dir
+        config.source_dirs.component_dirs.add "serializers"
+
+        # Adding a component dir with custom configuration
+        config.source_dirs.component_dirs.add "serializers" do |dir|
+          dir.auto_register = proc { |component|
+            !component.identifier.start_with?("structs")
+          }
+        end
+      end
+    end
+    ```
+
+    To customize the configuration of the default component dirs ("lib", "actions", "repositories", "views"):
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Customising a default component dir
+        config.source_dirs.component_dirs.dir("lib").auto_register = proc { |component|
+          !component.identifier.start_with?("structs")
+        }
+
+        # Setting default config to apply to all component dirs
+        config.source_dirs.component_dirs.auto_register = proc { |component|
+          !component.identifier.start_with?("entities")
+        }
+
+        # Removing a default component dir
+        config.source_dirs.component_dirs.delete("views")
+      end
+    end
+    ```
+
+    To configure the autoload paths (defaulting to `["entities"]`):
+
+    ```ruby
+    module MyApp
+      class Application < Hanami::Application
+        # Adding your own autoload paths
+        config.source_dirs.autoload_paths << "structs"
+
+        # Or providing a full replacement
+        config.source_dirs.autoload_paths = ["structs"]
+      end
+    end
+    ```
+- [Tim Riley] Application router is lazy loaded (not requiring application to be fully booted) and now available via `Hanami.rack_app` or `Hanami.application.rack_app`, instead of the previous `Hanami.app` (which required the app to be booted first).
+
 ## v2.0.0.alpha4 - 2021-12-07
 ### Added
 - [Luca Guidi] Manage Content Security Policy (CSP) with "zero-defaults" policy. New API to change CSP values and to disable the feature.

data/README.md

@@ -36,7 +36,7 @@ These components are designed to be used independently or together in a Hanami a
 
 ## Installation
 
-__Hanami__ supports Ruby (MRI) 2.6+
+__Hanami__ supports Ruby (MRI) 3.0+
 
 ```shell
 gem install hanami
@@ -58,7 +58,7 @@ You can give back to Open Source, by supporting Hanami development via a [donati
 
 ### Supporters
 
-  * [Trung Lê](https://github.com/joneslee85)
+  * [Trung Lê](https://github.com/runlevel5)
   * [James Carlson](https://github.com/jxxcarlson)
   * [Creditas](https://www.creditas.com.br/)
 
@@ -136,8 +136,4 @@ __Hanami__ uses [Semantic Versioning 2.0.0](http://semver.org)
 
 ## Copyright
 
-Released under MIT License.
-
-This project was formerly known as Lotus (`lotusrb`).
-
-Copyright © 2014-2021 Luca Guidi.
+Copyright © 2014-2022 Hanami Team – Released under MIT License.

data/hanami.gemspec

@@ -4,7 +4,7 @@ lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "hanami/version"
 
-Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
+Gem::Specification.new do |spec|
   spec.name          = "hanami"
   spec.version       = Hanami::VERSION
   spec.authors       = ["Luca Guidi"]
@@ -14,10 +14,11 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.homepage      = "http://hanamirb.org"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -c -o --exclude-standard -z -- lib/* bin/* LICENSE.md README.md CODE_OF_CONDUCT.md CHANGELOG.md FEATURES.md hanami.gemspec`.split("\x0")
+  spec.files         = `git ls-files -c -o --exclude-standard -z -- lib/* bin/* LICENSE.md README.md CODE_OF_CONDUCT.md CHANGELOG.md FEATURES.md hanami.gemspec`.split("\x0") # rubocop:disable Layout/LineLength
   spec.test_files    = spec.files.grep(%r{^(test)/})
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.required_ruby_version = ">= 3.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
@@ -26,7 +27,7 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.add_dependency "dry-core",          "~> 0.4"
   spec.add_dependency "dry-inflector",     "~> 0.2", ">= 0.2.1"
   spec.add_dependency "dry-monitor"
-  spec.add_dependency "dry-system",        "~> 0.19", ">= 0.21.0"
+  spec.add_dependency "dry-system",        "~> 0.23", ">= 0.23.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 → providers}/inflector.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Hanami.application.register_bootable :inflector do
+Hanami.application.register_provider :inflector do
   start do
     register :inflector, Hanami.application.inflector
   end

data/lib/hanami/application/container/{boot → providers}/logger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Hanami.application.register_bootable :logger do
+Hanami.application.register_provider :logger do
   start do
     register :logger, Hanami.application.configuration.logger_instance
   end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+Hanami.application.register_provider :rack_logger do
+  start do
+    require "hanami/web/rack_logger"
+
+    target.start :logger
+    target.start :rack_monitor
+
+    rack_logger = Hanami::Web::RackLogger.new(target[:logger])
+    rack_logger.attach target[:rack_monitor]
+
+    register :rack_logger, rack_logger
+  end
+end

data/lib/hanami/application/container/{boot → providers}/rack_monitor.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-Hanami.application.register_bootable :rack_monitor do |container|
+Hanami.application.register_provider :rack_monitor do
   start do
     require "dry/monitor"
     require "dry/monitor/rack/middleware"
 
-    middleware = Dry::Monitor::Rack::Middleware.new(container[:notifications])
+    middleware = Dry::Monitor::Rack::Middleware.new(target[:notifications])
 
     register :rack_monitor, middleware
   end

data/lib/hanami/application/container/{boot → providers}/routes_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Hanami.application.register_bootable :routes_helper do
+Hanami.application.register_provider :routes_helper do
   start do
     require "hanami/application/routes_helper"
 

data/lib/hanami/application/container/{boot → providers}/settings.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-Hanami.application.register_bootable :settings do
+Hanami.application.register_provider :settings do
   start do
     register :settings, Hanami.application.settings
   end

data/lib/hanami/application/router.rb

@@ -10,8 +10,8 @@ module Hanami
     class Router < ::Hanami::Router
       # @since 2.0.0
       # @api private
-      def initialize(routes:, stack: Routing::Middleware::Stack.new, **kwargs, &blk)
-        @stack = stack
+      def initialize(routes:, middleware_stack: Routing::Middleware::Stack.new, **kwargs, &blk)
+        @middleware_stack = middleware_stack
         instance_eval(&blk)
         super(**kwargs, &routes)
       end
@@ -21,20 +21,20 @@ module Hanami
       def freeze
         return self if frozen?
 
-        remove_instance_variable(:@stack)
+        remove_instance_variable(:@middleware_stack)
         super
       end
 
       # @since 2.0.0
       # @api private
       def use(middleware, *args, &blk)
-        @stack.use(middleware, *args, &blk)
+        @middleware_stack.use(middleware, *args, &blk)
       end
 
       # @since 2.0.0
       # @api private
       def scope(*args, &blk)
-        @stack.with(args.first) do
+        @middleware_stack.with(args.first) do
           super
         end
       end
@@ -50,9 +50,9 @@ module Hanami
       # @since 2.0.0
       # @api private
       def to_rack_app
-        return self if @stack.empty?
+        return self if @middleware_stack.empty?
 
-        @stack.to_rack_app(self)
+        @middleware_stack.to_rack_app(self)
       end
     end
   end

data/lib/hanami/application/routing/router.rb

@@ -0,0 +1,36 @@
+# # frozen_string_literal: true
+
+# require "hanami/application/router"
+
+# Hanami.application.register_provider :router do
+#   start do
+#     configuration = Hanami.application.configuration
+
+#     routes = begin
+#       require File.join(configuration.root, configuration.router.routes_path)
+#       routes_class = Hanami.application.send(:autodiscover_application_constant, configuration.router.routes_class_name) # WIP private
+#       routes_class.routes
+#     rescue LoadError
+#       proc {}
+#     end
+
+#     resolver = configuration.router.resolver.new(
+#       slices: Hanami.application.slices,
+#       inflector: Hanami.application.inflector # TODO: use container[:inflector]?
+#     )
+
+#     router = Hanami::Application::Router.new(
+#       routes: routes,
+#       resolver: resolver,
+#       **configuration.router.options,
+#     ) do
+#       use Hanami.application[:rack_monitor]
+
+#       Hanami.application.config.for_each_middleware do |m, *args, &block|
+#         use(m, *args, &block)
+#       end
+#     end
+
+#     register :router, router
+#   end
+# end

data/lib/hanami/application/slice_registrar.rb

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