hanami 2.0.0.alpha5 → 2.0.0.alpha7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c8875d3320057cffe3af1a7bb2ff781cd8ad2145c446fc9e9190d344a4a48e6
-  data.tar.gz: c003bc2117815e10f2c15f458fb3bc6d94b480dfe9f2ec98e6458804f8a0d06d
+  metadata.gz: 8db2d523a265dd089048a2a944ccf8b1d5d46a36d496be5638f4807fe3c451ad
+  data.tar.gz: fe510075e1e4d362e6c6419aab0d0b001eb8bf80329d51f7546f9955abf08cf6
 SHA512:
-  metadata.gz: 7b133de3c728132ef6255480b10068482d58cf1e2708df395f00cc5981cdccac70cbecdb2c8325cd822298d7c92c0ee0253ab1f8f9d95ddf84b0d6de556e7f3f
-  data.tar.gz: 42b525e3163e7bb73938b5e2fa444ccc15cc38def3e74225086f0e90bb0d805979e0a88a47703fcc73956d68598260ab366a1c155eb94b7114515b8ffc56671e
+  metadata.gz: 1af19f64f99af6997e772e25d49a5e835ea9e8ebac64aaab637fe56a0c91ea1b87d4a13d04b26145b58573d12478bd435183873e4cf7378e2b2046866e9a0fa4
+  data.tar.gz: d7be6b435ac445a23ceb616180493c863715dca8a039a81e2ab3af0aa49d60f73806625909dbee05aad4b1bab77b7b77fc6c94600f937cbe7e5af206f67efa82

data/CHANGELOG.md

@@ -1,6 +1,147 @@
 # Hanami
 The web, with simplicity.
 
+## v2.0.0.alpha7.1 - 2020-03-09
+
+## Fixed
+- [Tim Riley] Fixed error creating slice classes when the enclosing module did not already exist
+
+## 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:

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
@@ -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.22", ">= 0.22.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/routing/router.rb

@@ -2,7 +2,7 @@
 
 # require "hanami/application/router"
 
-# Hanami.application.register_bootable :router do
+# Hanami.application.register_provider :router do
 #   start do
 #     configuration = Hanami.application.configuration
 

data/lib/hanami/application/slice_registrar.rb

@@ -0,0 +1,106 @@
+# 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 # rubocop:disable Lint/SuppressedException
+          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