tina4ruby 0.5.2 → 3.0.0

data/lib/tina4/dev_mailbox.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "time"
+require "fileutils"
+require "base64"
+
+module Tina4
+  class DevMailbox
+    attr_reader :mailbox_dir
+
+    def initialize(mailbox_dir: nil)
+      @mailbox_dir = mailbox_dir || ENV["TINA4_MAILBOX_DIR"] || "data/mailbox"
+      ensure_dirs
+    end
+
+    # Capture an outgoing email to the local filesystem instead of sending
+    def capture(to:, subject:, body:, html: false, cc: [], bcc: [],
+                reply_to: nil, from_address: nil, from_name: nil, attachments: [])
+      msg_id = SecureRandom.uuid
+      timestamp = Time.now
+
+      message = {
+        id: msg_id,
+        from: { name: from_name, email: from_address },
+        to: normalize_recipients(to),
+        cc: normalize_recipients(cc),
+        bcc: normalize_recipients(bcc),
+        reply_to: reply_to,
+        subject: subject,
+        body: body,
+        html: html,
+        attachments: store_attachments(msg_id, attachments),
+        read: false,
+        folder: "outbox",
+        created_at: timestamp.iso8601,
+        updated_at: timestamp.iso8601
+      }
+
+      write_message(msg_id, message)
+
+      Tina4::Log.debug("DevMailbox captured email: #{subject} -> #{Array(to).join(', ')}")
+      { success: true, message: "Email captured to dev mailbox", id: msg_id }
+    end
+
+    # List messages in the mailbox
+    def inbox(limit: 50, offset: 0, folder: nil)
+      messages = load_all_messages
+      messages = messages.select { |m| m[:folder] == folder } if folder
+      messages.sort_by { |m| m[:created_at] || "" }.reverse[offset, limit] || []
+    end
+
+    # Read a single message by ID
+    def read(msg_id)
+      path = message_path(msg_id)
+      return nil unless File.exist?(path)
+
+      message = JSON.parse(File.read(path), symbolize_names: true)
+      unless message[:read]
+        message[:read] = true
+        message[:updated_at] = Time.now.iso8601
+        File.write(path, JSON.pretty_generate(message))
+      end
+      message
+    end
+
+    # Count unread messages
+    def unread_count
+      load_all_messages.count { |m| m[:read] == false }
+    end
+
+    # Delete a message by ID
+    def delete(msg_id)
+      path = message_path(msg_id)
+      return false unless File.exist?(path)
+
+      File.delete(path)
+      # Clean up attachments directory
+      att_dir = File.join(@mailbox_dir, "attachments", msg_id)
+      FileUtils.rm_rf(att_dir) if Dir.exist?(att_dir)
+      true
+    end
+
+    # Clear all messages, optionally by folder
+    def clear(folder: nil)
+      if folder
+        load_all_messages.each do |msg|
+          delete(msg[:id]) if msg[:folder] == folder
+        end
+      else
+        messages_dir = File.join(@mailbox_dir, "messages")
+        FileUtils.rm_rf(messages_dir)
+        FileUtils.rm_rf(File.join(@mailbox_dir, "attachments"))
+        ensure_dirs
+      end
+    end
+
+    # Seed the mailbox with sample messages for development
+    def seed(count: 5)
+      fake = Tina4::FakeData.new
+      count.times do |i|
+        name = fake.name
+        email = fake.email(from_name: name)
+        capture(
+          to: "dev@localhost",
+          subject: fake.sentence(words: 4 + rand(4)),
+          body: Array.new(2 + rand(3)) { fake.sentence(words: 8 + rand(8)) }.join("\n\n"),
+          html: i.even?,
+          from_address: email,
+          from_name: name
+        )
+      end
+      Tina4::Log.info("DevMailbox seeded with #{count} messages")
+    end
+
+    # Count messages by folder
+    # Returns { inbox: N, outbox: N, total: N }
+    def count(folder: nil)
+      messages = load_all_messages
+      if folder
+        n = messages.count { |m| m[:folder] == folder }
+        { folder.to_sym => n, total: n }
+      else
+        inbox_count = messages.count { |m| m[:folder] == "inbox" }
+        outbox_count = messages.count { |m| m[:folder] == "outbox" }
+        { inbox: inbox_count, outbox: outbox_count, total: messages.length }
+      end
+    end
+
+    private
+
+    def ensure_dirs
+      FileUtils.mkdir_p(File.join(@mailbox_dir, "messages"))
+      FileUtils.mkdir_p(File.join(@mailbox_dir, "attachments"))
+    end
+
+    def message_path(msg_id)
+      File.join(@mailbox_dir, "messages", "#{msg_id}.json")
+    end
+
+    def write_message(msg_id, message)
+      File.write(message_path(msg_id), JSON.pretty_generate(message))
+    end
+
+    def load_all_messages
+      pattern = File.join(@mailbox_dir, "messages", "*.json")
+      Dir.glob(pattern).filter_map do |path|
+        JSON.parse(File.read(path), symbolize_names: true)
+      rescue JSON::ParserError => e
+        Tina4::Log.error("DevMailbox: corrupt message file #{path}: #{e.message}")
+        nil
+      end
+    end
+
+    def normalize_recipients(value)
+      case value
+      when nil then []
+      when String then [value]
+      when Array then value.flatten.compact
+      else [value.to_s]
+      end
+    end
+
+    def store_attachments(msg_id, attachments)
+      return [] if attachments.nil? || attachments.empty?
+
+      att_dir = File.join(@mailbox_dir, "attachments", msg_id)
+      FileUtils.mkdir_p(att_dir)
+
+      attachments.map do |attachment|
+        if attachment.is_a?(Hash)
+          filename = attachment[:filename] || attachment[:name] || "attachment"
+          content = attachment[:content] || ""
+          mime = attachment[:mime_type] || attachment[:content_type] || "application/octet-stream"
+        elsif attachment.is_a?(String) && File.exist?(attachment)
+          filename = File.basename(attachment)
+          content = File.binread(attachment)
+          mime = "application/octet-stream"
+        else
+          next nil
+        end
+
+        file_path = File.join(att_dir, filename)
+        File.binwrite(file_path, content)
+
+        { filename: filename, mime_type: mime, size: content.bytesize, path: file_path }
+      end.compact
+    end
+  end
+end

data/lib/tina4/dev_reload.rb

@@ -17,25 +17,25 @@ module Tina4
         # Also watch root for .rb files
         dirs << root_dir
 
-        Tina4::Debug.info("Dev reload watching: #{dirs.join(', ')}")
+        Tina4::Log.info("Dev reload watching: #{dirs.join(', ')}")
 
         @listener = Listen.to(*dirs, only: /\.(#{WATCH_EXTENSIONS.map { |e| e.delete('.') }.join('|')})$/, ignore: build_ignore_regex) do |modified, added, removed|
           changes = { modified: modified, added: added, removed: removed }
           all_files = modified + added + removed
           next if all_files.empty?
 
-          Tina4::Debug.info("File changes detected:")
-          modified.each { |f| Tina4::Debug.debug("  Modified: #{f}") }
-          added.each { |f| Tina4::Debug.debug("  Added: #{f}") }
-          removed.each { |f| Tina4::Debug.debug("  Removed: #{f}") }
+          Tina4::Log.info("File changes detected:")
+          modified.each { |f| Tina4::Log.debug("  Modified: #{f}") }
+          added.each { |f| Tina4::Log.debug("  Added: #{f}") }
+          removed.each { |f| Tina4::Log.debug("  Removed: #{f}") }
 
           # Reload Ruby files
           modified.select { |f| f.end_with?(".rb") }.each do |file|
             begin
               load file
-              Tina4::Debug.info("Reloaded: #{file}")
+              Tina4::Log.info("Reloaded: #{file}")
             rescue => e
-              Tina4::Debug.error("Reload failed: #{file} - #{e.message}")
+              Tina4::Log.error("Reload failed: #{file} - #{e.message}")
             end
           end
 
@@ -49,12 +49,12 @@ module Tina4
         end
 
         @listener.start
-        Tina4::Debug.info("Dev reload started")
+        Tina4::Log.info("Dev reload started")
       end
 
       def stop
         @listener&.stop
-        Tina4::Debug.info("Dev reload stopped")
+        Tina4::Log.info("Dev reload stopped")
       end
 
       private

data/lib/tina4/drivers/firebird_driver.rb

@@ -5,10 +5,26 @@ module Tina4
     class FirebirdDriver
       attr_reader :connection
 
-      def connect(connection_string)
+      def connect(connection_string, username: nil, password: nil)
         require "fb"
-        db_path = connection_string.sub(/^firebird:\/\//, "")
-        @connection = Fb::Database.new(database: db_path).connect
+        require "uri"
+        uri = URI.parse(connection_string)
+        host = uri.host
+        port = uri.port || 3050
+        db_path = uri.path&.sub(/^\//, "")
+        db_user = username || uri.user
+        db_pass = password || uri.password
+
+        database = if host
+                     "#{host}/#{port}:#{db_path}"
+                   else
+                     db_path || connection_string.sub(/^firebird:\/\//, "")
+                   end
+
+        opts = { database: database }
+        opts[:username] = db_user if db_user
+        opts[:password] = db_pass if db_pass
+        @connection = Fb::Database.new(**opts).connect
       rescue LoadError
         raise "Firebird driver requires the 'fb' gem. Install it with: gem install fb"
       end

data/lib/tina4/drivers/mssql_driver.rb

@@ -5,14 +5,14 @@ module Tina4
     class MssqlDriver
       attr_reader :connection
 
-      def connect(connection_string)
+      def connect(connection_string, username: nil, password: nil)
         require "tiny_tds"
         uri = parse_connection(connection_string)
         @connection = TinyTds::Client.new(
           host: uri[:host],
           port: uri[:port] || 1433,
-          username: uri[:username],
-          password: uri[:password],
+          username: username || uri[:username],
+          password: password || uri[:password],
           database: uri[:database]
         )
       end

data/lib/tina4/drivers/mysql_driver.rb

@@ -5,14 +5,14 @@ module Tina4
     class MysqlDriver
       attr_reader :connection
 
-      def connect(connection_string)
+      def connect(connection_string, username: nil, password: nil)
         require "mysql2"
-        uri = URI.parse(connection_string.sub(/^mysql:\/\//, "mysql2://"))
+        uri = URI.parse(connection_string)
         @connection = Mysql2::Client.new(
           host: uri.host || "localhost",
           port: uri.port || 3306,
-          username: uri.user,
-          password: uri.password,
+          username: username || uri.user,
+          password: password || uri.password,
           database: uri.path&.sub("/", "")
         )
       end

data/lib/tina4/drivers/postgres_driver.rb

@@ -5,9 +5,16 @@ module Tina4
     class PostgresDriver
       attr_reader :connection
 
-      def connect(connection_string)
+      def connect(connection_string, username: nil, password: nil)
         require "pg"
-        @connection = PG.connect(connection_string)
+        url = connection_string
+        if username || password
+          uri = URI.parse(url)
+          uri.user = username if username
+          uri.password = password if password
+          url = uri.to_s
+        end
+        @connection = PG.connect(url)
       end
 
       def close

data/lib/tina4/drivers/sqlite_driver.rb

@@ -5,7 +5,7 @@ module Tina4
     class SqliteDriver
       attr_reader :connection
 
-      def connect(connection_string)
+      def connect(connection_string, username: nil, password: nil)
         require "sqlite3"
         db_path = connection_string.sub(/^sqlite:\/\//, "").sub(/^sqlite:/, "")
         @connection = SQLite3::Database.new(db_path)

data/lib/tina4/env.rb

@@ -7,12 +7,21 @@ module Tina4
       "PROJECT_NAME" => "Tina4 Ruby Project",
       "VERSION" => "1.0.0",
       "TINA4_LANGUAGE" => "en",
-      "TINA4_DEBUG_LEVEL" => "[TINA4_LOG_ALL]",
+      "TINA4_DEBUG" => "true",
+      "TINA4_LOG_LEVEL" => "[TINA4_LOG_ALL]",
       "SECRET" => "tina4-secret-change-me"
     }.freeze
 
+    # Check if a value is truthy for env boolean checks.
+    #
+    # Accepts: "true", "True", "TRUE", "1", "yes", "Yes", "YES", "on", "On", "ON".
+    # Everything else is falsy (including empty string, nil, not set).
+    def self.truthy?(val)
+      %w[true 1 yes on].include?(val.to_s.strip.downcase)
+    end
+
     class << self
-      def load(root_dir = Dir.pwd)
+      def load_env(root_dir = Dir.pwd)
         env_file = resolve_env_file(root_dir)
         unless File.exist?(env_file)
           create_default_env(env_file)
@@ -20,6 +29,35 @@ module Tina4
         parse_env_file(env_file)
       end
 
+      # Get an env var value, with optional default
+      def get_env(key, default = nil)
+        ENV[key.to_s] || default
+      end
+
+      # Check if an env var exists
+      def has_env?(key)
+        ENV.key?(key.to_s)
+      end
+
+      # Return all current ENV vars as a hash
+      def all_env
+        ENV.to_h
+      end
+
+      # Raise if any of the given keys are missing from ENV
+      def require_env!(*keys)
+        missing = keys.map(&:to_s).reject { |k| ENV.key?(k) }
+        unless missing.empty?
+          raise KeyError, "Missing required env vars: #{missing.join(', ')}"
+        end
+      end
+
+      # Reset: clear all env vars that were loaded (restore to process defaults)
+      def reset_env
+        @loaded_keys&.each { |k| ENV.delete(k) }
+        @loaded_keys = []
+      end
+
       private
 
       def resolve_env_file(root_dir)
@@ -47,6 +85,8 @@ module Tina4
             key = match[1]
             value = match[2].gsub(/["']\z/, "")
             ENV[key] ||= value
+            @loaded_keys ||= []
+            @loaded_keys << key
           end
         end
       end

data/lib/tina4/error_overlay.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+# Tina4 Debug — Rich error overlay for development mode.
+#
+# Renders a professional, syntax-highlighted HTML error page when an unhandled
+# exception occurs in a route handler.
+#
+#   begin
+#     handler.call(request, response)
+#   rescue => e
+#     Tina4::ErrorOverlay.render(e, request: env)
+#   end
+#
+# Only activate when TINA4_DEBUG is true.
+# In production, call Tina4::ErrorOverlay.render_production instead.
+
+module Tina4
+  module ErrorOverlay
+    # ── Colour palette (Catppuccin Mocha) ──────────────────────────────
+    BG            = "#1e1e2e"
+    SURFACE       = "#313244"
+    OVERLAY_COLOR = "#45475a"
+    TEXT_COLOR    = "#cdd6f4"
+    SUBTEXT       = "#a6adc8"
+    RED           = "#f38ba8"
+    YELLOW        = "#f9e2af"
+    BLUE          = "#89b4fa"
+    GREEN         = "#a6e3a1"
+    LAVENDER      = "#b4befe"
+    PEACH         = "#fab387"
+    ERROR_LINE_BG = "rgba(243,139,168,0.15)"
+
+    CONTEXT_LINES = 7
+
+    class << self
+      # Render a rich HTML error overlay.
+      #
+      # @param exception [Exception] the caught exception
+      # @param request [Hash, nil] optional request details (Rack env or custom hash)
+      # @return [String] complete HTML page
+      def render(exception, request: nil)
+        exc_type = exception.class.name
+        exc_msg  = exception.message
+
+        # ── Stack trace ──
+        frames_html = +""
+        backtrace = exception.backtrace || []
+        backtrace.each do |line|
+          file, lineno, method = parse_backtrace_line(line)
+          frames_html << format_frame(file, lineno, method)
+        end
+
+        # ── Request info ──
+        request_pairs = []
+        if request.is_a?(Hash)
+          request.each do |k, v|
+            key = k.to_s
+            if v.is_a?(Hash)
+              v.each { |hk, hv| request_pairs << ["#{key}.#{hk}", hv.to_s] }
+            elsif key.start_with?("HTTP_") || %w[REQUEST_METHOD REQUEST_URI SERVER_PROTOCOL
+              REMOTE_ADDR SERVER_PORT QUERY_STRING CONTENT_TYPE CONTENT_LENGTH
+              method url path].include?(key)
+              request_pairs << [key, v.to_s]
+            end
+          end
+        end
+        request_section = request_pairs.empty? ? "" : collapsible("Request Details", table(request_pairs))
+
+        # ── Environment ──
+        env_pairs = [
+          ["Framework", "Tina4 Ruby"],
+          ["Version", defined?(Tina4::VERSION) ? Tina4::VERSION : "unknown"],
+          ["Ruby", RUBY_VERSION],
+          ["Platform", RUBY_PLATFORM],
+          ["Debug", ENV.fetch("TINA4_DEBUG", "false")],
+          ["Log Level", ENV.fetch("TINA4_LOG_LEVEL", "ERROR")]
+        ]
+        env_section = collapsible("Environment", table(env_pairs))
+        stack_section = collapsible("Stack Trace", frames_html, open_by_default: true)
+
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+          <meta charset="utf-8">
+          <meta name="viewport" content="width=device-width,initial-scale=1">
+          <title>Tina4 Error — #{esc(exc_type)}</title>
+          <style>
+          *{margin:0;padding:0;box-sizing:border-box;}
+          body{background:#{BG};color:#{TEXT_COLOR};font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;padding:24px;line-height:1.5;}
+          </style>
+          </head>
+          <body>
+          <div style="max-width:960px;margin:0 auto;">
+            <div style="margin-bottom:24px;">
+              <div style="display:flex;align-items:center;gap:12px;margin-bottom:12px;">
+                <span style="background:#{RED};color:#{BG};padding:4px 12px;border-radius:4px;font-weight:700;font-size:13px;text-transform:uppercase;">Error</span>
+                <span style="color:#{SUBTEXT};font-size:14px;">Tina4 Debug Overlay</span>
+              </div>
+              <h1 style="color:#{RED};font-size:28px;font-weight:700;margin-bottom:8px;">#{esc(exc_type)}</h1>
+              <p style="color:#{TEXT_COLOR};font-size:18px;font-family:'SF Mono','Fira Code','Consolas',monospace;background:#{SURFACE};padding:12px 16px;border-radius:6px;border-left:4px solid #{RED};">#{esc(exc_msg)}</p>
+            </div>
+            #{stack_section}
+            #{request_section}
+            #{env_section}
+            <div style="margin-top:32px;padding-top:16px;border-top:1px solid #{OVERLAY_COLOR};color:#{SUBTEXT};font-size:12px;">
+              Tina4 Debug Overlay &mdash; This page is only shown in debug mode. Set TINA4_DEBUG=false in production.
+            </div>
+          </div>
+          </body>
+          </html>
+        HTML
+      end
+
+      # Render a safe, generic error page for production.
+      def render_production(status_code: 500, message: "Internal Server Error", path: "")
+        # Determine color based on status code
+        code_color = case status_code
+                     when 403 then "#f59e0b"
+                     when 404 then "#3b82f6"
+                     else "#ef4444"
+                     end
+
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+          <meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <title>#{status_code} — #{esc(message)}</title>
+          <style>
+          * { box-sizing: border-box; margin: 0; padding: 0; }
+          body { font-family: system-ui, -apple-system, sans-serif; background: #0f172a; color: #e2e8f0; min-height: 100vh; display: flex; align-items: center; justify-content: center; }
+          .error-card { background: #1e293b; border: 1px solid #334155; border-radius: 1rem; padding: 3rem; text-align: center; max-width: 520px; width: 90%; }
+          .error-code { font-size: 8rem; font-weight: 900; color: #{code_color}; opacity: 0.6; line-height: 1; margin-bottom: 0.5rem; }
+          .error-title { font-size: 1.5rem; font-weight: 700; margin-bottom: 0.75rem; }
+          .error-msg { color: #94a3b8; font-size: 1rem; margin-bottom: 1.5rem; line-height: 1.5; }
+          .error-path { font-family: 'SF Mono', monospace; background: #0f172a; color: #{code_color}; padding: 0.5rem 1rem; border-radius: 0.5rem; font-size: 0.85rem; word-break: break-all; margin-bottom: 1.5rem; display: inline-block; }
+          .error-home { display: inline-block; padding: 0.6rem 2rem; background: #3b82f6; color: #fff; text-decoration: none; border-radius: 0.5rem; font-size: 0.9rem; font-weight: 600; }
+          .error-home:hover { opacity: 0.9; }
+          .logo { font-size: 1.5rem; margin-bottom: 1rem; opacity: 0.5; }
+          </style>
+          </head>
+          <body>
+          <div class="error-card">
+              <div class="error-code">#{status_code}</div>
+              <div class="error-title">#{esc(message)}</div>
+              <div class="error-msg">Something went wrong while processing your request.</div>
+              #{path.to_s.empty? ? '' : "<div class=\"error-path\">#{esc(path)}</div><br>"}
+              <a href="/" class="error-home">Go Home</a>
+          </div>
+          </body>
+          </html>
+        HTML
+      end
+
+      # Return true if TINA4_DEBUG is enabled.
+      def debug_mode?
+        Tina4::Env.truthy?(ENV.fetch("TINA4_DEBUG", ""))
+      end
+
+      private
+
+      def esc(text)
+        text.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&#39;")
+      end
+
+      def parse_backtrace_line(line)
+        if line =~ /\A(.+):(\d+):in [`'](.+)'\z/
+          [$1, $2.to_i, $3]
+        elsif line =~ /\A(.+):(\d+)\z/
+          [$1, $2.to_i, "{main}"]
+        else
+          [line, 0, "{unknown}"]
+        end
+      end
+
+      def read_source_lines(filename, lineno)
+        return [] unless filename && lineno.positive? && File.file?(filename) && File.readable?(filename)
+
+        all_lines = File.readlines(filename, chomp: true)
+        start_idx = [0, lineno - CONTEXT_LINES - 1].max
+        end_idx   = [all_lines.length, lineno + CONTEXT_LINES].min
+        (start_idx...end_idx).map do |i|
+          num = i + 1
+          [num, all_lines[i] || "", num == lineno]
+        end
+      rescue StandardError
+        []
+      end
+
+      def format_source_block(filename, lineno)
+        lines = read_source_lines(filename, lineno)
+        return "" if lines.empty?
+
+        rows = lines.map do |num, text, is_error|
+          bg = is_error ? "background:#{ERROR_LINE_BG};" : ""
+          marker = is_error ? "&#x25b6;" : " "
+          "<div style=\"#{bg}display:flex;padding:1px 0;\">" \
+            "<span style=\"color:#{YELLOW};min-width:3.5em;text-align:right;padding-right:1em;user-select:none;\">#{num}</span>" \
+            "<span style=\"color:#{RED};width:1.2em;user-select:none;\">#{marker}</span>" \
+            "<span style=\"color:#{TEXT_COLOR};white-space:pre-wrap;tab-size:4;\">#{esc(text)}</span>" \
+            "</div>"
+        end.join("\n")
+
+        "<div style=\"background:#{SURFACE};border-radius:6px;padding:12px;overflow-x:auto;" \
+          "font-family:'SF Mono','Fira Code','Consolas',monospace;font-size:13px;line-height:1.6;\">" \
+          "#{rows}</div>"
+      end
+
+      def format_frame(filename, lineno, func_name)
+        source = (filename && lineno.positive?) ? format_source_block(filename, lineno) : ""
+        "<div style=\"margin-bottom:16px;\">" \
+          "<div style=\"margin-bottom:4px;\">" \
+          "<span style=\"color:#{BLUE};\">#{esc(filename.to_s)}</span>" \
+          "<span style=\"color:#{SUBTEXT};\"> : </span>" \
+          "<span style=\"color:#{YELLOW};\">#{lineno}</span>" \
+          "<span style=\"color:#{SUBTEXT};\"> in </span>" \
+          "<span style=\"color:#{GREEN};\">#{esc(func_name.to_s)}</span>" \
+          "</div>" \
+          "#{source}" \
+          "</div>"
+      end
+
+      def collapsible(title, content, open_by_default: false)
+        open_attr = open_by_default ? " open" : ""
+        "<details style=\"margin-top:16px;\"#{open_attr}>" \
+          "<summary style=\"cursor:pointer;color:#{LAVENDER};font-weight:600;font-size:15px;" \
+          "padding:8px 0;user-select:none;\">#{esc(title)}</summary>" \
+          "<div style=\"padding:8px 0;\">#{content}</div>" \
+          "</details>"
+      end
+
+      def table(pairs)
+        return "<span style=\"color:#{SUBTEXT};\">None</span>" if pairs.empty?
+
+        rows = pairs.map do |key, val|
+          "<tr>" \
+            "<td style=\"color:#{PEACH};padding:4px 16px 4px 0;vertical-align:top;white-space:nowrap;\">#{esc(key)}</td>" \
+            "<td style=\"color:#{TEXT_COLOR};padding:4px 0;word-break:break-all;\">#{esc(val)}</td>" \
+            "</tr>"
+        end.join
+        "<table style=\"border-collapse:collapse;width:100%;\">#{rows}</table>"
+      end
+    end
+  end
+end