hanami 2.1.1 → 2.2.0.beta2

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.
@@ -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.
@@ -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.1"
+    VERSION = "2.2.0.beta2"
 
     # @since 0.9.0
     # @api private

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/commands_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Commands", :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 "registers custom commands" do
+    with_tmp_directory(@dir = Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File::NULL
+          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
+
+      write "app/db/commands/nested/create_post_with_default_title.rb", <<~RUBY
+        module TestApp
+          module DB
+            module Commands
+              module Nested
+                class CreatePostWithDefaultTitle < ROM::SQL::Commands::Create
+                  relation :posts
+                  register_as :create_with_default_title
+                  result :one
+
+                  before :set_title
+
+                  def set_title(tuple, *)
+                    tuple[:title] ||= "Default title from command"
+                    tuple
+                  end
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      Hanami.app.prepare :db
+
+      # Manually run a migration and add a test record
+      gateway = TestApp::App["db.gateway"]
+      migration = gateway.migration do
+        change do
+          create_table :posts do
+            primary_key :id
+            column :title, :text, null: false
+          end
+        end
+      end
+      migration.apply(gateway, :up)
+
+      post = TestApp::App["relations.posts"].command(:create_with_default_title).call({})
+      expect(post[:title]).to eq "Default title from command"
+    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