hanami 2.1.1 → 2.2.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 190712bdfa529ad5769aa5effd9335e436b067cd91b6a109a3aa9a4718a73507
-  data.tar.gz: 353ccb232425a07133e981d5d8ae6c6906f49cb48d38d7f2b55dc4e28a9c797b
+  metadata.gz: 6d6bd309aaaf86dce283f25dbdf786db6da76567ae8b00aed92c34de637f8909
+  data.tar.gz: 3b6430d47afb052bdc4df9ce200ceb3b2888b733b040bdb4de056052a8e99db2
 SHA512:
-  metadata.gz: 4a4e7e1885c9b3eb494863b63f4d376739d6736764b435b83ce75e9a1bb68340681a26bea3883ed20c679e4d88bf99b3d487ae40e2e80f0fb15adb99acfa561d
-  data.tar.gz: 8fe1a9d8f9f7372d67ee3f7b9c6e55b0e1aa59acbaee7264028d876dd5cd7b586f147ae08cd268d67c923d5028344bf37868d190cd2d56229932db56828dcce1
+  metadata.gz: a73cfea60952ba798fe2d04b2cf430996f8b81960959054251e4277b9f0a53aadfdad23850d389fcedcdb3f77a0855acd2e128e5d8aa3cc8a82df485ae11d592
+  data.tar.gz: 05a033e21dd6b9499b125583de931a39f128828ef5f8d730c7ef1522db765ffef35eb1938013b8f58d1199d68aa8564d5183a726bb733e4d1c5b1aaae9f79f7f

data/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 The web, with simplicity.
 
+## v2.2.0.beta2 - 2024-09-26
+
+### Added
+
+- [Tim Riley] Support multiple gateways within each slice's `:db` provider (#1452)
+- [Tim Riley] Register ROM commands and mappers in `db/commands/` and `db/mappers/`. Support registration of components from deeply nested files within these directories. (#1448)
+- [Adam Lassek, Tim Riley] Make `slice` available inside providers (as an alias for `target`) (#1446)
+
+### Changed
+
+- [Tim Riley] Register deeply nested relation files with ROM (#1448)
+- [Kyle Plump] Raise helpful error when preparing `:db` provider if the relevant driver gem for the configured database type is not installed (#1453)
+- [Sean Collins] Remove "disabled" attribute on the `<option>` generated via the `select` helper's `prompt:`, so it shows properly on the select box in the browser (#1444)
+
+## v2.2.0.beta1 - 2024-07-16
+
+### Added
+
+- [Tim Riley, Adam Lassek] Introduce database layer
+- [Adam Lassek] Add `Hanami::Slice.app?`, returning false for slices and true for the app (#1399)
+- [Tim Riley] Add `Slice#registered?`, an additional method delegating to the internal container. Returns true only if a component is already registered for the given, without triggering lazy loading (#1382)
+
+### Changed
+
+- [Tim Riley] `target` inside providers is now the slice itself, instead of the slice's internal container (#1382)
+- Drop support for Ruby 3.0
+
+### Fixed
+
+- [Damian C. Rossney] Allow form `label` helper to receive a symbol (#1423)
+- [Damian C. Rossney] Fix invalid input names generated when using form `fields_for_collection` helper (#1421)
+- [Tim Riley] Fix dry-logger compatibility check for versions of dry-logger >= 1.0.4 (#1384)
+
 ## v2.1.1 - 2024-05-12
 
 ### Fixed

data/README.md

@@ -4,7 +4,7 @@ The web, with simplicity.
 
 ## Version
 
-**This branch contains the code for `hanami` 2.0.x.**
+**This branch contains the code for `hanami`: 2.2**
 
 ## Frameworks
 
@@ -14,9 +14,8 @@ This repository is for the full-stack framework, which provides the glue that ti
 
 * [**Hanami::Router**](https://github.com/hanami/router) - Rack compatible HTTP router for Ruby
 * [**Hanami::Controller**](https://github.com/hanami/controller) - Full featured, fast and testable actions for Rack
+* [**Hanami::Validations**](https://github.com/hanami/validations) - Parameter validations & coercion for actions
 * [**Hanami::View**](https://github.com/hanami/view) - Presentation with a separation between views and templates
-* [**Hanami::Helpers**](https://github.com/hanami/helpers) - View helpers for Ruby applications
-* [**Hanami::Mailer**](https://github.com/hanami/mailer) - Mail for Ruby applications
 * [**Hanami::Assets**](https://github.com/hanami/assets) - Assets management for Ruby
 
 These components are designed to be used independently or together in a Hanami application.
@@ -24,12 +23,13 @@ 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=main)](https://github.com/hanami/hanami/actions?query=workflow%3Aci+branch%3Amain)
+[![CI](https://github.com/hanami/hanami/actions/workflows/ci.yml/badge.svg)](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)
 
 ## Installation
 
-__Hanami__ supports Ruby (MRI) 3.0+
+__Hanami__ supports Ruby (MRI) 3.1+.
 
 ```shell
 gem install hanami
@@ -110,7 +110,7 @@ $ bundle exec rspec path/to/spec.rb
 
 ### Development Requirements
 
-  * Ruby >= 3.0
+  * Ruby >= 3.1
   * Bundler
   * Node.js (MacOS)
 
@@ -120,4 +120,4 @@ __Hanami__ uses [Semantic Versioning 2.0.0](http://semver.org)
 
 ## Copyright
 
-Copyright © 2014 Hanami Team – Released under MIT License.
+Copyright © 2014–2024 Hanami Team – Released under MIT License.

data/hanami.gemspec

@@ -27,19 +27,19 @@ Gem::Specification.new do |spec|
   spec.test_files    = Dir["spec/**/*"]
   spec.require_paths = ["lib"]
   spec.metadata["rubygems_mfa_required"] = "true"
-  spec.required_ruby_version = ">= 3.0"
+  spec.required_ruby_version = ">= 3.1"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.add_dependency "bundler",          ">= 1.16", "< 3"
-  spec.add_dependency "dry-configurable", "~> 1.0", "< 2"
+  spec.add_dependency "dry-configurable", "~> 1.0", ">= 1.2.0", "< 2"
   spec.add_dependency "dry-core",         "~> 1.0", "< 2"
-  spec.add_dependency "dry-inflector",    "~> 1.0", "< 2"
+  spec.add_dependency "dry-inflector",    "~> 1.0", ">= 1.1.0", "< 2"
   spec.add_dependency "dry-monitor",      "~> 1.0", ">= 1.0.1", "< 2"
-  spec.add_dependency "dry-system",       "~> 1.0", "< 2"
+  spec.add_dependency "dry-system",       "= 1.1.0.beta2"
   spec.add_dependency "dry-logger",       "~> 1.0", "< 2"
-  spec.add_dependency "hanami-cli",       "~> 2.1"
-  spec.add_dependency "hanami-utils",     "~> 2.1"
+  spec.add_dependency "hanami-cli",       "= 2.2.0.beta2"
+  spec.add_dependency "hanami-utils",     "~> 2.2.beta"
   spec.add_dependency "zeitwerk",         "~> 2.6"
 
   spec.add_development_dependency "rspec",     "~> 3.8"

data/lib/hanami/app.rb

@@ -152,7 +152,7 @@ module Hanami
         register_provider(:inflector, source: Hanami::Providers::Inflector)
 
         # Allow logger to be replaced by users with a manual provider, for advanced cases
-        unless container.providers.find_and_load_provider(:logger)
+        unless container.providers[:logger]
           require_relative "providers/logger"
           register_provider(:logger, source: Hanami::Providers::Logger)
         end
@@ -161,6 +161,10 @@ module Hanami
           require_relative "providers/rack"
           register_provider(:rack, source: Hanami::Providers::Rack, namespace: true)
         end
+
+        if Hanami.bundled?("hanami-db")
+          register_provider(:db_logging, source: Hanami::Providers::DBLogging)
+        end
       end
 
       def prepare_autoloader

data/lib/hanami/config/db.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  class Config
+    # Hanami DB config
+    #
+    # @since 2.2.0
+    # @api public
+    class DB
+      include Dry::Configurable
+
+      setting :configure_from_parent, default: true
+
+      setting :import_from_parent, default: false
+
+      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

data/lib/hanami/config.rb

@@ -110,7 +110,12 @@ module Hanami
     #
     #   @api public
     #   @since 2.0.0
-    setting :no_auto_register_paths, default: %w[entities]
+    setting :no_auto_register_paths, default: [
+      "db",
+      "entities",
+      "relations",
+      "structs"
+    ]
 
     # @!attribute [rw] base_url
     #   Sets the base URL for app's web server.
@@ -216,6 +221,20 @@ module Hanami
     # @since 2.0.0
     attr_reader :actions
 
+    # Returns the app's db config, or a null config if hanami-db is not bundled.
+    #
+    # @example When hanami-db is bundled
+    #   config.db.import_from_parent # => false
+    #
+    # @example When hanami-db is not bundle
+    #   config.db.import_from_parent # => NoMethodError
+    #
+    # @return [Hanami::Config::DB, Hanami::Config::NullConfig]
+    #
+    # @api public
+    # @since 2.2.0
+    attr_reader :db
+
     # Returns the app's middleware stack, or nil if hanami-router is not bundled.
     #
     # Use this to configure middleware that should apply to all routes.
@@ -288,16 +307,27 @@ module Hanami
       self.render_detailed_errors = (env == :development)
       load_from_env
 
-      @logger = Config::Logger.new(env: env, app_name: app_name)
 
       @actions = load_dependent_config("hanami-controller") {
         require_relative "config/actions"
         Actions.new
       }
 
+      @assets = load_dependent_config("hanami-assets") {
+        require_relative "config/assets"
+        Hanami::Config::Assets.new
+      }
+
+      @db = load_dependent_config("hanami-db") { DB.new }
+
+      @logger = Config::Logger.new(env: env, app_name: app_name)
+
+      @middleware = load_dependent_config("hanami-router") {
+        Slice::Routing::Middleware::Stack.new
+      }
+
       @router = load_dependent_config("hanami-router") {
         require_relative "config/router"
-        @middleware = Slice::Routing::Middleware::Stack.new
         Router.new(self)
       }
 
@@ -306,11 +336,6 @@ module Hanami
         Views.new
       }
 
-      @assets = load_dependent_config("hanami-assets") {
-        require_relative "config/assets"
-        Hanami::Config::Assets.new
-      }
-
       yield self if block_given?
     end
     # rubocop:enable Metrics/AbcSize
@@ -321,8 +346,10 @@ module Hanami
 
       @app_name = app_name.dup
 
-      @assets = source.assets.dup
       @actions = source.actions.dup
+      @assets = source.assets.dup
+      @db = source.db.dup
+      @logger = source.logger.dup
       @middleware = source.middleware.dup
       @router = source.router.dup.tap do |router|
         router.instance_variable_set(:@base_config, self)

data/lib/hanami/constants.rb

@@ -52,4 +52,8 @@ module Hanami
   # @api private
   RB_EXT = ".rb"
   private_constant :RB_EXT
+
+  # @api private
+  RB_EXT_REGEXP = %r{.rb$}
+  private_constant :RB_EXT_REGEXP
 end

data/lib/hanami/extensions/db/repo.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "hanami/db"
+
+module Hanami
+  module Extensions
+    # @api private
+    # @since 2.2.0
+    module DB
+      # @api private
+      # @since 2.2.0
+      module Repo
+        def self.included(repo_class)
+          super
+
+          repo_class.extend(Hanami::SliceConfigurable)
+          repo_class.extend(ClassMethods)
+        end
+
+        # @api private
+        # @since 2.2.0
+        module ClassMethods
+          def configure_for_slice(slice)
+            extend SliceConfiguredRepo.new(slice)
+          end
+        end
+      end
+
+      # @api private
+      # @since 2.2.0
+      class SliceConfiguredRepo < Module
+        attr_reader :slice
+
+        def initialize(slice)
+          super()
+          @slice = slice
+        end
+
+        def extended(repo_class)
+          define_inherited
+          configure_repo(repo_class)
+          define_new
+        end
+
+        def inspect
+          "#<#{self.class.name}[#{slice.name}]>"
+        end
+
+        private
+
+        def define_inherited
+          root_for_repo_class = method(:root_for_repo_class)
+
+          define_method(:inherited) do |subclass|
+            super(subclass)
+
+            unless subclass.root
+              root = root_for_repo_class.(subclass)
+              subclass.root root if root
+            end
+          end
+        end
+
+        def configure_repo(repo_class)
+          repo_class.struct_namespace struct_namespace
+        end
+
+        def define_new
+          resolve_rom = method(:resolve_rom)
+
+          define_method(:new) do |**kwargs|
+            super(container: kwargs.fetch(:container) { resolve_rom.() })
+          end
+        end
+
+        def resolve_rom
+          slice["db.rom"]
+        end
+
+        def root_for_repo_class(repo_class)
+          return unless repo_class.to_s.end_with?("Repo")
+
+          slice.inflector.demodulize(repo_class)
+            .then { slice.inflector.underscore(_1) }
+            .then { _1.gsub(/_repo$/, "") }
+            .then { slice.inflector.pluralize(_1) }
+            .then { _1.to_sym }
+        end
+
+        def struct_namespace
+          @struct_namespace ||=
+            if slice.namespace.const_defined?(:Structs)
+              slice.namespace.const_get(:Structs)
+            else
+              slice.namespace.const_set(:Structs, Module.new)
+            end
+        end
+      end
+    end
+  end
+end
+
+Hanami::DB::Repo.include(Hanami::Extensions::DB::Repo)

data/lib/hanami/extensions.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+if Hanami.bundled?("hanami-db")
+  require_relative "extensions/db/repo"
+end
+
 if Hanami.bundled?("hanami-controller")
   require_relative "extensions/action"
 end

data/lib/hanami/helpers/form_helper/form_builder.rb

@@ -226,10 +226,8 @@ module Hanami
         # @api public
         # @since 2.1.0
         def fields_for_collection(name, &block)
-          collection_base_name = [base_name, name.to_s].compact.join(INPUT_NAME_SEPARATOR)
-
           _value(name).each_with_index do |value, index|
-            fields_for("#{collection_base_name}.#{index}", index, value, &block)
+            fields_for("#{name}.#{index}", index, value, &block)
           end
         end
 
@@ -295,7 +293,7 @@ module Hanami
           attributes[:for] = _input_id(attributes[:for] || content)
 
           if content && !for_attribute_given
-            content = inflector.humanize(content.split(INPUT_NAME_SEPARATOR).last)
+            content = inflector.humanize(content.to_s.split(INPUT_NAME_SEPARATOR).last)
           end
 
           tag.label(content, **attributes, &block)
@@ -940,7 +938,7 @@ module Hanami
         #
         #   =>
         #   <select name="book[store]" id="book-store" class="form-control">
-        #     <option disabled="disabled">Select a store</option>
+        #     <option>Select a store</option>
         #     <option value="it">Italy</option>
         #     <option value="au">Australia</option>
         #   </select>
@@ -997,7 +995,7 @@ module Hanami
           input_value = _value(name)
 
           option_tags = []
-          option_tags << tag.option(prompt, disabled: true) if prompt
+          option_tags << tag.option(prompt) if prompt
 
           already_selected = nil
           values.each do |content, value|

data/lib/hanami/provider/source.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Provider
+    class Source < Dry::System::Provider::Source
+      attr_reader :slice
+
+      def initialize(slice:, **options, &block)
+        @slice = slice
+        super(**options, &block)
+      end
+
+      def target_container = slice
+    end
+  end
+end

data/lib/hanami/provider_registrar.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 2.2.0
+module Hanami
+  class ProviderRegistrar < Dry::System::ProviderRegistrar
+    def self.for_slice(slice)
+      Class.new(self) do
+        define_singleton_method(:new) do |container|
+          super(container, slice)
+        end
+      end
+    end
+
+    attr_reader :slice
+
+    def initialize(container, slice)
+      super(container)
+      @slice = slice
+    end
+
+    def provider_source_class = Hanami::Provider::Source
+
+    def provider_source_options
+      {slice: slice}
+    end
+  end
+end

data/lib/hanami/providers/assets.rb

@@ -9,19 +9,7 @@ module Hanami
     #
     # @api private
     # @since 2.0.0
-    class Assets < Dry::System::Provider::Source
-      # @api private
-      def self.for_slice(slice)
-        Class.new(self) do |klass|
-          klass.instance_variable_set(:@slice, slice)
-        end
-      end
-
-      # @api private
-      def self.slice
-        @slice || Hanami.app
-      end
-
+    class Assets < Hanami::Provider::Source
       # @api private
       def prepare
         require "hanami/assets"
@@ -29,18 +17,12 @@ module Hanami
 
       # @api private
       def start
-        root = slice.app.root.join("public", "assets", Hanami::Assets.public_assets_dir(slice).to_s)
+        root = slice.app.root.join("public", "assets", Hanami::Assets.public_assets_dir(target).to_s)
 
         assets = Hanami::Assets.new(config: slice.config.assets, root: root)
 
         register(:assets, assets)
       end
-
-      private
-
-      def slice
-        self.class.slice
-      end
     end
   end
 end

data/lib/hanami/providers/db/adapter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Adapter
+        include Dry::Configurable
+
+        # @api public
+        # @since 2.2.0
+        setting :plugins, mutable: true
+
+        # @api private
+        def initialize(...)
+          @skip_defaults = Hash.new(false)
+        end
+
+        # @api public
+        # @since 2.2.0
+        def skip_defaults(setting_name = nil)
+          @skip_defaults[setting_name] = true
+        end
+
+        # @api private
+        private def skip_defaults?(setting_name = nil)
+          @skip_defaults[setting_name]
+        end
+
+        # @api private
+        def configure_from_adapter(other_adapter)
+          return if skip_defaults?
+
+          plugins.concat(other_adapter.plugins).uniq! unless skip_defaults?(:plugins)
+        end
+
+        # @api private
+        def configure_for_database(database_url)
+        end
+
+        # @api public
+        # @since 2.2.0
+        def plugin(**plugin_spec, &config_block)
+          plugins << [plugin_spec, config_block]
+        end
+
+        # @api public
+        # @since 2.2.0
+        def plugins
+          config.plugins ||= []
+        end
+
+        # @api private
+        def gateway_cache_keys
+          gateway_options
+        end
+
+        # @api private
+        def gateway_options
+          {}
+        end
+
+        # @api public
+        # @since 2.2.0
+        def clear
+          config.plugins = nil
+          self
+        end
+      end
+    end
+  end
+end

data/lib/hanami/providers/db/adapters.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Providers
+    class DB < Hanami::Provider::Source
+      # @api public
+      # @since 2.2.0
+      class Adapters
+        # @api private
+        # @since 2.2.0
+        ADAPTER_CLASSES = Hash.new(Adapter).update(
+          sql: SQLAdapter
+        ).freeze
+        private_constant :ADAPTER_CLASSES
+
+        extend Forwardable
+
+        def_delegators :adapters, :[], :[]=, :each, :to_h
+
+        # @api private
+        # @since 2.2.0
+        def self.new_adapter(name)
+          ADAPTER_CLASSES[name].new
+        end
+
+        # @api private
+        # @since 2.2.0
+        attr_reader :adapters
+
+        # @api private
+        # @since 2.2.0
+        def initialize
+          @adapters = Hash.new do |hsh, key|
+            hsh[key] = self.class.new_adapter(key)
+          end
+        end
+
+        # @api private
+        # @since 2.2.0
+        def initialize_copy(source)
+          @adapters = source.adapters.dup
+
+          source.adapters.each do |key, val|
+            @adapters[key] = val.dup
+          end
+        end
+      end
+    end
+  end
+end