hanami 2.1.0.beta2.1 → 2.1.0.rc2

data/lib/hanami/slice.rb

@@ -952,6 +952,7 @@ module Hanami
         config = self.config
         rack_monitor = self["rack.monitor"]
 
+        show_welcome = Hanami.env?(:development) && routes.empty?
         render_errors = render_errors?
         render_detailed_errors = render_detailed_errors?
 
@@ -971,6 +972,8 @@ module Hanami
         ) do
           use(rack_monitor)
 
+          use(Hanami::Web::Welcome) if show_welcome
+
           use(
             Hanami::Middleware::RenderErrors,
             config,
@@ -982,8 +985,15 @@ module Hanami
             use(Hanami::Webconsole::Middleware, config)
           end
 
-          if Hanami.bundled?("hanami-controller") && config.actions.sessions.enabled?
-            use(*config.actions.sessions.middleware)
+          if Hanami.bundled?("hanami-controller")
+            if config.actions.method_override
+              require "rack/method_override"
+              use(Rack::MethodOverride)
+            end
+
+            if config.actions.sessions.enabled?
+              use(*config.actions.sessions.middleware)
+            end
           end
 
           if Hanami.bundled?("hanami-assets") && config.assets.serve

data/lib/hanami/slice_registrar.rb

@@ -46,19 +46,16 @@ module Hanami
     end
 
     def load_slices
-      slice_configs = Dir[root.join(CONFIG_DIR, SLICES_DIR, "*#{RB_EXT}")]
-        .map { |file| File.basename(file, RB_EXT) }
+      slice_configs = root.join(CONFIG_DIR, SLICES_DIR).glob("*#{RB_EXT}")
+        .map { _1.basename(RB_EXT) }
 
-      slice_dirs = Dir[File.join(root, SLICES_DIR, "*")]
-        .select { |path| File.directory?(path) }
-        .map { |path| File.basename(path) }
+      slice_dirs = root.join(SLICES_DIR).glob("*")
+        .select(&:directory?)
+        .map { _1.basename }
 
-      slice_names = (slice_dirs + slice_configs).uniq.sort
+      (slice_dirs + slice_configs).uniq.sort
         .then { filter_slice_names(_1) }
-
-      slice_names.each do |slice_name|
-        load_slice(slice_name)
-      end
+        .each(&method(:load_slice))
 
       self
     end
@@ -97,21 +94,20 @@ module Hanami
       parent.eql?(parent.app) ? Object : parent.namespace
     end
 
-    # Runs when a slice file has been found at `config/slices/[slice_name].rb`, or a slice directory
-    # at `slices/[slice_name]`. Attempts to require the slice class, if defined, before registering
-    # the slice. If a slice class is not found, registering the slice will generate the slice class.
+    # Runs when a slice file has been found inside the app at `config/slices/[slice_name].rb`,
+    # or when a slice directory exists at `slices/[slice_name]`.
+    #
+    # If a slice definition file is found by `find_slice_require_path`, then `load_slice` will
+    # require the file before registering the slice class.
+    #
+    # If a slice class is not found, registering the slice will generate the slice class.
     def load_slice(slice_name)
-      slice_require_path = root.join(CONFIG_DIR, SLICES_DIR, slice_name).to_s
-      begin
-        require(slice_require_path)
-      rescue LoadError => e
-        raise e unless e.path == slice_require_path
-      end
+      slice_require_path = find_slice_require_path(slice_name)
+      require slice_require_path if slice_require_path
 
-      slice_module_name = inflector.camelize("#{parent_slice_namespace.name}#{PATH_DELIMITER}#{slice_name}")
       slice_class =
         begin
-          inflector.constantize("#{slice_module_name}#{MODULE_DELIMITER}Slice")
+          inflector.constantize("#{slice_module_name(slice_name)}#{MODULE_DELIMITER}Slice")
         rescue NameError => e
           raise e unless e.name.to_s == inflector.camelize(slice_name) || e.name.to_s == :Slice
         end
@@ -119,11 +115,36 @@ module Hanami
       register(slice_name, slice_class)
     end
 
+    # Finds the path to the slice's definition file, if it exists, in the following order:
+    #
+    # 1. `config/slices/[slice_name].rb`
+    # 2. `slices/[parent_slice_name]/config/[slice_name].rb` (unless parent is the app)
+    # 3. `slices/[slice_name]/config/slice.rb`
+    #
+    # If the slice is nested under another slice then it will look in the following order:
+    #
+    # 1. `config/slices/[parent_slice_name]/[slice_name].rb`
+    # 2. `slices/[parent_slice_name]/config/[slice_name].rb`
+    # 3. `slices/[parent_slice_name]/[slice_name]/config/slice.rb`
+    def find_slice_require_path(slice_name)
+      app_slice_file_path = [slice_name]
+      app_slice_file_path.prepend(parent.slice_name) unless parent.eql?(parent.app)
+      ancestors = [
+        parent.app.root.join(CONFIG_DIR, SLICES_DIR, app_slice_file_path.join(File::SEPARATOR)),
+        parent.root.join(CONFIG_DIR, SLICES_DIR, slice_name),
+        root.join(SLICES_DIR, slice_name, CONFIG_DIR, "slice")
+      ]
+
+      ancestors
+        .uniq
+        .find { _1.sub_ext(RB_EXT).file? }
+        &.to_s
+    end
+
     def build_slice(slice_name, &block)
-      slice_module_name = inflector.camelize("#{parent_slice_namespace.name}#{PATH_DELIMITER}#{slice_name}")
       slice_module =
         begin
-          inflector.constantize(slice_module_name)
+          inflector.constantize(slice_module_name(slice_name))
         rescue NameError
           parent_slice_namespace.const_set(inflector.camelize(slice_name), Module.new)
         end
@@ -131,6 +152,10 @@ module Hanami
       slice_module.const_set(:Slice, Class.new(Hanami::Slice, &block))
     end
 
+    def slice_module_name(slice_name)
+      inflector.camelize("#{parent_slice_namespace.name}#{PATH_DELIMITER}#{slice_name}")
+    end
+
     def configure_slice(slice_name, slice)
       slice.instance_variable_set(:@parent, parent)
 

data/lib/hanami/version.rb

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

data/lib/hanami/web/rack_logger.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "delegate"
+require "json"
+
 module Hanami
   # @api private
   module Web
@@ -53,10 +56,75 @@ module Hanami
         end
       end
 
+      # @since 2.1.0
+      # @api private
+      class UniversalLogger
+        class << self
+          # @since 2.1.0
+          # @api private
+          def call(logger)
+            return logger if compatible_logger?(logger)
+
+            new(logger)
+          end
+
+          # @since 2.1.0
+          # @api private
+          alias_method :[], :call
+
+          private
+
+          def compatible_logger?(logger)
+            logger.respond_to?(:tagged) && accepts_entry_payload?(logger)
+          end
+
+          def accepts_entry_payload?(logger)
+            logger.method(:info).parameters.last.then { |type, _| type == :keyrest }
+          end
+        end
+
+        # @since 2.1.0
+        # @api private
+        attr_reader :logger
+
+        # @since 2.1.0
+        # @api private
+        def initialize(logger)
+          @logger = logger
+        end
+
+        # @since 2.1.0
+        # @api private
+        def tagged(*, &blk)
+          blk.call
+        end
+
+        # Logs the entry as JSON.
+        #
+        # This ensures a reasonable (and parseable) representation of our log payload structures for
+        # loggers that are configured to wholly replace Hanami's default logger.
+        #
+        # @since 2.1.0
+        # @api private
+        def info(message = nil, **payload)
+          payload[:message] = message if message
+          logger.info(JSON.fast_generate(payload))
+        end
+
+        # @see info
+        #
+        # @since 2.1.0
+        # @api private
+        def error(message = nil, **payload)
+          payload[:message] = message if message
+          logger.info(JSON.fast_generate(payload))
+        end
+      end
+
       # @api private
       # @since 2.0.0
       def initialize(logger, env: :development)
-        @logger = logger
+        @logger = UniversalLogger[logger]
         extend(Development) if %i[development test].include?(env)
       end
 
@@ -77,7 +145,7 @@ module Hanami
       # @since 2.0.0
       def log_request(env, status, elapsed)
         logger.tagged(:rack) do
-          logger.info(data(env, status: status, elapsed: elapsed))
+          logger.info(**data(env, status: status, elapsed: elapsed))
         end
       end
 

data/lib/hanami/web/welcome.html.erb

@@ -0,0 +1,203 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Hanami</title>
+  <style>
+    :root {
+      --max-width: 1024px;
+      --foreground-rgb: 0, 0, 0;
+      --background-rgb: 255, 255, 255;
+      --card-border-rgb: 200, 200, 200;
+      --card-background-rgb: 100, 100, 100;
+      --font-sans: ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;
+      --gradient: radial-gradient(circle at 50% 125%, rgba(255,202,212,1) 0%, rgba(255,202,212,0) 40%);
+    }
+
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --foreground-rgb: 255, 255, 255;
+        --background-rgb: 0, 0, 0;
+        --card-border-rgb: 200, 200, 200;
+        --card-background-rgb: 100, 100, 100;
+        --gradient: radial-gradient(circle at 50% 125%, rgba(255,73,108,0.75) 0%, rgba(255,73,108,0) 40%);
+      }
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    body,
+    html {
+      max-width: 100vw;
+      overflow-x: hidden;
+      font-size: 100%;
+    }
+
+    body {
+      color: rgb(var(--foreground-rgb));
+      background: var(--gradient) rgb(var(--background-rgb));
+      font-family: var(--font-sans);
+      font-style: normal;
+    }
+
+    main {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      padding: 2rem 8vw;
+      min-height: 100vh;
+    }
+
+    a {
+      text-decoration: none;
+      color: rgb(var(--foreground-rgb));
+    }
+
+    .welcome {
+      display: flex;
+      flex-direction: column;
+      gap: 2vh;
+      justify-content: center;
+      flex-grow: 3;
+      align-items: center;
+      text-align: center;
+      position: relative;
+      margin-bottom: 4vh;
+    }
+
+    .welcome .logo {
+      display: block;
+      width: 120px;
+      height: 120px;
+    }
+
+    .welcome h1 {
+      font-size: 2.625rem;
+      font-weight: 500;
+    }
+
+    .grid {
+      display: grid;
+      grid-template-columns: repeat(4, 1fr);
+      column-gap: 20px;
+      max-width: 100%;
+      margin-bottom: 8vh;
+      width: var(--max-width);
+    }
+
+    .card {
+      padding: 1rem;
+      border-radius: 12px;
+      border: 1px solid rgba(var(--card-border-rgb), 0.3);
+      background: rgba(var(--card-background-rgb), 0);
+      transition: background 200ms, border 200ms;
+    }
+
+    .card:hover {
+      background: rgba(var(--card-background-rgb), 0.05);
+    }
+
+    .card h2 {
+      font-size: 1.5rem;
+      font-weight: 500;
+      margin-bottom: 0.8rem;
+    }
+
+    .card p {
+      line-height: 1.5;
+      opacity: 0.6;
+    }
+
+    .meta {
+      text-align: center;
+      opacity: 50%;
+    }
+
+    /* Mobile */
+    @media (max-width: 700px) {
+
+      .welcome {
+        justify-content: top;
+        flex-grow: 0;
+        margin-bottom: 4rem;
+      }
+
+      .welcome .logo {
+        width: 90px;
+        height: 90px;
+      }
+
+      .welcome h1 {
+        font-size: 2rem;
+      }
+
+      .grid {
+        grid-template-columns: 1fr;
+        row-gap: 20px;
+      }
+
+      .card {
+        text-align: center;
+      }
+    }
+
+    /* Tablet and Smaller Desktop */
+    @media (min-width: 701px) and (max-width: 1120px) {
+      .grid {
+        grid-template-columns: repeat(2, 1fr);
+        gap: 20px;
+      }
+    }
+
+    @media (prefers-color-scheme: dark) {
+      html {
+        color-scheme: dark;
+      }
+      .card {
+        border: 1px solid rgba(var(--card-border-rgb), 0.15);
+        background: rgba(var(--card-background-rgb), 0);
+      }
+
+      .card:hover {
+        background: rgba(var(--card-background-rgb), 0.1);
+      }
+    }
+
+  </style>
+</head>
+<body>
+  <main>
+    <div class="welcome">
+      <img src="data:image/svg+xml,%3Csvg height='840' width='840' viewBox='0 0 840 840' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'%3E%3Cmask id='a' fill='%23fff'%3E%3Cpath d='m0 0h840v840h-840z' fill='%23fff' fill-rule='evenodd'/%3E%3C/mask%3E%3Cg fill='none' fill-rule='evenodd' mask='url(%23a)'%3E%3Cg transform='translate(-115.9919 -103.9919)'%3E%3Cg fill='%23dc3610'%3E%3Cpath d='m523.491853 126.991853 377.093909 273.974762-144.037057 443.300476h-466.113705l-144.037056-443.300476z' opacity='.6' transform='matrix(.91354546 .40673664 -.40673664 .91354546 258.181591 -167.665085)'/%3E%3Cpath d='m525.491853 129.991853 377.093909 273.974762-144.037057 443.300476h-466.113705l-144.037056-443.300476z' opacity='.8' transform='matrix(.97437006 .22495105 -.22495105 .97437006 131.903231 -104.716004)'/%3E%3Cpath d='m535.491853 130.991853 377.093909 273.974762-144.037057 443.300476h-466.113705l-144.037056-443.300476z'/%3E%3C/g%3E%3Cpath d='m534.991853 370.991853c86.156421 0 156 69.843579 156 156s-69.843579 156-156 156-156-69.843579-156-156 69.843579-156 156-156zm0 35c-66.826455 0-121 54.173545-121 121s54.173545 121 121 121 121-54.173545 121-121-54.173545-121-121-121z' fill='%23fff'/%3E%3Cpath d='m535.947441 478.991853 74.023116 90.999216-20.023116 27h-108l-19.978704-27z' fill='%23fff' transform='matrix(-1 0 0 -1 1071.9392 1075.983)'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E" alt="Hanani logo" class="logo">
+      <h1>Welcome to Hanami</h1>
+    </div>
+    <div class="grid">
+      <a href="https://guides.hanamirb.org" class="card">
+        <h2>Guides</h2>
+        <p>Get started with the Hanami guides</p>
+      </a>
+      <a href="https://docs.hanamirb.org/" class="card">
+        <h2>API docs</h2>
+        <p>Learn more through the API docs</p>
+      </a>
+      <a href="http://github.com/hanami" class="card">
+        <h2>Code</h2>
+        <p>Contribute to the source code</p>
+      </a>
+      <a href="https://discourse.hanamirb.org" class="card">
+        <h2>Forum</h2>
+        <p>Join the conversation on the forum</p>
+      </a>
+    </div>
+    <p class="meta">
+      Hanami version: <%= hanami_version %> • Ruby version: <%= ruby_version %>
+    </p>
+  </main>
+</body>
+</html>

data/lib/hanami/web/welcome.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Hanami
+  # @api private
+  module Web
+    # Middleware that renders a welcome view in fresh Hanami apps.
+    #
+    # @api private
+    # @since 2.1.0
+    class Welcome
+      # @api private
+      # @since 2.1.0
+      def initialize(app)
+        @app = app
+      end
+
+      # @api private
+      # @since 2.1.0
+      def call(env)
+        request_path = env["REQUEST_PATH"] || ""
+        request_host = env["HTTP_HOST"] || ""
+
+        template_path = File.join(__dir__, "welcome.html.erb")
+        body = [ERB.new(File.read(template_path)).result(binding)]
+
+        [200, {}, body]
+      end
+
+      private
+
+      # @api private
+      # @since 2.1.0
+      def hanami_version
+        Hanami::VERSION
+      end
+
+      # @api private
+      # @since 2.1.0
+      def ruby_version
+        RUBY_DESCRIPTION
+      end
+    end
+  end
+end

data/spec/integration/assets/assets_spec.rb

@@ -18,6 +18,19 @@ RSpec.describe "Assets", :app_integration do
         end
       RUBY
 
+      write "config/assets.mjs", <<~JS
+        import * as assets from "hanami-assets";
+        await assets.run();
+      JS
+
+      write "package.json", <<~JSON
+        {
+          "scripts": {
+            "assets": "node config/assets.mjs"
+          }
+        }
+      JSON
+
       write "config/routes.rb", <<~RUBY
         module TestApp
           class Routes < Hanami::Routes
@@ -62,10 +75,8 @@ RSpec.describe "Assets", :app_integration do
       RUBY
 
       write "app/templates/posts/show.html.erb", <<~ERB
-        <%= stylesheet_link_tag("app") %>
-        <%= css("app") %>
+        <%= stylesheet_tag("app") %>
         <%= javascript_tag("app") %>
-        <%= js("app") %>
       ERB
 
       write "app/assets/js/app.ts", <<~TS

data/spec/integration/logging/request_logging_spec.rb

@@ -11,6 +11,8 @@ RSpec.describe "Logging / Request logging", :app_integration do
 
   let(:logger_stream) { StringIO.new }
 
+  let(:root) { make_tmp_directory }
+
   def configure_logger
     Hanami.app.config.logger.stream = logger_stream
   end
@@ -19,14 +21,18 @@ RSpec.describe "Logging / Request logging", :app_integration do
     @logs ||= (logger_stream.rewind and logger_stream.read)
   end
 
+  def generate_app
+    write "config/app.rb", <<~RUBY
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+    RUBY
+  end
+
   before do
-    with_directory(make_tmp_directory) do
-      write "config/app.rb", <<~RUBY
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
+    with_directory(root) do
+      generate_app
 
       require "hanami/setup"
       configure_logger
@@ -125,4 +131,56 @@ RSpec.describe "Logging / Request logging", :app_integration do
       end
     end
   end
+
+  context "when using ::Logger from Ruby stdlib" do
+    def generate_app
+      write "config/app.rb", <<~RUBY
+        require "logger"
+        require "pathname"
+
+        module TestApp
+          class App < Hanami::App
+            stream = Pathname.new(#{root.to_s.inspect}).join("log").tap(&:mkpath).join("test.log").to_s
+            config.logger = ::Logger.new(stream, progname: "custom-logger-app")
+          end
+        end
+      RUBY
+    end
+
+    def before_prepare
+      with_directory(root) do
+        write "config/routes.rb", <<~RUBY
+          module TestApp
+            class Routes < Hanami::Routes
+              root to: ->(env) { [200, {}, ["OK"]] }
+            end
+          end
+        RUBY
+      end
+    end
+
+    let(:logs) do
+      Pathname.new(root).join("log", "test.log").readlines
+    end
+
+    it "logs the requests with the payload serialized as JSON" do
+      get "/"
+
+      request_log = logs.last
+
+      # Expected log line follows the standard Logger structure:
+      #
+      # I, [2023-10-14T14:55:16.638753 #94836]  INFO -- custom-logger-app: {"verb":"GET", ...}
+      expect(request_log).to match(%r{INFO -- custom-logger-app:})
+
+      # The log message should be JSON, after the progname
+      log_message = request_log.split("custom-logger-app: ").last
+      log_payload = JSON.parse(log_message, symbolize_names: true)
+
+      expect(log_payload).to include(
+        verb: "GET",
+        status: 200
+      )
+    end
+  end
 end