hanami 2.1.0.beta1 → 2.1.0.beta2.1

data/lib/hanami/middleware/assets.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rack/static"
+
+module Hanami
+  module Middleware
+    class Assets < Rack::Static
+      def initialize(app, options = {}, config: Hanami.app.config)
+        root = config.actions.public_directory
+        urls = [config.assets.path_prefix]
+
+        defaults = {
+          root: root,
+          urls: urls
+        }
+
+        super(app, defaults.merge(options))
+      end
+    end
+  end
+end

data/lib/hanami/middleware/render_errors.rb

@@ -56,18 +56,15 @@ module Hanami
       def call(env)
         @app.call(env)
       rescue Exception => exception
-        request = Rack::Request.new(env)
+        raise unless @config.render_errors
 
-        if @config.render_errors
-          render_exception(request, exception)
-        else
-          raise exception
-        end
+        render_exception(env, exception)
       end
 
       private
 
-      def render_exception(request, exception)
+      def render_exception(env, exception)
+        request = Rack::Request.new(env)
         renderable = RenderableException.new(exception, responses: @config.render_error_responses)
 
         status = renderable.status_code

data/lib/hanami/providers/assets.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hanami
+  # @api private
+  module Providers
+    # Provider source to register routes helper component in Hanami slices.
+    #
+    # @see Hanami::Slice::RoutesHelper
+    #
+    # @api private
+    # @since 2.0.0
+    class Assets < Dry::System::Provider::Source
+      # @api private
+      def self.for_slice(slice)
+        Class.new(self) do |klass|
+          klass.instance_variable_set(:@slice, slice)
+        end
+      end
+
+      # @api private
+      def self.slice
+        @slice || Hanami.app
+      end
+
+      # @api private
+      def prepare
+        require "hanami/assets"
+      end
+
+      # @api private
+      def start
+        assets = Hanami::Assets.new(config: slice.config.assets)
+
+        register(:assets, assets)
+      end
+
+      private
+
+      def slice
+        self.class.slice
+      end
+    end
+  end
+end

data/lib/hanami/rake_tasks.rb

@@ -10,7 +10,7 @@ Hanami::CLI::RakeTasks.register_tasks do
 
   # Ruby ecosystem compatibility
   #
-  # Most of the SaaS automatic tasks are designed after Ruby on Rails.
+  # Most of the hosting SaaS automatic tasks are designed after Ruby on Rails.
   # They expect the following Rake tasks to be present:
   #
   #   * db:migrate
@@ -20,31 +20,32 @@ Hanami::CLI::RakeTasks.register_tasks do
   #
   # ===
   #
-  # These Rake tasks aren't listed when someone runs `rake -T`, because we
-  # want to encourage developers to use `hanami` commands.
+  # These Rake tasks are **NOT** listed when someone runs `rake -T`, because we
+  # want to encourage developers to use `hanami` CLI commands.
   #
-  # In order to migrate the database or precompile assets a developer should
-  # use:
+  # In order to migrate the database or compile assets a developer should use:
   #
   #   * hanami db migrate
-  #   * hanami assets precompile
+  #   * hanami assets compile
   #
   # This is the preferred way to run Hanami command line tasks.
   # Please use them when you're in control of your deployment environment.
   #
   # If you're not in control and your deployment requires these "standard"
   # Rake tasks, they are here to solve this only specific problem.
-  namespace :db do
-    task :migrate do
-      # TODO(@jodosha): Enable when we'll integrate with ROM
-      # run_hanami_command("db migrate")
-    end
-  end
-
-  namespace :assets do
-    task :precompile do
-      # TODO(@jodosha): Enable when we'll integrate with hanami-assets
-      # run_hanami_command("assets precompile")
+  #
+  # namespace :db do
+  #   task :migrate do
+  #     # TODO(@jodosha): Enable when we'll integrate with ROM
+  #     # run_hanami_command("db migrate")
+  #   end
+  # end
+
+  if Hanami.bundled?("hanami-assets")
+    namespace :assets do
+      task :precompile do
+        run_hanami_command("assets compile")
+      end
     end
   end
 
@@ -53,7 +54,7 @@ Hanami::CLI::RakeTasks.register_tasks do
   @_hanami_cli_bundler = Hanami::CLI::Bundler.new
 
   def run_hanami_command(command)
-    @_hanami_cli_bundler.exec(command)
+    @_hanami_cli_bundler.hanami_exec(command)
   end
 end
 

data/lib/hanami/settings.rb

@@ -45,7 +45,7 @@ module Hanami
   #
   # Setting values are loaded from a configurable store, which defaults to
   # {Hanami::Settings::EnvStore}, which fetches the values from equivalent upper-cased keys in
-  # `ENV`. You can configue an alternative store via {Hanami::Config#settings_store}. Setting stores
+  # `ENV`. You can configure an alternative store via {Hanami::Config#settings_store}. Setting stores
   # must implement a `#fetch` method with the same signature as `Hash#fetch`.
   #
   # [dry-c]: https://dry-rb.org/gems/dry-configurable/

data/lib/hanami/slice.rb

@@ -952,12 +952,21 @@ module Hanami
         config = self.config
         rack_monitor = self["rack.monitor"]
 
+        render_errors = render_errors?
+        render_detailed_errors = render_detailed_errors?
+
+        error_handlers = {}.tap do |hsh|
+          if render_errors || render_detailed_errors
+            hsh[:not_allowed] = ROUTER_NOT_ALLOWED_HANDLER
+            hsh[:not_found] = ROUTER_NOT_FOUND_HANDLER
+          end
+        end
+
         Slice::Router.new(
           inspector: inspector,
           routes: routes,
           resolver: config.router.resolver.new(slice: self),
-          not_allowed: ROUTER_NOT_ALLOWED_HANDLER,
-          not_found: ROUTER_NOT_FOUND_HANDLER,
+          **error_handlers,
           **config.router.options
         ) do
           use(rack_monitor)
@@ -968,19 +977,31 @@ module Hanami
             Hanami::Middleware::PublicErrorsApp.new(slice.root.join("public"))
           )
 
-          if config.render_detailed_errors && Hanami.bundled?("hanami-webconsole")
+          if render_detailed_errors
             require "hanami/webconsole"
-            use(Hanami::Webconsole::Middleware)
+            use(Hanami::Webconsole::Middleware, config)
           end
 
           if Hanami.bundled?("hanami-controller") && config.actions.sessions.enabled?
             use(*config.actions.sessions.middleware)
           end
 
+          if Hanami.bundled?("hanami-assets") && config.assets.serve
+            use(Hanami::Middleware::Assets)
+          end
+
           middleware_stack.update(config.middleware_stack)
         end
       end
 
+      def render_errors?
+        config.render_errors
+      end
+
+      def render_detailed_errors?
+        config.render_detailed_errors && Hanami.bundled?("hanami-webconsole")
+      end
+
       ROUTER_NOT_ALLOWED_HANDLER = -> env, allowed_http_methods {
         raise Hanami::Router::NotAllowedError.new(env, allowed_http_methods)
       }.freeze

data/lib/hanami/version.rb

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

data/lib/hanami.rb

@@ -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/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

data/spec/integration/logging/notifications_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "rack/test"
+
+RSpec.describe "Logging / Notifications", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { Hanami.app }
+
+  specify "Request logging continues even when notifications bus has already been used" do
+    dir = Dir.mktmpdir
+
+    with_tmp_directory(dir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.actions.format :json
+            config.logger.options = {colorize: true}
+            config.logger.stream = config.root.join("test.log")
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            post "/users", to: "users.create"
+          end
+        end
+      RUBY
+
+      write "app/actions/users/create.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Users
+              class Create < Hanami::Action
+                def handle(req, resp)
+                  resp.body = req.params.to_h.keys
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      # Simulate any component interacting with the notifications bus such that it creates its
+      # internal bus with a duplicate copy of all currently registered events. This means that the
+      # class-level Dry::Monitor::Notification events implicitly registered by the
+      # Dry::Monitor::Rack::Middleware activated via the rack provider are ignored, unless our
+      # provider explicitly re-registers them on _instance_ of the notifications bus.
+      #
+      # See Hanami::Providers::Rack for more detail.
+      Hanami.app["notifications"].instrument(:sql)
+
+      logs = -> { Pathname(dir).join("test.log").realpath.read }
+
+      post "/users", JSON.generate(name: "jane", password: "secret"), {"CONTENT_TYPE" => "application/json"}
+      expect(logs.()).to match %r{POST 200 \d+(µs|ms) 127.0.0.1 /}
+    end
+  end
+end
+
+
+