hanami 2.0.0.beta4 → 2.0.0.rc1

data/spec/integration/slices/slice_routing_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rack/test"
+require "stringio"
 
 RSpec.describe "Slices / Slice routing", :app_integration do
   include Rack::Test::Methods
@@ -34,7 +35,7 @@ RSpec.describe "Slices / Slice routing", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
           end
         end
       RUBY
@@ -67,7 +68,7 @@ RSpec.describe "Slices / Slice routing", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
           end
         end
       RUBY
@@ -118,7 +119,7 @@ RSpec.describe "Slices / Slice routing", :app_integration do
 
           module TestApp
             class App < Hanami::App
-              config.logger.stream = File.new("/dev/null", "w")
+              config.logger.stream = StringIO.new
             end
           end
         RUBY

data/spec/integration/slices_spec.rb

@@ -55,6 +55,32 @@ RSpec.describe "Slices", :app_integration do
     end
   end
 
+  specify "Loading a nested slice with a defined slice class" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "slices/main/config/slices/nested.rb", <<~RUBY
+        module Main
+          module Nested
+            class Slice < Hanami::Slice
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:main].slices[:nested]).to be Main::Nested::Slice
+    end
+  end
+
   it "Loading a slice generates a slice class if none is defined" do
     with_tmp_directory(Dir.mktmpdir) do
       write "config/app.rb", <<~RUBY
@@ -78,6 +104,80 @@ RSpec.describe "Slices", :app_integration do
     end
   end
 
+  specify "Registering a slice on the app creates a slice class with a top-level namespace" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            register_slice :main
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:main]).to be Main::Slice
+      expect(Main::Slice.ancestors).to include(Hanami::Slice)
+    end
+  end
+
+  specify "Registering a nested slice creates a slice class within the parent's namespace" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "config/slices/main.rb", <<~RUBY
+        module Main
+          class Slice < Hanami::Slice
+            register_slice :nested
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:main].slices[:nested]).to be Main::Nested::Slice
+    end
+  end
+
+  specify "Registering a nested slice with an existing class uses that class' own namespace" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "config/slices/main.rb", <<~RUBY
+        module Admin
+          class Slice < Hanami::Slice
+          end
+        end
+
+        module Main
+          class Slice < Hanami::Slice
+            register_slice :nested, Admin::Slice
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:main].slices[:nested]).to be Admin::Slice
+    end
+  end
+
   it "Registering a slice with a block creates a slice class and evals the block" do
     with_tmp_directory(Dir.mktmpdir) do
       write "config/app.rb", <<~RUBY

data/spec/isolation/hanami/boot/success_spec.rb

@@ -44,7 +44,7 @@ RSpec.describe Hanami do
       Hanami.boot
       expect(Hanami.app.ancestors).to include(Hanami::Application)
       expect(Hanami.app.root).to eq(Dir.pwd)
-      expect(Hanami.logger).to be_kind_of(Hanami::Logger)
+      expect(Hanami.logger).to be_kind_of(Dry::Logger::Dispatcher)
     end
   end
 end

data/spec/support/app_integration.rb

@@ -24,19 +24,11 @@ RSpec.shared_context "Application integration" do
 end
 
 def autoloaders_teardown!
-  # Tear down Zeitwerk (from zeitwerk's own test/support/loader_test)
-  Zeitwerk::Registry.loaders.reject! do |loader|
-    test_loader = loader.dirs.any? { |dir|
+  ObjectSpace.each_object(Zeitwerk::Loader) do |loader|
+    loader.unregister if loader.dirs.any? { |dir|
       dir.include?("/spec/") || dir.include?(Dir.tmpdir) ||
         dir.include?("/slices/") || dir.include?("/app")
     }
-
-    if test_loader
-      loader.unregister
-      true
-    else
-      false
-    end
   end
 end
 

data/spec/unit/hanami/config/actions/content_security_policy_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Hanami::Config::Actions, "#content_security_policy" do
           %(style-src 'self' 'unsafe-inline' https:)
         ].join("\n")
 
-        expect(content_security_policy.to_str).to eq(expected)
+        expect(content_security_policy.to_s).to eq(expected)
       end
     end
 
@@ -51,35 +51,35 @@ RSpec.describe Hanami::Config::Actions, "#content_security_policy" do
       content_security_policy[:script_src] += " #{cdn_url}"
 
       expect(content_security_policy[:script_src]).to eq("'self' #{cdn_url}")
-      expect(content_security_policy.to_str).to match("'self' #{cdn_url}")
+      expect(content_security_policy.to_s).to match("'self' #{cdn_url}")
     end
 
     it "overrides default values" do
       content_security_policy[:style_src] = cdn_url
 
       expect(content_security_policy[:style_src]).to eq(cdn_url)
-      expect(content_security_policy.to_str).to match(cdn_url)
+      expect(content_security_policy.to_s).to match(cdn_url)
     end
 
     it "nullifies value" do
       content_security_policy[:plugin_types] = nil
 
       expect(content_security_policy[:plugin_types]).to be(nil)
-      expect(content_security_policy.to_str).to match("plugin-types ;")
+      expect(content_security_policy.to_s).to match("plugin-types ;")
     end
 
     it "deletes key" do
       content_security_policy.delete(:object_src)
 
       expect(content_security_policy[:object_src]).to be(nil)
-      expect(content_security_policy.to_str).to_not match("object-src")
+      expect(content_security_policy.to_s).to_not match("object-src")
     end
 
     it "adds a custom key" do
       content_security_policy[:a_custom_key] = "foo"
 
       expect(content_security_policy[:a_custom_key]).to eq("foo")
-      expect(content_security_policy.to_str).to match("a-custom-key foo")
+      expect(content_security_policy.to_s).to match("a-custom-key foo")
     end
   end
 
@@ -87,7 +87,7 @@ RSpec.describe Hanami::Config::Actions, "#content_security_policy" do
     it "sets default header" do
       config.finalize!
 
-      expect(config.default_headers.fetch("Content-Security-Policy")).to eq(content_security_policy.to_str)
+      expect(config.default_headers.fetch("Content-Security-Policy")).to eq(content_security_policy.to_s)
     end
   end
 

data/spec/unit/hanami/config/actions/default_values_spec.rb

@@ -46,7 +46,7 @@ RSpec.describe Hanami::Config::Actions, "default values" do
           "X-Frame-Options" => "DENY",
           "X-Content-Type-Options" => "nosniff",
           "X-XSS-Protection" => "1; mode=block",
-          "Content-Security-Policy" => config.content_security_policy.to_str
+          "Content-Security-Policy" => config.content_security_policy.to_s
         )
       }
     end

data/spec/unit/hanami/config/actions/sessions_spec.rb

@@ -42,9 +42,7 @@ RSpec.describe Hanami::Config::Actions, "#sessions" do
     end
 
     it "returns an array of middleware classes and options" do
-      expect(sessions.middleware).to eq [
-        [Rack::Session::Cookie, [secret: "abc"]]
-      ]
+      expect(sessions.middleware).to eq [Rack::Session::Cookie, {secret: "abc"}]
     end
   end
 end

data/spec/unit/hanami/config/actions_spec.rb

@@ -34,17 +34,6 @@ RSpec.describe Hanami::Config, "#actions" do
     it "can be finalized" do
       is_expected.to respond_to(:finalize!)
     end
-
-    describe "#settings" do
-      it "returns a set of available settings" do
-        expect(actions.settings).to be_a(Set)
-        expect(actions.settings).to include(:view_context_identifier, :handled_exceptions)
-      end
-
-      it "includes all base action settings" do
-        expect(actions.settings).to include(Hanami::Action.settings)
-      end
-    end
   end
 
   context "hanami-controller is not bundled" do
@@ -54,7 +43,7 @@ RSpec.describe Hanami::Config, "#actions" do
     end
 
     it "does not expose any settings" do
-      is_expected.not_to be_an_instance_of(Hanami::Config::Actions)
+      is_expected.to be_an_instance_of(Hanami::Config::NullConfig)
       is_expected.not_to respond_to(:default_response_format)
       is_expected.not_to respond_to(:default_response_format=)
     end

data/spec/unit/hanami/config/logger_spec.rb

@@ -4,26 +4,19 @@ require "hanami/config/logger"
 require "hanami/slice_name"
 require "dry/inflector"
 require "logger"
+require "stringio"
 
 RSpec.describe Hanami::Config::Logger do
-  subject { described_class.new(app_name: app_name, env: env) }
-  let(:app_name) { Hanami::SliceName.new(double(name: "MyApp::app"), inflector: -> { Dry::Inflector.new }) }
-  let(:env) { :development }
-
-  describe "#logger_class" do
-    it "defaults to Hanami::Logger" do
-      expect(subject.logger_class).to eql Hanami::Logger
-    end
-
-    it "can be changed to another class" do
-      another_class = Class.new
+  subject do
+    described_class.new(app_name: app_name, env: env)
+  end
 
-      expect { subject.logger_class = another_class }
-        .to change { subject.logger_class }
-        .to(another_class)
-    end
+  let(:app_name) do
+    Hanami::SliceName.new(double(name: "MyApp::app"), inflector: -> { Dry::Inflector.new })
   end
 
+  let(:env) { :development }
+
   describe "#level" do
     it "defaults to :debug" do
       expect(subject.level).to eq(:debug)
@@ -63,16 +56,24 @@ RSpec.describe Hanami::Config::Logger do
   end
 
   describe "#stream=" do
-    it "accepts a IO object or a path to a file" do
-      expect { subject.stream = "/dev/null" }
+    it "accepts a path to a file" do
+      expect { subject.stream = File::NULL }
         .to change { subject.stream }
-        .to("/dev/null")
+        .to(File::NULL)
+    end
+
+    it "accepts a IO object" do
+      stream = StringIO.new
+
+      expect { subject.stream = stream }
+        .to change { subject.stream }
+        .to(stream)
     end
   end
 
   describe "#formatter" do
-    it "defaults to nil" do
-      expect(subject.formatter).to eq(nil)
+    it "defaults to :rack" do
+      expect(subject.formatter).to eq(:rack)
     end
 
     context "when :production environment" do
@@ -92,33 +93,17 @@ RSpec.describe Hanami::Config::Logger do
     end
   end
 
-  describe "#colors" do
-    it "defaults to nil" do
-      expect(subject.colors).to eq(nil)
-    end
-
-    context "when :test environment" do
-      let(:env) { :test }
-
-      it "returns false" do
-        expect(subject.colors).to eq(false)
-      end
-    end
-
-    context "when :production environment" do
-      let(:env) { :production }
-
-      it "returns false" do
-        expect(subject.colors).to eq(false)
-      end
+  describe "#template" do
+    it "defaults to false" do
+      expect(subject.template).to eq("[%<progname>s] [%<severity>s] [%<time>s] %<message>s")
     end
   end
 
-  describe "#colors=" do
+  describe "#template=" do
     it "accepts a value" do
-      expect { subject.colors = false }
-        .to change { subject.colors }
-        .to(false)
+      expect { subject.template = "%<message>s" }
+        .to change { subject.template }
+        .to("%<message>s")
     end
   end
 
@@ -145,20 +130,14 @@ RSpec.describe Hanami::Config::Logger do
   end
 
   describe "#options" do
-    it "defaults to empty array" do
-      expect(subject.options).to eq([])
+    it "defaults to empty hash" do
+      expect(subject.options).to eq({})
     end
   end
 
   describe "#options=" do
     it "accepts value" do
-      subject.options = expected = "daily"
-
-      expect(subject.options).to eq([expected])
-    end
-
-    it "accepts values" do
-      subject.options = expected = [0, 1048576]
+      subject.options = expected = {rotate: "daily"}
 
       expect(subject.options).to eq(expected)
     end
@@ -167,7 +146,11 @@ end
 
 RSpec.describe Hanami::Config do
   subject(:config) { described_class.new(app_name: app_name, env: env) }
-  let(:app_name) { Hanami::SliceName.new(double(name: "SOS::app"), inflector: -> { Dry::Inflector.new }) }
+
+  let(:app_name) do
+    Hanami::SliceName.new(double(name: "SOS::app"), inflector: -> { Dry::Inflector.new })
+  end
+
   let(:env) { :development }
 
   describe "#logger" do
@@ -187,8 +170,8 @@ RSpec.describe Hanami::Config do
   end
 
   describe "#logger_instance" do
-    it "defaults to an Hanami::Logger instance, based on the default logger settings" do
-      expect(config.logger_instance).to be_an_instance_of config.logger.logger_class
+    it "defaults to using Dry::Logger, based on the default logger settings" do
+      expect(config.logger_instance).to be_a(Dry::Logger::Dispatcher)
       expect(config.logger_instance.level).to eq Logger::DEBUG
     end
 

data/spec/unit/hanami/config/router_spec.rb

@@ -33,7 +33,7 @@ RSpec.describe Hanami::Config, "#router" do
     end
 
     it "does not expose any settings" do
-      is_expected.not_to be_an_instance_of(Hanami::Config::Router)
+      is_expected.to be_an_instance_of(Hanami::Config::NullConfig)
       is_expected.not_to respond_to(:resolver)
     end
 

data/spec/unit/hanami/config/views_spec.rb

@@ -28,16 +28,6 @@ RSpec.describe Hanami::Config, "#views" do
       expect(views).not_to respond_to(:inflector=)
     end
 
-    describe "#settings" do
-      it "includes locally defined settings" do
-        expect(views.settings).to include :parts_path
-      end
-
-      it "includes all view settings apart from inflector" do
-        expect(views.settings).to include (Hanami::View.settings - [:inflector])
-      end
-    end
-
     it "preserves default values from the base view config" do
       expect(views.layouts_dir).to eq Hanami::View.config.layouts_dir
     end
@@ -80,11 +70,11 @@ RSpec.describe Hanami::Config, "#views" do
       end
 
       it "does not allow changes to locally defined settings" do
-        expect { views.parts_path = "parts" }.to raise_error(Dry::Configurable::FrozenConfig)
+        expect { views.parts_path = "parts" }.to raise_error(Dry::Configurable::FrozenConfigError)
       end
 
       it "does not allow changes to base view settings" do
-        expect { views.paths = [] }.to raise_error(Dry::Configurable::FrozenConfig)
+        expect { views.paths = [] }.to raise_error(Dry::Configurable::FrozenConfigError)
       end
     end
   end
@@ -96,7 +86,7 @@ RSpec.describe Hanami::Config, "#views" do
     end
 
     it "does not expose any settings" do
-      is_expected.not_to be_an_instance_of(Hanami::Config::Views)
+      is_expected.to be_an_instance_of(Hanami::Config::NullConfig)
       is_expected.not_to respond_to(:layouts_dir)
       is_expected.not_to respond_to(:layouts_dir=)
     end

data/spec/unit/hanami/settings_spec.rb

@@ -68,7 +68,7 @@ RSpec.describe Hanami::Settings do
       settings = settings_class.new(store)
 
       expect(settings.config).to be_frozen
-      expect { settings.database_url = "new" }.to raise_error(Dry::Configurable::FrozenConfig)
+      expect { settings.database_url = "new" }.to raise_error(Dry::Configurable::FrozenConfigError)
     end
   end
 

data/spec/unit/hanami/slice_configurable_spec.rb

@@ -106,18 +106,18 @@ RSpec.describe Hanami::SliceConfigurable, :app_integration do
         class Slice
           register_slice :nested
         end
-      end
 
-      module Nested
-        class MySubclass < TestApp::BaseClass
+        module Nested
+          class MySubclass < TestApp::BaseClass
+          end
         end
       end
     end
 
-    subject(:subclass) { Nested::MySubclass }
+    subject(:subclass) { Main::Nested::MySubclass }
 
     it "calls `configure_for_slice` with the nested slice" do
-      expect(subclass.traces).to eq [Nested::Slice]
+      expect(subclass.traces).to eq [Main::Nested::Slice]
     end
   end
 end

data/spec/unit/hanami/slice_spec.rb

@@ -8,6 +8,38 @@ RSpec.describe Hanami::Slice, :app_integration do
     end
   end
 
+  describe ".environemnt" do
+    subject(:slice) { Hanami.app.register_slice(:main) }
+
+    before do
+      allow(slice.config).to receive(:env) { :development }
+    end
+
+    it "evaluates the block with the env matches the Hanami.env" do
+      expect {
+        slice.environment(:development) do
+          config.logger.level = :info
+        end
+      }
+        .to change { slice.config.logger.level }
+        .to :info
+    end
+
+    it "yields the slice to the block" do
+      captured_slice = nil
+      slice.environment(:development) { |slice| captured_slice = slice }
+      expect(captured_slice).to be slice
+    end
+
+    it "does not evaluate the block with the env does not match the Hanami.env" do
+      expect {
+        slice.environment(:test) do
+          config.logger.level = :info
+        end
+      }.not_to(change { slice.config.logger.level })
+    end
+  end
+
   describe ".prepare" do
     it "raises an error if the slice class is anonymous" do
       expect { Class.new(described_class).prepare }

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.beta4")
+    expect(Hanami::VERSION).to eq("2.0.0.rc1")
   end
 end

data/spec/unit/hanami/web/rack_logger_spec.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
 require "hanami/web/rack_logger"
-require "hanami/logger"
+require "dry/logger"
 require "stringio"
 require "rack/mock"
 
 RSpec.describe Hanami::Web::RackLogger do
   subject { described_class.new(logger) }
-  let(:logger) { Hanami::Logger.new(app_name, stream: stream, level: Hanami::Logger::DEBUG, filter: filters) }
+
+  let(:logger) do
+    Dry.Logger(
+      app_name,
+      stream: stream,
+      level: :debug,
+      filters: filters,
+      formatter: :rack,
+      template: "[%<progname>s] [%<severity>s] [%<time>s] %<message>s"
+    )
+  end
+
   let(:stream) { StringIO.new }
   let(:filters) { ["user.password"] }
   let(:app_name) { "my_app" }