hanami 2.1.0 → 2.2.0.beta1

data/lib/hanami/slice.rb

@@ -101,6 +101,16 @@ module Hanami
         Hanami.app
       end
 
+      # Returns true if the slice is Hanami.app
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      # @since 2.2.0
+      def app?
+        eql?(app)
+      end
+
       # Returns the slice's config.
       #
       # A slice's config is copied from the app config at time of first access.
@@ -189,7 +199,7 @@ module Hanami
       # @api public
       # @since 2.0.0
       def root
-        # Provide a best guess for a root when it is not yet configured.
+        # Provides a best guess for a root when it is not yet configured.
         #
         # This is particularly useful for user-defined slice classes that access `settings` inside
         # the class body (since the root needed to find the settings file). In this case,
@@ -203,6 +213,16 @@ module Hanami
         config.root || app.root.join(SLICES_DIR, slice_name.to_s)
       end
 
+      # Returns the slice's root component directory, accounting for App as a special case.
+      #
+      # @return [Pathname]
+      #
+      # @api public
+      # @since 2.2.0
+      def source_path
+        app? ? root.join(APP_DIR) : root
+      end
+
       # Returns the slice's configured inflector.
       #
       # Unless explicitly re-configured for the slice, this will be the app's inflector.
@@ -265,7 +285,7 @@ module Hanami
       #
       # @example
       #   module MySlice
-      #     class Sliice < Hanami::Slice
+      #     class Slice < Hanami::Slice
       #       prepare_container do |container|
       #         # ...
       #       end
@@ -404,7 +424,7 @@ module Hanami
       #   @param key [String] the component's key
       #   @param object [Object] the object to register as the component
       #
-      # @overload reigster(key, memoize: false, &block)
+      # @overload register(key, memoize: false, &block)
       #   Registers the given block as the component. When the component is resolved, the return
       #   value of the block will be returned.
       #
@@ -422,7 +442,7 @@ module Hanami
       #   @param memoize [Boolean]
       #   @yieldreturn [Object] the object to register as the component
       #
-      # @overload reigster(key, call: true, &block)
+      # @overload register(key, call: true, &block)
       #   Registers the given block as the component. When `call: false` is given, then the block
       #   itself will become the component.
       #
@@ -430,7 +450,7 @@ module Hanami
       #   object for that block will be returned.
       #
       #   @param key [String] the component's key
-      #   @param call [Booelan]
+      #   @param call [Boolean]
       #
       # @return [container]
       #
@@ -493,7 +513,7 @@ module Hanami
       #     namespace. May be an explicit string, or `true` for the namespace to be the provider's
       #     name
       #   @param from [Symbol, nil] the group for an external provider source to use, with the
-      #     provider source name inferred from `name` or passsed explicitly as `source:`
+      #     provider source name inferred from `name` or passed explicitly as `source:`
       #   @param source [Symbol, nil] the name of the external provider source to use, if different
       #     from the value provided as `name`
       #   @param if [Boolean] a boolean-returning expression to determine whether to register the
@@ -507,6 +527,12 @@ module Hanami
         container.register_provider(...)
       end
 
+      # @api public
+      # @since 2.1.0
+      def configure_provider(*args, **kwargs, &block)
+        container.register_provider(*args, **kwargs, from: :hanami, &block)
+      end
+
       # @overload start(provider_name)
       #   Starts a provider.
       #
@@ -559,6 +585,13 @@ module Hanami
         container.key?(...)
       end
 
+      # Required for the slice to act as a provider target
+      # @api public
+      # @since 2.2.0
+      def registered?(...)
+        container.registered?(...)
+      end
+
       # Returns an array of keys for all currently registered components in the container.
       #
       # For a prepared slice, this will be the set of components that have been previously resolved.
@@ -842,6 +875,7 @@ module Hanami
       def prepare_container_base_config
         container.config.name = slice_name.to_sym
         container.config.root = root
+        container.config.provider_registrar = ProviderRegistrar.for_slice(self)
         container.config.provider_dirs = [File.join("config", "providers")]
         container.config.registrations_dir = File.join("config", "registrations")
 
@@ -893,12 +927,29 @@ module Hanami
         # point we're still in the process of preparing.
         if routes
           require_relative "providers/routes"
-          register_provider(:routes, source: Providers::Routes.for_slice(self))
+          register_provider(:routes, source: Providers::Routes)
         end
 
         if assets_dir? && Hanami.bundled?("hanami-assets")
           require_relative "providers/assets"
-          register_provider(:assets, source: Providers::Assets.for_slice(self))
+          register_provider(:assets, source: Providers::Assets)
+        end
+
+        if Hanami.bundled?("hanami-db")
+          # Explicit require here to ensure the provider source registers itself, to allow the user
+          # to configure it within their own concrete provider file.
+          require_relative "providers/db"
+
+          if register_db_provider?
+            # Only register providers if the user hasn't provided their own
+            if !container.providers[:db]
+              register_provider(:db, namespace: true, source: Providers::DB)
+            end
+
+            if !container.providers[:relations]
+              register_provider(:relations, namespace: true, source: Providers::Relations)
+            end
+          end
         end
       end
 
@@ -1028,8 +1079,37 @@ module Hanami
       private_constant :ROUTER_NOT_FOUND_HANDLER
 
       def assets_dir?
-        assets_path = app.eql?(self) ? root.join("app", "assets") : root.join("assets")
-        assets_path.directory?
+        source_path.join("assets").directory?
+      end
+
+      def register_db_provider?
+        concrete_db_provider? ||
+          db_config_dir? ||
+          relations_dir? ||
+          db_source_dir? ||
+          import_db_from_parent?
+      end
+
+      def concrete_db_provider?
+        root.join(CONFIG_DIR, "providers", "db.rb").exist?
+      end
+
+      def db_config_dir?
+        root.join("config", "db").directory?
+      end
+
+      def relations_dir?
+        source_path.join("relations").directory?
+      end
+
+      def db_source_dir?
+        source_path.join("db").directory?
+      end
+
+      def import_db_from_parent?
+        parent &&
+          config.db.import_from_parent &&
+          parent.container.providers[:db]
       end
 
       # rubocop:enable Metrics/AbcSize

data/lib/hanami/version.rb

@@ -7,7 +7,7 @@ module Hanami
   # @api private
   module Version
     # @api public
-    VERSION = "2.1.0"
+    VERSION = "2.2.0.beta1"
 
     # @since 0.9.0
     # @api private

data/lib/hanami/web/rack_logger.rb

@@ -35,8 +35,8 @@ module Hanami
       CONTENT_LENGTH = "CONTENT_LENGTH"
       private_constant :CONTENT_LENGTH
 
-      MILISECOND = "ms"
-      private_constant :MILISECOND
+      MILLISECOND = "ms"
+      private_constant :MILLISECOND
 
       MICROSECOND = "µs"
       private_constant :MICROSECOND
@@ -79,7 +79,7 @@ module Hanami
           end
 
           def accepts_entry_payload?(logger)
-            logger.method(:info).parameters.last.then { |type, _| type == :keyrest }
+            logger.method(:info).parameters.any? { |(type, _)| type == :keyrest }
           end
         end
 

data/lib/hanami.rb

@@ -17,6 +17,9 @@ module Hanami
   # @since 2.0.0
   def self.loader
     @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
+      loader.inflector.inflect "db" => "DB"
+      loader.inflector.inflect "db_logging" => "DBLogging"
+      loader.inflector.inflect "sql_adapter" => "SQLAdapter"
       loader.ignore(
         "#{loader.dirs.first}/hanami/{constants,boot,errors,extensions/router/errors,prepare,rake_tasks,setup}.rb"
       )

data/spec/integration/container/provider_environment_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+RSpec.describe "Container / Provider environment", :app_integration do
+  let!(:app) {
+    module TestApp
+      class App < Hanami::App
+        class << self
+          attr_accessor :test_provider_target
+        end
+      end
+    end
+
+    before_prepare if respond_to?(:before_prepare)
+
+    Hanami.app.prepare
+    Hanami.app
+  }
+
+  context "app provider" do
+    before do
+      Hanami.app.register_provider :test_provider, namespace: true do
+        start do
+          Hanami.app.test_provider_target = target
+        end
+      end
+    end
+
+    it "exposes the app as the provider target" do
+      Hanami.app.start :test_provider
+      expect(Hanami.app.test_provider_target).to be Hanami.app
+    end
+  end
+
+  context "slice provider" do
+    def before_prepare
+      Hanami.app.register_slice :main
+    end
+
+    before do
+      Main::Slice.register_provider :test_provider, namespace: true do
+        start do
+          Hanami.app.test_provider_target = target
+        end
+      end
+    end
+
+    it "exposes the slice as the provider target" do
+      Main::Slice.start :test_provider
+      expect(Hanami.app.test_provider_target).to be Main::Slice
+    end
+  end
+end

data/spec/integration/db/auto_registration_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / auto-registration", :app_integration do
+  before do
+    @env = ENV.to_h
+    allow(Hanami::Env).to receive(:loaded?).and_return(false)
+  end
+
+  after do
+    ENV.replace(@env)
+  end
+
+  it "does not auto-register files in entities/, structs/, or db/" do
+    with_tmp_directory(@dir = Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/db/changesets/update_posts.rb", ""
+      write "app/entities/post.rb", ""
+      write "app/structs/post.rb", ""
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/boot"
+
+      expect(Hanami.app.keys).not_to include(*[
+        "db.changesets.update_posts",
+        "entities.post",
+        "structs.post"
+      ])
+    end
+  end
+end

data/spec/integration/db/db_inflector_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "dry/system"
+
+RSpec.describe "ROM::Inflector", :app_integration do
+  before do
+    @env = ENV.to_h
+    allow(Hanami::Env).to receive(:loaded?).and_return(false)
+  end
+
+  after do
+    ENV.replace(@env)
+  end
+
+  around :each do |example|
+    inflector = ROM::Inflector
+    ROM.instance_eval {
+      remove_const :Inflector
+      const_set :Inflector, Dry::Inflector.new
+    }
+    example.run
+  ensure
+    ROM.instance_eval {
+      remove_const :Inflector
+      const_set :Inflector, inflector
+    }
+  end
+
+  it "replaces ROM::Inflector with the Hanami inflector" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/relations/posts.rb", <<~RUBY
+        module TestApp
+          module Relations
+            class Posts < Hanami::DB::Relation
+              schema :posts, infer: true
+            end
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      expect { Hanami.app.prepare :db }.to change { ROM::Inflector == Hanami.app["inflector"] }.from(false).to(true)
+    end
+  end
+end