hanami 2.0.0.beta1.1 → 2.0.0.beta2

data/spec/new_integration/slices/slice_loading_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "rack/test"
+
+RSpec.describe "Slices / Slice loading", :app_integration, :aggregate_failures do
+  let(:app_modules) { %i[TestApp Admin Editorial Main Shop] }
+
+  describe "loading specific slices with config.slices" do
+    describe "setup app" do
+      it "ignores any explicitly registered slices not included in load_slices" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+                config.slices = %w[admin]
+              end
+            end
+          RUBY
+
+          require "hanami/setup"
+
+          expect { Hanami.app.register_slice :main }.not_to(change { Hanami.app.slices.keys })
+          expect { Main }.to raise_error(NameError)
+
+          expect { Hanami.app.register_slice :admin }.to change { Hanami.app.slices.keys }.to [:admin]
+          expect(Admin::Slice).to be
+        end
+      end
+
+      describe "nested slices" do
+        it "ignores any explicitly registered slices not included in load_slices" do
+          with_tmp_directory(Dir.mktmpdir) do
+            write "config/app.rb", <<~'RUBY'
+              require "hanami"
+
+              module TestApp
+                class App < Hanami::App
+                  config.slices = %w[admin.shop]
+                end
+              end
+            RUBY
+
+            require "hanami/setup"
+
+            expect { Hanami.app.register_slice :admin }.to change { Hanami.app.slices.keys }.to [:admin]
+
+            expect { Admin::Slice.register_slice :editorial }.not_to(change { Admin::Slice.slices.keys })
+            expect { Admin::Slice.register_slice :shop }.to change { Admin::Slice.slices.keys }.to [:shop]
+            expect(Shop::Slice).to be
+          end
+        end
+      end
+    end
+
+    describe "prepared app" do
+      it "loads only the slices included in load_slices" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+                config.slices = %w[admin]
+              end
+            end
+          RUBY
+
+          write "slices/admin/.keep"
+          write "slices/main/.keep"
+
+          require "hanami/prepare"
+
+          expect(Hanami.app.slices.keys).to eq [:admin]
+          expect(Admin::Slice).to be
+          expect { Main }.to raise_error(NameError)
+        end
+      end
+
+      it "ignores unknown slices in load_slices" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+                config.slices = %w[admin meep morp]
+              end
+            end
+          RUBY
+
+          write "slices/admin/.keep"
+          write "slices/main/.keep"
+
+          require "hanami/prepare"
+
+          expect(Hanami.app.slices.keys).to eq [:admin]
+        end
+      end
+
+      describe "nested slices" do
+        it "loads only the dot-delimited nested slices (and their parents) included in load_slices" do
+          with_tmp_directory(Dir.mktmpdir) do
+            write "config/app.rb", <<~'RUBY'
+              require "hanami"
+
+              module TestApp
+                class App < Hanami::App
+                  config.slices = %w[admin.shop]
+                end
+              end
+            RUBY
+
+            write "slices/admin/.keep"
+            write "slices/admin/slices/shop/.keep"
+            write "slices/admin/slices/editorial/.keep"
+            write "slices/main/.keep"
+
+            require "hanami/prepare"
+
+            expect(Hanami.app.slices.keys).to eq [:admin]
+            expect(Admin::Slice.slices.keys).to eq [:shop]
+
+            expect(Admin::Slice).to be
+            expect(Shop::Slice).to be
+
+            expect { Editorial }.to raise_error(NameError)
+            expect { Main }.to raise_error(NameError)
+          end
+        end
+      end
+    end
+  end
+
+  describe "using ENV vars" do
+    before do
+      @orig_env = ENV.to_h
+    end
+
+    after do
+      ENV.replace(@orig_env)
+    end
+
+    it "uses HANAMI_SLICES" do
+      ENV["HANAMI_SLICES"] = "admin"
+
+      with_tmp_directory(Dir.mktmpdir) do
+        write "config/app.rb", <<~'RUBY'
+          require "hanami"
+
+          module TestApp
+            class App < Hanami::App
+            end
+          end
+        RUBY
+
+        write "slices/admin/.keep"
+        write "slices/main/.keep"
+
+        require "hanami/setup"
+
+        expect(Hanami.app.config.slices).to eq %w[admin]
+
+        require "hanami/prepare"
+
+        expect(Hanami.app.slices.keys).to eq [:admin]
+      end
+    end
+  end
+end

data/spec/new_integration/view/context/settings_spec.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require "hanami"
+require "hanami/settings"
 
 RSpec.describe "App view / Context / Settings", :app_integration do
   before do
     module TestApp
       class App < Hanami::App
       end
+
+      class Settings < Hanami::Settings
+      end
     end
 
     Hanami.prepare
@@ -24,7 +28,7 @@ RSpec.describe "App view / Context / Settings", :app_integration do
 
   describe "#settings" do
     it "is the app settings by default" do
-      expect(context.settings).to be TestApp::App.settings
+      expect(context.settings).to be TestApp::App["settings"]
     end
 
     context "injected settings" do

data/spec/new_integration/view/slice_configuration_spec.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+RSpec.describe "App view / Slice configuration", :app_integration do
+  before do
+    with_directory(@dir = make_tmp_directory) do
+      write "config/app.rb", <<~'RUBY'
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/view.rb", <<~'RUBY'
+        require "hanami/view"
+
+        module TestApp
+          class View < Hanami::View
+          end
+        end
+      RUBY
+
+      require "hanami/setup"
+    end
+  end
+
+  def prepare_app
+    with_directory(@dir) { require "hanami/prepare" }
+  end
+
+  describe "inheriting from app-level base class" do
+    describe "app-level base class" do
+      it "applies default views config from the app", :aggregate_failures do
+        prepare_app
+
+        expect(TestApp::View.config.layouts_dir).to eq "layouts"
+        expect(TestApp::View.config.layout).to eq "app"
+      end
+
+      it "applies views config from the app" do
+        Hanami.app.config.views.layout = "app_layout"
+
+        prepare_app
+
+        expect(TestApp::View.config.layout).to eq "app_layout"
+      end
+
+      it "does not override config in the base class" do
+        Hanami.app.config.views.layout = "app_layout"
+
+        prepare_app
+
+        TestApp::View.config.layout = "custom_layout"
+
+        expect(TestApp::View.config.layout).to eq "custom_layout"
+      end
+    end
+
+    describe "subclass in app" do
+      before do
+        with_directory(@dir) do
+          write "app/views/articles/index.rb", <<~'RUBY'
+            module TestApp
+              module Views
+                module Articles
+                  class Index < TestApp::View
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+      end
+
+      it "applies default views config from the app", :aggregate_failures do
+        prepare_app
+
+        expect(TestApp::Views::Articles::Index.config.layouts_dir).to eq "layouts"
+        expect(TestApp::Views::Articles::Index.config.layout).to eq "app"
+      end
+
+      it "applies views config from the app" do
+        Hanami.app.config.views.layout = "app_layout"
+
+        prepare_app
+
+        expect(TestApp::Views::Articles::Index.config.layout).to eq "app_layout"
+      end
+
+      it "applies config from the base class" do
+        prepare_app
+
+        TestApp::View.config.layout = "base_class_layout"
+
+        expect(TestApp::Views::Articles::Index.config.layout).to eq "base_class_layout"
+      end
+    end
+
+    describe "subclass in slice" do
+      before do
+        with_directory(@dir) do
+          write "slices/admin/views/articles/index.rb", <<~'RUBY'
+            module Admin
+              module Views
+                module Articles
+                  class Index < TestApp::View
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+      end
+
+      it "applies default views config from the app", :aggregate_failures do
+        prepare_app
+
+        expect(Admin::Views::Articles::Index.config.layouts_dir).to eq "layouts"
+        expect(Admin::Views::Articles::Index.config.layout).to eq "app"
+      end
+
+      it "applies views config from the app" do
+        Hanami.app.config.views.layout = "app_layout"
+
+        prepare_app
+
+        expect(Admin::Views::Articles::Index.config.layout).to eq "app_layout"
+      end
+
+      it "applies config from the base class" do
+        prepare_app
+
+        TestApp::View.config.layout = "base_class_layout"
+
+        expect(Admin::Views::Articles::Index.config.layout).to eq "base_class_layout"
+      end
+    end
+  end
+
+  describe "inheriting from a slice-level base class, in turn inheriting from an app-level base class" do
+    before do
+      with_directory(@dir) do
+        write "slices/admin/view.rb", <<~'RUBY'
+          module Admin
+            class View < TestApp::View
+            end
+          end
+        RUBY
+      end
+    end
+
+    describe "slice-level base class" do
+      it "applies default views config from the app", :aggregate_failures do
+        prepare_app
+
+        expect(Admin::View.config.layouts_dir).to eq "layouts"
+        expect(Admin::View.config.layout).to eq "app"
+      end
+
+      it "applies views config from the app" do
+        Hanami.app.config.views.layout = "app_layout"
+
+        prepare_app
+
+        expect(Admin::View.config.layout).to eq "app_layout"
+      end
+
+      it "applies config from the app base class" do
+        prepare_app
+
+        TestApp::View.config.layout = "app_base_class_layout"
+
+        expect(Admin::View.config.layout).to eq "app_base_class_layout"
+      end
+
+      context "slice views config present" do
+        before do
+          with_directory(@dir) do
+            write "config/slices/admin.rb", <<~'RUBY'
+              module Admin
+                class Slice < Hanami::Slice
+                  config.views.layout = "slice_layout"
+                end
+              end
+            RUBY
+          end
+        end
+
+        it "applies views config from the slice" do
+          prepare_app
+
+          expect(Admin::View.config.layout).to eq "slice_layout"
+        end
+
+        it "prefers views config from the slice over config from the app-level base class" do
+          prepare_app
+
+          TestApp::View.config.layout = "app_base_class_layout"
+
+          expect(Admin::View.config.layout).to eq "slice_layout"
+        end
+
+        it "prefers config from the base class over views config from the slice" do
+          prepare_app
+
+          TestApp::View.config.layout = "app_base_class_layout"
+          Admin::View.config.layout = "slice_base_class_layout"
+
+          expect(Admin::View.config.layout).to eq "slice_base_class_layout"
+        end
+      end
+    end
+
+    describe "subclass in slice" do
+      before do
+        with_directory(@dir) do
+          write "slices/admin/views/articles/index.rb", <<~'RUBY'
+            module Admin
+              module Views
+                module Articles
+                  class Index < Admin::View
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+      end
+
+      it "applies default views config from the app", :aggregate_failures do
+        prepare_app
+
+        expect(Admin::Views::Articles::Index.config.layouts_dir).to eq "layouts"
+        expect(Admin::Views::Articles::Index.config.layout).to eq "app"
+      end
+
+      it "applies views config from the app" do
+        Hanami.app.config.views.layout = "app_layout"
+
+        prepare_app
+
+        expect(Admin::Views::Articles::Index.config.layout).to eq "app_layout"
+      end
+
+      it "applies views config from the slice" do
+        with_directory(@dir) do
+          write "config/slices/admin.rb", <<~'RUBY'
+            module Admin
+              class Slice < Hanami::Slice
+                config.views.layout = "slice_layout"
+              end
+            end
+          RUBY
+        end
+
+        prepare_app
+
+        expect(Admin::Views::Articles::Index.config.layout).to eq "slice_layout"
+      end
+
+      it "applies config from the slice base class" do
+        prepare_app
+
+        Admin::View.config.layout = "slice_base_class_layout"
+
+        expect(Admin::Views::Articles::Index.config.layout).to eq "slice_base_class_layout"
+      end
+
+      it "prefers config from the slice base class over views config from the slice" do
+        with_directory(@dir) do
+          write "config/slices/admin.rb", <<~'RUBY'
+            module Admin
+              class Slice < Hanami::Slice
+                config.views.layout = "slice_layout"
+              end
+            end
+          RUBY
+        end
+
+        prepare_app
+
+        Admin::View.config.layout = "slice_base_class_layout"
+
+        expect(Admin::Views::Articles::Index.config.layout).to eq "slice_base_class_layout"
+      end
+    end
+  end
+end

data/spec/support/app_integration.rb

@@ -20,7 +20,7 @@ module RSpec
 end
 
 RSpec.shared_context "Application integration" do
-  let(:application_modules) { %i[TestApp Admin Main Search] }
+  let(:app_modules) { %i[TestApp Admin Main Search] }
 end
 
 RSpec.configure do |config|
@@ -52,9 +52,8 @@ RSpec.configure do |config|
     Zeitwerk::ExplicitNamespace.cpaths.clear
     Zeitwerk::ExplicitNamespace.tracer.disable
 
-    if Hanami.instance_variable_defined?(:@_app)
-      Hanami.remove_instance_variable(:@_app)
-    end
+    Hanami.instance_variable_set(:@_bundled, {})
+    Hanami.remove_instance_variable(:@_app) if Hanami.instance_variable_defined?(:@_app)
 
     $LOAD_PATH.replace(@load_paths)
 
@@ -68,7 +67,7 @@ RSpec.configure do |config|
     }
     $LOADED_FEATURES.replace(@loaded_features + new_features_to_keep)
 
-    application_modules.each do |app_module_name|
+    app_modules.each do |app_module_name|
       next unless Object.const_defined?(app_module_name)
 
       Object.const_get(app_module_name).tap do |mod|

data/spec/unit/hanami/configuration/slices_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "hanami/configuration"
+require "hanami/slice_name"
+
+RSpec.describe Hanami::Configuration, "#slices" do
+  subject(:config) { described_class.new(app_name: app_name, env: :development) }
+  let(:app_name) { Hanami::SliceName.new(double(name: "MyApp::App"), inflector: Dry::Inflector.new) }
+
+  subject(:slices) { config.slices }
+
+  before do
+    @orig_env = ENV.to_h
+  end
+
+  after do
+    ENV.replace(@orig_env)
+  end
+
+  it "is nil by default" do
+    is_expected.to be nil
+  end
+
+  it "defaults to the HANAMI_LOAD_SLICES env var, separated by commas" do
+    ENV["HANAMI_SLICES"] = "main,admin"
+    is_expected.to eq %w[main admin]
+  end
+
+  it "strips spaces from HANAMI_LOAD_SLICES env var entries" do
+    ENV["HANAMI_SLICES"] = "main, admin"
+    is_expected.to eq %w[main admin]
+  end
+end

data/spec/unit/hanami/settings/env_store_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "hanami/settings/env_store"
+
+RSpec.describe Hanami::Settings::EnvStore do
+  it "defaults to using ENV as the store" do
+    orig_env = ENV.to_h
+
+    ENV["FOO"] = "bar"
+    expect(described_class.new.fetch("FOO")).to eq "bar"
+
+    ENV.replace(orig_env)
+  end
+
+  describe "#fetch" do
+    it "fetches from ENV" do
+      store = described_class.new(store: {"FOO" => "bar"})
+
+      expect(store.fetch("FOO")).to eq("bar")
+    end
+
+    it "capitalizes name" do
+      store = described_class.new(store: {"FOO" => "bar"})
+
+      expect(store.fetch("foo")).to eq("bar")
+    end
+
+    it "coerces name to string" do
+      store = described_class.new(store: {"FOO" => "bar"})
+
+      expect(store.fetch(:foo)).to eq("bar")
+    end
+
+    it "returns default when value is not found" do
+      store = described_class.new(store: {"FOO" => "bar"})
+
+      expect(store.fetch("BAZ", "qux")).to eq("qux")
+    end
+
+    it "returns the block execution when value is not found" do
+      store = described_class.new(store: {"FOO" => "bar"})
+
+      expect(store.fetch("BAZ") { "qux" }).to eq("qux") # rubocop:disable Style/RedundantFetchBlock
+    end
+
+    it "raises KeyError when value is not found and no default is given" do
+      store = described_class.new(store: {"FOO" => "bar"})
+
+      expect { store.fetch("BAZ") }.to raise_error(KeyError)
+    end
+  end
+end

data/spec/unit/hanami/slice_configurable_spec.rb

@@ -54,8 +54,8 @@ RSpec.describe Hanami::SliceConfigurable, :app_integration do
 
       subject(:subclass) { Main::MySubSubclass }
 
-      it "calls `configure_for_slice` again for the same slice" do
-        expect(subclass.traces).to eq [Main::Slice, Main::Slice]
+      it "does not call `configure_for_slice` again" do
+        expect(subclass.traces).to eq [Main::Slice]
       end
     end
 

data/spec/unit/hanami/version_spec.rb

@@ -2,6 +2,6 @@
 
 RSpec.describe "Hanami::VERSION" do
   it "returns current version" do
-    expect(Hanami::VERSION).to eq("2.0.0.beta1.1")
+    expect(Hanami::VERSION).to eq("2.0.0.beta2")
   end
 end