hanami 2.0.3 → 2.1.0.beta2

data/lib/hanami/version.rb

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

data/lib/hanami/web/rack_logger.rb

@@ -29,7 +29,7 @@ module Hanami
       ROUTER_PARAMS = "router.params"
       private_constant :ROUTER_PARAMS
 
-      CONTENT_LENGTH = "Content-Length"
+      CONTENT_LENGTH = "CONTENT_LENGTH"
       private_constant :CONTENT_LENGTH
 
       MILISECOND = "ms"

data/lib/hanami.rb

@@ -18,7 +18,7 @@ module Hanami
   def self.loader
     @loader ||= Zeitwerk::Loader.for_gem.tap do |loader|
       loader.ignore(
-        "#{loader.dirs.first}/hanami/{constants,boot,errors,prepare,rake_tasks,setup}.rb"
+        "#{loader.dirs.first}/hanami/{constants,boot,errors,extensions/router/errors,prepare,rake_tasks,setup}.rb"
       )
     end
   end
@@ -144,8 +144,8 @@ module Hanami
   #
   # @api public
   # @since 2.0.0
-  def self.env
-    ENV.fetch("HANAMI_ENV") { ENV.fetch("RACK_ENV", "development") }.to_sym
+  def self.env(e: ENV)
+    e.fetch("HANAMI_ENV") { e.fetch("RACK_ENV", "development") }.to_sym
   end
 
   # Returns true if {.env} matches any of the given names

data/spec/integration/action/view_rendering/view_context_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+RSpec.describe "App action / View rendering / View context", :app_integration do
+  subject(:context) {
+    # We capture the context during rendering via our view spies; see the view classes below
+    action.call("REQUEST_METHOD" => "GET", "QUERY_STRING" => "/mock_request")
+    action.view.called_with[:context]
+  }
+
+  before do
+    with_directory(make_tmp_directory) do
+      write "config/app.rb", <<~RUBY
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/action.rb", <<~RUBY
+        # auto_register: false
+
+        require "hanami/view"
+
+        module TestApp
+          class Action < Hanami::Action
+          end
+        end
+      RUBY
+
+      before_prepare if respond_to?(:before_prepare)
+      require "hanami/prepare"
+    end
+  end
+
+  describe "app action" do
+    let(:action) { TestApp::App["actions.posts.show"] }
+
+    def before_prepare
+      write "app/actions/posts/show.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Posts
+              class Show < TestApp::Action
+              end
+            end
+          end
+        end
+      RUBY
+
+      # Custom view class as a spy for `#call` args
+      write "app/views/posts/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Posts
+              class Show
+                attr_reader :called_with
+
+                def call(**args)
+                  @called_with = args
+                  ""
+                end
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    context "no context class defined" do
+      it "defines and uses a context class" do
+        expect(context).to be_an_instance_of TestApp::Views::Context
+        expect(context.class).to be < Hanami::View::Context
+      end
+
+      it "includes the request" do
+        expect(context.request).to be_an_instance_of Hanami::Action::Request
+        expect(context.request.env["QUERY_STRING"]).to eq "/mock_request"
+      end
+    end
+
+    context "context class defined" do
+      def before_prepare
+        super()
+
+        write "app/views/context.rb", <<~RUBY
+          # auto_register: false
+
+          module TestApp
+            module Views
+              class Context < Hanami::View::Context
+                def concrete_app_context?
+                  true
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "uses the defined context class" do
+        expect(context).to be_an_instance_of TestApp::Views::Context
+        expect(context).to be_a_concrete_app_context
+      end
+    end
+
+    context "hanami-view not bundled" do
+      before do
+        allow(Hanami).to receive(:bundled?).and_call_original
+        expect(Hanami).to receive(:bundled?).with("hanami-view").and_return false
+      end
+
+      it "does not provide a context" do
+        expect(context).to be nil
+      end
+
+      context "context class defined" do
+        def before_prepare
+          super()
+
+          write "app/views/context.rb", <<~RUBY
+            module TestApp
+              module Views
+                class Context
+                  def initialize(**)
+                  end
+
+                  def with(**)
+                    self
+                  end
+
+                  def concrete_app_context?
+                    true
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+
+        it "uses the defined context class" do
+          expect(context).to be_an_instance_of TestApp::Views::Context
+          expect(context).to be_a_concrete_app_context
+        end
+      end
+    end
+  end
+
+  describe "slice action" do
+    let(:action) { Main::Slice["actions.posts.show"] }
+
+    def before_prepare
+      write "slices/main/action.rb", <<~RUBY
+        module Main
+          class Action < TestApp::Action
+          end
+        end
+      RUBY
+
+      write "slices/main/actions/posts/show.rb", <<~RUBY
+        module Main
+          module Actions
+            module Posts
+              class Show < Main::Action
+              end
+            end
+          end
+        end
+      RUBY
+
+      # Custom view class as a spy for `#call` args
+      write "slices/main/views/posts/show.rb", <<~RUBY
+        module Main
+          module Views
+            module Posts
+              class Show
+                attr_reader :called_with
+
+                def call(**args)
+                  @called_with = args
+                  ""
+                end
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    context "no context class defined" do
+      it "defines and uses a context class" do
+        expect(context).to be_an_instance_of Main::Views::Context
+        expect(context.class).to be < Hanami::View::Context
+      end
+    end
+
+    context "context class defined" do
+      def before_prepare
+        super()
+
+        write "slices/main/views/context.rb", <<~RUBY
+          # auto_register: false
+
+          module Main
+            module Views
+              class Context < Hanami::View::Context
+                def concrete_slice_context?
+                  true
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "uses the defined context class" do
+        expect(context).to be_an_instance_of Main::Views::Context
+        expect(context).to be_a_concrete_slice_context
+      end
+    end
+  end
+end

data/spec/integration/action/view_rendering_spec.rb

@@ -32,24 +32,6 @@ RSpec.describe "App action / View rendering", :app_integration do
         end
       RUBY
 
-      write "app/views/context.rb", <<~RUBY
-        require "hanami/view/context"
-
-        module TestApp
-          module Views
-            class Context < Hanami::View::Context
-              def request
-                _options.fetch(:request)
-              end
-
-              def response
-                _options.fetch(:response)
-              end
-            end
-          end
-        end
-      RUBY
-
       write "app/actions/users/show.rb", <<~RUBY
         module TestApp
           module Actions

data/spec/integration/assets/assets_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "rack/test"
+require "stringio"
+
+RSpec.describe "Assets", :app_integration do
+  include Rack::Test::Methods
+  let(:app) { Hanami.app }
+  let(:root) { make_tmp_directory }
+
+  before do
+    with_directory(root) do
+      write "config/app.rb", <<~RUBY
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = StringIO.new
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            get "posts/:id/edit", to: "posts.edit"
+            put "posts/:id", to: "posts.update"
+          end
+        end
+      RUBY
+
+      write "app/action.rb", <<~RUBY
+        # auto_register: false
+
+        require "hanami/action"
+
+        module TestApp
+          class Action < Hanami::Action
+          end
+        end
+      RUBY
+
+      write "app/view.rb", <<~RUBY
+        # auto_register: false
+
+        require "hanami/view"
+
+        module TestApp
+          class View < Hanami::View
+            config.layout = nil
+          end
+        end
+      RUBY
+
+      write "app/views/posts/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Posts
+              class Show < TestApp::View
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/templates/posts/show.html.erb", <<~ERB
+        <%= stylesheet_link_tag("app") %>
+        <%= css("app") %>
+        <%= javascript_tag("app") %>
+        <%= js("app") %>
+      ERB
+
+      write "app/assets/js/app.ts", <<~TS
+        import "../css/app.css";
+
+        console.log("Hello from index.ts");
+      TS
+
+      write "app/assets/css/app.css", <<~CSS
+        .btn {
+          background: #f00;
+        }
+      CSS
+
+      before_prepare if respond_to?(:before_prepare)
+      require "hanami/prepare"
+    end
+  end
+
+  specify "assets are available in helpers and in `assets` component" do
+    compile_assets!
+
+    output = Hanami.app["views.posts.show"].call.to_s
+
+    expect(output).to match(%r{<link href="/assets/app-[A-Z0-9]{8}.css" type="text/css" rel="stylesheet">})
+    expect(output).to match(%r{<script src="/assets/app-[A-Z0-9]{8}.js" type="text/javascript"></script>})
+
+    assets = Hanami.app["assets"]
+
+    expect(assets["app.css"].to_s).to match(%r{/assets/app-[A-Z0-9]{8}.css})
+    expect(assets["app.js"].to_s).to match(%r{/assets/app-[A-Z0-9]{8}.js})
+  end
+end

data/spec/integration/assets/serve_static_assets_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "rack/test"
+require "stringio"
+
+RSpec.describe "Serve Static Assets", :app_integration do
+  include Rack::Test::Methods
+  let(:app) { Hanami.app }
+  let(:root) { make_tmp_directory }
+  let!(:env) { ENV.to_h }
+
+  before do
+    with_directory(root) do
+      write "config/app.rb", <<~RUBY
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = StringIO.new
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            root to: ->(env) { [200, {}, ["Hello from root"]] }
+          end
+        end
+      RUBY
+
+      write "public/assets/app.js", <<~JS
+        console.log("Hello from app.js");
+      JS
+    end
+  end
+
+  after do
+    ENV.replace(env)
+  end
+
+  context "with default configuration" do
+    before do
+      with_directory(root) do
+        require "hanami/prepare"
+      end
+    end
+
+    it "serves static assets" do
+      get "/assets/app.js"
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to match(/Hello/)
+    end
+
+    it "returns 404 for missing asset" do
+      get "/assets/missing.js"
+
+      expect(last_response.status).to eq(404)
+      expect(last_response.body).to match(/Not Found/i)
+    end
+
+    it "doesn't escape from root directory" do
+      get "/assets/../../config/app.rb"
+
+      expect(last_response.status).to eq(404)
+      expect(last_response.body).to match(/Not Found/i)
+    end
+  end
+
+  context "when configuration is set to false" do
+    before do
+      with_directory(root) do
+        write "config/app.rb", <<~RUBY
+          module TestApp
+            class App < Hanami::App
+              config.logger.stream = StringIO.new
+              config.assets.serve = false
+            end
+          end
+        RUBY
+
+        require "hanami/boot"
+      end
+    end
+
+    it "doesn't serve static assets" do
+      get "/assets/app.js"
+
+      expect(last_response.status).to eq(404)
+    end
+  end
+
+  context "when env var is set to true" do
+    before do
+      with_directory(root) do
+        ENV["HANAMI_SERVE_ASSETS"] = "true"
+        require "hanami/boot"
+      end
+    end
+
+    it "serves static assets" do
+      get "/assets/app.js"
+
+      expect(last_response.status).to eq(200)
+    end
+  end
+
+  context "when env var is set to false" do
+    before do
+      with_directory(root) do
+        ENV["HANAMI_SERVE_ASSETS"] = "false"
+        require "hanami/boot"
+      end
+    end
+
+    it "doesn't serve static assets" do
+      get "/assets/app.js"
+
+      expect(last_response.status).to eq(404)
+    end
+  end
+
+  context "when Hanami.env is not :development or :test" do
+    before do
+      with_directory(root) do
+        ENV["HANAMI_ENV"] = "production"
+        require "hanami/boot"
+      end
+    end
+
+    it "doesn't serve static assets" do
+      get "/assets/app.js"
+
+      expect(last_response.status).to eq(404)
+    end
+  end
+
+  context "when Hanami.env is not :development or :test, but env var is set to true" do
+    before do
+      with_directory(root) do
+        ENV["HANAMI_ENV"] = "production"
+        ENV["HANAMI_SERVE_ASSETS"] = "true"
+        require "hanami/boot"
+      end
+    end
+
+    it "serves static assets" do
+      get "/assets/app.js"
+
+      expect(last_response.status).to eq(200)
+    end
+  end
+end

data/spec/integration/logging/exception_logging_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "rack/test"
+require "stringio"
+
+RSpec.describe "Logging / Exception logging", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { Hanami.app }
+
+  let(:logger_stream) { StringIO.new }
+
+  def configure_logger
+    Hanami.app.config.logger.stream = logger_stream
+  end
+
+  def logs
+    @logs ||= (logger_stream.rewind and logger_stream.read)
+  end
+
+  before do
+    with_directory(make_tmp_directory) do
+      write "config/app.rb", <<~RUBY
+        module TestApp
+          class App < Hanami::App
+            # Disable framework-level error rendering so we can test the raw action behavior
+            config.render_errors = false
+            config.render_detailed_errors = false
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            root to: "test"
+          end
+        end
+      RUBY
+
+      require "hanami/setup"
+      configure_logger
+
+      before_prepare if respond_to?(:before_prepare)
+      require "hanami/prepare"
+    end
+  end
+
+  describe "unhandled exceptions" do
+    def before_prepare
+      write "app/actions/test.rb", <<~RUBY
+        module TestApp
+          module Actions
+            class Test < Hanami::Action
+              UnhandledError = Class.new(StandardError)
+
+              def handle(request, response)
+                raise UnhandledError, "unhandled"
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    it "logs a 500 error and full exception details when an exception is raised" do
+      # Make the request with a rescue so the raised exception doesn't crash the tests
+      begin
+        get "/"
+      rescue TestApp::Actions::Test::UnhandledError # rubocop:disable Lint/SuppressedException
+      end
+
+      expect(logs.lines.length).to be > 10
+      expect(logs).to match %r{GET 500 \d+(µs|ms) 127.0.0.1 /}
+      expect(logs).to include("unhandled (TestApp::Actions::Test::UnhandledError)")
+      expect(logs).to include("app/actions/test.rb:7:in `handle'")
+    end
+
+    it "re-raises the exception" do
+      expect { get "/" }.to raise_error(TestApp::Actions::Test::UnhandledError)
+    end
+  end
+
+  describe "errors handled by handle_exception" do
+    def before_prepare
+      write "app/actions/test.rb", <<~RUBY
+        module TestApp
+          module Actions
+            class Test < Hanami::Action
+              NotFoundError = Class.new(StandardError)
+
+              handle_exception NotFoundError => :handle_not_found_error
+
+              def handle(request, response)
+                raise NotFoundError
+              end
+
+              private
+
+              def handle_not_found_error(request, response, exception)
+                halt 404
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    it "does not log an error" do
+      get "/"
+
+      expect(logs).to match %r{GET 404 \d+(µs|ms) 127.0.0.1 /}
+    end
+  end
+end