solid_web_ui 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c473be31f5f3992b41cfca6aaf1855045104194afa6507947110feb311d374ee
-  data.tar.gz: '059154707b3a45e39a94904824c7dca137170549f0f7a8bf52432c51aa11a898'
+  metadata.gz: 9036bf52798c82718cce437f3ba58c1ca43f5f325d4a185bc7fb942a1dadfed7
+  data.tar.gz: fc33a3c5f65913a9aa9f59e5d3e1578a8ec89ba38a76cea55b4e79b38c980bea
 SHA512:
-  metadata.gz: a1a32a7e4292847fb8fa0ecd9df72d8e5c1b8211ac91eed54043373956015e7435a46720e4857d274fa8ba8ca6adeb5e5d1af576b95e3950cb037d20083c099d
-  data.tar.gz: d0b391dde5552ab3152edb019427c6caf0fbb77e545fc013580fe0f3491dd9f24ec71dd5399a26140c34dc9029663b25e86248a316a6be211dac63acada112a8
+  metadata.gz: ce886a4c5e21b2aa6fe722281338fb07619fb6302b9577cd2e736ec6381b14d797191715a54f25c149dfc31b212fda51fc5937c90f20c4df86240d0526446333
+  data.tar.gz: 855442dad92195d237732c456662472fe03b9daca0e07a72cff4f334913a0f0249582465f193adf5fa40ec650d0b6feb8688e99593443c5eb19ab755e23c6ccf

data/app/assets/javascripts/solid_web_ui.js

@@ -123,3 +123,23 @@
   document.addEventListener("turbo:load", bindAll);
   window.setInterval(tick, TICK_MS);
 })();
+
+// Clickable table rows: a row carrying data-swui-row-href navigates to that URL.
+// A single delegated listener (bound once, survives frame morphs). Clicks on an
+// inner link/button keep their own behaviour, and modified/middle clicks are left
+// to the browser so "open in new tab" still works via the row's ID link.
+(function () {
+  "use strict";
+
+  document.addEventListener("click", function (event) {
+    if (event.defaultPrevented || event.button !== 0 || event.metaKey ||
+        event.ctrlKey || event.shiftKey || event.altKey) return;
+    if (event.target.closest("a, button, input, label, select, textarea")) return;
+
+    var row = event.target.closest("tr[data-swui-row-href]");
+    if (!row) return;
+
+    var href = row.getAttribute("data-swui-row-href");
+    if (href) window.location.assign(href);
+  });
+})();

data/app/assets/stylesheets/solid_web_ui.css

@@ -2,9 +2,30 @@
 @layer properties;
 @layer theme, components, utilities;
 @layer utilities {
+  .visible {
+    visibility: visible;
+  }
   .static {
     position: static;
   }
+  .container {
+    width: 100%;
+    @media (width >= 40rem) {
+      max-width: 40rem;
+    }
+    @media (width >= 48rem) {
+      max-width: 48rem;
+    }
+    @media (width >= 64rem) {
+      max-width: 64rem;
+    }
+    @media (width >= 80rem) {
+      max-width: 80rem;
+    }
+    @media (width >= 96rem) {
+      max-width: 96rem;
+    }
+  }
   .block {
     display: block;
   }
@@ -14,6 +35,9 @@
   .hidden {
     display: none;
   }
+  .table {
+    display: table;
+  }
   .filter {
     filter: var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,);
   }
@@ -29,8 +53,17 @@
   .solid-web-ui *, .solid-web-ui *::before, .solid-web-ui *::after {
     box-sizing: border-box;
   }
+  .solid-web-ui[data-color-scheme="light"] {
+    color-scheme: light;
+  }
+  .solid-web-ui[data-color-scheme="dark"] {
+    color-scheme: dark;
+  }
+  .solid-web-ui[data-color-scheme="auto"] {
+    color-scheme: light dark;
+  }
   .solid-web-ui .swui-page {
-    max-width: 72rem;
+    max-width: var(--swui-page-max-width, 72rem);
     margin-inline: auto;
     padding: 1.5rem;
   }
@@ -224,6 +257,15 @@
   .solid-web-ui .swui-table tr:last-child td {
     border-bottom: 0;
   }
+  .solid-web-ui .swui-table tbody tr[data-swui-row-href] {
+    cursor: pointer;
+  }
+  .solid-web-ui .swui-table tbody tr[data-swui-row-href]:hover {
+    background: var(--swui-color-primary);
+    @supports (color: color-mix(in lab, red, red)) {
+      background: color-mix(in srgb, var(--swui-color-primary) 8%, transparent);
+    }
+  }
   .solid-web-ui .swui-table__empty td {
     text-align: center;
     color: var(--swui-color-muted);
@@ -280,6 +322,157 @@
     font-weight: 600;
     margin: 1.5rem 0 0.75rem;
   }
+  .solid-web-ui .swui-back {
+    display: inline-block;
+    margin-bottom: 1rem;
+    color: var(--swui-color-muted);
+    text-decoration: none;
+    font-size: 0.85rem;
+  }
+  .solid-web-ui .swui-back:hover {
+    color: var(--swui-color-text);
+  }
+  .solid-web-ui .swui-detail {
+    display: grid;
+    grid-template-columns: minmax(8rem, 14rem) 1fr;
+    gap: 0;
+    margin: 0 0 1.5rem;
+    background: var(--swui-color-surface);
+    border: 1px solid var(--swui-color-border);
+    border-radius: var(--swui-radius);
+    overflow: hidden;
+    font-size: 0.9rem;
+  }
+  .solid-web-ui .swui-detail dt, .solid-web-ui .swui-detail dd {
+    padding: 0.6rem 0.85rem;
+    border-bottom: 1px solid var(--swui-color-border);
+    margin: 0;
+  }
+  .solid-web-ui .swui-detail dt {
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    color: var(--swui-color-muted);
+    background: var(--swui-color-muted);
+    @supports (color: color-mix(in lab, red, red)) {
+      background: color-mix(in srgb, var(--swui-color-muted) 6%, transparent);
+    }
+  }
+  .solid-web-ui .swui-detail > dt:last-of-type, .solid-web-ui .swui-detail > dd:last-of-type {
+    border-bottom: 0;
+  }
+  .solid-web-ui .swui-detail__hint {
+    text-transform: none;
+    letter-spacing: 0;
+    opacity: 0.8;
+  }
+  .solid-web-ui .swui-flash-region {
+    max-width: var(--swui-page-max-width, 72rem);
+    margin-inline: auto;
+    padding: 1.5rem 1.5rem 0;
+  }
+  .solid-web-ui .swui-flash {
+    padding: 0.6rem 0.85rem;
+    margin-bottom: 1rem;
+    border: 1px solid var(--swui-color-border);
+    border-radius: var(--swui-radius);
+    font-size: 0.9rem;
+  }
+  .solid-web-ui .swui-flash--notice {
+    border-color: var(--swui-color-success);
+    background: var(--swui-color-success);
+    @supports (color: color-mix(in lab, red, red)) {
+      background: color-mix(in srgb, var(--swui-color-success) 14%, transparent);
+    }
+  }
+  .solid-web-ui .swui-flash--alert {
+    border-color: var(--swui-color-danger);
+    background: var(--swui-color-danger);
+    @supports (color: color-mix(in lab, red, red)) {
+      background: color-mix(in srgb, var(--swui-color-danger) 14%, transparent);
+    }
+  }
+  .solid-web-ui .swui-actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    margin-bottom: 1rem;
+  }
+  .solid-web-ui .swui-form {
+    max-width: 48rem;
+    margin-bottom: 1.5rem;
+  }
+  .solid-web-ui .swui-field {
+    margin-bottom: 1rem;
+  }
+  .solid-web-ui .swui-fieldset {
+    margin: 0 0 1rem;
+    padding: 1rem 1.1rem 0.25rem;
+    border: 1px solid var(--swui-color-border);
+    border-radius: var(--swui-radius);
+  }
+  .solid-web-ui .swui-fieldset legend {
+    padding: 0 0.4rem;
+  }
+  .solid-web-ui .swui-label {
+    display: block;
+    margin-bottom: 0.35rem;
+    font-size: 0.8rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    color: var(--swui-color-muted);
+  }
+  .solid-web-ui .swui-input, .solid-web-ui .swui-textarea {
+    width: 100%;
+    padding: 0.5rem 0.65rem;
+    border: 1px solid var(--swui-color-border);
+    border-radius: var(--swui-radius);
+    background: var(--swui-color-surface);
+    color: var(--swui-color-text);
+    font: inherit;
+    font-size: 0.9rem;
+  }
+  .solid-web-ui .swui-textarea {
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    line-height: 1.45;
+    resize: vertical;
+  }
+  .solid-web-ui .swui-input:focus, .solid-web-ui .swui-textarea:focus {
+    outline: none;
+    border-color: var(--swui-color-primary);
+  }
+  .solid-web-ui .swui-input:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+  }
+  .solid-web-ui .swui-hint {
+    margin: 0.35rem 0 0;
+    font-size: 0.8rem;
+    color: var(--swui-color-muted);
+  }
+  .solid-web-ui .swui-form__actions {
+    display: flex;
+    gap: 0.5rem;
+    margin-top: 1.25rem;
+  }
+  .solid-web-ui .swui-codeblock {
+    margin: 0;
+    padding: 0.75rem;
+    max-height: 24rem;
+    overflow: auto;
+    background: var(--swui-color-muted);
+    @supports (color: color-mix(in lab, red, red)) {
+      background: color-mix(in srgb, var(--swui-color-muted) 8%, transparent);
+    }
+    border: 1px solid var(--swui-color-border);
+    border-radius: var(--swui-radius);
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    font-size: 0.8rem;
+    line-height: 1.45;
+    white-space: pre;
+    color: var(--swui-color-text);
+  }
 }
 @property --tw-blur {
   syntax: "*";

data/app/controllers/solid_web_ui/cable/application_controller.rb

@@ -7,6 +7,10 @@ module SolidWebUi::Cable
 
     private
 
+    def per_page
+      SolidWebUi::Cable.config.per_page
+    end
+
     def trimmable_scope
       SolidCable::Message.where(created_at: ...SolidWebUi::Cable.config.retention.ago)
     end

data/app/controllers/solid_web_ui/cable/channels_controller.rb

@@ -3,11 +3,25 @@
 module SolidWebUi::Cable
   class ChannelsController < ApplicationController
     def index
-      counts = SolidCable::Message.group(:channel).count
+      counts = SolidCable::Message.group(:channel, :channel_hash).count
       last_seen = SolidCable::Message.group(:channel).maximum(:created_at)
       @channels = counts
-                  .map { |channel, count| { name: channel, count: count, last: last_seen[channel] } }
+                  .map { |(channel, hash), count| { name: channel, hash: hash, count: count, last: last_seen[channel] } }
                   .sort_by { |row| -row[:count] }
     end
+
+    def show
+      scope = SolidCable::Message.where(channel_hash: params[:channel_hash])
+      @name = scope.limit(1).pick(:channel)
+      raise ActiveRecord::RecordNotFound if @name.nil?
+
+      @channel_hash = params[:channel_hash]
+      @count = scope.count
+      @first = scope.minimum(:created_at)
+      @last = scope.maximum(:created_at)
+
+      @paginator = SolidWebUi::Paginator.new(scope.order(id: :desc), page: params[:page], per_page: per_page)
+      @messages = @paginator.records
+    end
   end
 end

data/app/controllers/solid_web_ui/cable/messages_controller.rb

@@ -4,6 +4,10 @@ module SolidWebUi::Cable
   class MessagesController < ApplicationController
     before_action :ensure_trim_enabled, only: :trim
 
+    def show
+      @message = SolidCable::Message.find(params[:id])
+    end
+
     def trim
       deleted = trimmable_scope.delete_all
       redirect_to root_path, notice: "Trimmed #{deleted} old message(s)."

data/app/controllers/solid_web_ui/cache/entries_controller.rb

@@ -2,12 +2,94 @@
 
 module SolidWebUi::Cache
   class EntriesController < ApplicationController
-    before_action :ensure_clear_enabled, only: :clear
+    before_action :ensure_clear_enabled,  only: :clear
+    before_action :ensure_create_enabled, only: %i[new create]
+    before_action :ensure_edit_enabled,   only: %i[edit update]
+    before_action :ensure_delete_enabled, only: :destroy
+    before_action :set_entry, only: %i[show edit update destroy]
 
     def index
       scope = SolidCache::Entry.order(id: :desc)
       @paginator = SolidWebUi::Paginator.new(scope, page: params[:page], per_page: per_page)
       @entries = @paginator.records
+      # Per-entry expiry, read from each cache envelope's header (no value
+      # deserialization). Numeric epoch = has a TTL, :never = decodable but no
+      # TTL, :undecodable = couldn't be read.
+      @expiry = @entries.to_h { |entry| [ entry.id, entry_expiry(entry) ] }
+    end
+
+    def show
+      @decoded = decode_value(@entry.value)
+      value = resolved_value(@decoded)
+      @value_readable = value != UNREADABLE
+      @value_text = value.is_a?(String) ? value : value.inspect if @value_readable
+    end
+
+    def new
+      @key = ""
+      @value = ""
+      @expires_at = ""
+      @version = ""
+    end
+
+    def create
+      @key = params[:key].to_s
+      @value = params[:value].to_s
+      @expires_at = params[:expires_at].to_s
+      @version = params[:version].to_s
+
+      if @key.empty?
+        return render_new_error("Key can't be blank.")
+      elsif SolidCache::Entry.read(@key)
+        return render_new_error("An entry with that key already exists.")
+      end
+
+      expires_at = parse_expires_at(@expires_at)
+      SolidCache::Entry.write(@key, encode_entry(@value, version: @version.presence, expires_at: expires_at))
+      redirect_to entries_path, notice: "Entry created."
+    rescue InvalidExpiry
+      render_new_error("Couldn't parse the expiry time.")
+    end
+
+    def edit
+      decoded = decode_value(@entry.value)
+      value = resolved_value(decoded)
+      @value_editable = value.is_a?(String)
+      @meta_editable = value != UNREADABLE
+      @key = scrub_for_display(@entry.key)
+      @expires_at = format_expires_at(decoded)
+      @version = (decoded.version if decoded.respond_to?(:version)).to_s
+
+      if @value_editable
+        @value = value
+      elsif @meta_editable
+        @value = value.inspect
+        @note = "This entry holds a #{value.class} (not a plain string), so the value is " \
+                "read-only — but you can still change its metadata below."
+      else
+        @value = scrub_for_display(@entry.value)
+        @note = "This value couldn't be read as a cache entry (it may use a different cache format " \
+                "or reference a class this app can't load), so it can't be edited here."
+      end
+    end
+
+    def update
+      value = resolved_value(decode_value(@entry.value))
+      if value == UNREADABLE
+        return redirect_to edit_entry_path(@entry), alert: "This entry can't be edited."
+      end
+
+      value = params[:value].to_s if value.is_a?(String)
+      expires_at = parse_expires_at(params[:expires_at])
+      SolidCache::Entry.write(@entry.key, encode_entry(value, version: params[:version].presence, expires_at: expires_at))
+      redirect_to entry_path(@entry), notice: "Entry updated."
+    rescue InvalidExpiry
+      redirect_to edit_entry_path(@entry), alert: "Couldn't parse the expiry time."
+    end
+
+    def destroy
+      @entry.destroy
+      redirect_to entries_path, notice: "Entry deleted."
     end
 
     def clear
@@ -17,8 +99,107 @@ module SolidWebUi::Cache
 
     private
 
+    InvalidExpiry = Class.new(StandardError)
+
+    # Sentinel for a value that can't be read — either the entry didn't decode, or
+    # its envelope decoded but resolving the value raised (a LazyEntry resolves on
+    # first access and can fail, e.g. a Marshal value for a class this app can't load).
+    UNREADABLE = Object.new.freeze
+    private_constant :UNREADABLE
+
+    def set_entry
+      @entry = SolidCache::Entry.find(params[:id])
+    end
+
+    def render_new_error(message)
+      flash.now[:alert] = message
+      render :new, status: :unprocessable_entity
+    end
+
+    # Resolve a decoded entry's value, returning UNREADABLE if it can't be read.
+    def resolved_value(decoded)
+      return UNREADABLE unless decoded.respond_to?(:value)
+
+      decoded.value
+    rescue StandardError
+      UNREADABLE
+    end
+
+    # The cache store whose coder matches how these entries were written. Prefer the
+    # host's Rails.cache when it is the Solid Cache store (exact format match), and
+    # fall back to a default Solid Cache store otherwise.
+    def cache_store
+      @cache_store ||=
+        if defined?(SolidCache::Store) && Rails.cache.is_a?(SolidCache::Store)
+          Rails.cache
+        else
+          ActiveSupport::Cache.lookup_store(:solid_cache_store)
+        end
+    end
+
+    # Expiry of a single entry for the index: epoch Float, :never, or :undecodable.
+    def entry_expiry(entry)
+      decoded = decode_value(entry.value)
+      return :undecodable unless decoded.respond_to?(:expires_at)
+
+      decoded.expires_at || :never
+    end
+
+    # Raw stored bytes -> ActiveSupport::Cache::Entry (or nil if undecodable).
+    def decode_value(raw)
+      cache_store.send(:deserialize_entry, raw.to_s)
+    rescue StandardError
+      nil
+    end
+
+    # A value + metadata -> serialized cache-entry bytes.
+    def encode_entry(value, version:, expires_at:)
+      entry = ActiveSupport::Cache::Entry.new(value, version: version, expires_at: expires_at)
+      cache_store.send(:serialize_entry, entry)
+    end
+
+    def cache_time_zone
+      ActiveSupport::TimeZone[SolidWebUi::Cache.config.time_zone] || ActiveSupport::TimeZone["UTC"]
+    end
+
+    # Absolute epoch on the decoded entry -> a datetime-local value (YYYY-MM-DDThh:mm:ss)
+    # in the dashboard's time zone.
+    def format_expires_at(decoded)
+      epoch = decoded.expires_at if decoded.respond_to?(:expires_at)
+      return "" unless epoch
+
+      Time.at(epoch).in_time_zone(cache_time_zone).strftime("%Y-%m-%dT%H:%M:%S")
+    rescue StandardError
+      "" # a corrupt/out-of-range epoch shouldn't break the form
+    end
+
+    # Form string (in the dashboard's time zone) -> a Time, or nil for "no expiry".
+    def parse_expires_at(str)
+      return nil if str.blank?
+
+      cache_time_zone.parse(str) || raise(InvalidExpiry)
+    rescue ArgumentError, RangeError, TypeError
+      raise InvalidExpiry
+    end
+
+    def scrub_for_display(bytes)
+      bytes.to_s.dup.force_encoding("UTF-8").scrub("?")
+    end
+
     def ensure_clear_enabled
       head :forbidden unless SolidWebUi::Cache.config.enable_clear
     end
+
+    def ensure_create_enabled
+      head :forbidden unless SolidWebUi::Cache.config.enable_create
+    end
+
+    def ensure_edit_enabled
+      head :forbidden unless SolidWebUi::Cache.config.enable_edit
+    end
+
+    def ensure_delete_enabled
+      head :forbidden unless SolidWebUi::Cache.config.enable_delete
+    end
   end
 end

data/app/controllers/solid_web_ui/queue/jobs_controller.rb

@@ -20,5 +20,12 @@ module SolidWebUi::Queue
       @paginator = SolidWebUi::Paginator.new(scope, page: params[:page], per_page: per_page)
       @jobs = @paginator.records
     end
+
+    def show
+      @job = SolidQueue::Job
+             .includes(:ready_execution, :scheduled_execution, :claimed_execution,
+                       :blocked_execution, :failed_execution)
+             .find(params[:id])
+    end
   end
 end

data/app/helpers/solid_web_ui/cable/application_helper.rb

@@ -9,8 +9,13 @@ module SolidWebUi::Cable
       ]
     end
 
-    def readable_channel(channel)
-      truncate(channel.to_s.dup.force_encoding("UTF-8").scrub("?"), length: 80)
+    def readable_channel(channel, length: 80)
+      truncate(channel.to_s.dup.force_encoding("UTF-8").scrub("?"), length: length)
+    end
+
+    # Cable payloads are binary; present a scrubbed, truncated preview.
+    def readable_payload(payload, length: 120)
+      truncate(payload.to_s.dup.force_encoding("UTF-8").scrub("?"), length: length)
     end
 
     def short_time(time)

data/app/helpers/solid_web_ui/cache/application_helper.rb

@@ -10,8 +10,35 @@ module SolidWebUi::Cache
     end
 
     # Cache keys are stored as binary; present them as readable, truncated text.
-    def readable_key(key)
-      truncate(key.to_s.dup.force_encoding("UTF-8").scrub("?"), length: 80)
+    def readable_key(key, length: 80)
+      truncate(key.to_s.dup.force_encoding("UTF-8").scrub("?"), length: length)
+    end
+
+    # Cache values are binary (often a Marshal/compressed blob). Present a scrubbed,
+    # truncated preview so the show page never dumps megabytes of unreadable bytes.
+    def readable_value(value, length: 2000)
+      truncate(value.to_s.dup.force_encoding("UTF-8").scrub("?"), length: length)
+    end
+
+    # Absolute expiry of a cache entry (see EntriesController#entry_expiry).
+    def cache_expires_at(expiry)
+      case expiry
+      when Numeric then short_time(Time.at(expiry))
+      when :never  then "Never"
+      else "—"
+      end
+    rescue StandardError
+      "—" # a corrupt/out-of-range epoch shouldn't break the list
+    end
+
+    # Remaining time until a cache entry expires, e.g. "about 2 hours" / "expired".
+    def cache_time_to_expire(expiry)
+      return "—" unless expiry.is_a?(Numeric)
+
+      remaining = expiry - Time.now.to_f
+      return "expired" if remaining <= 0
+
+      distance_of_time_in_words(remaining)
     end
 
     def short_time(time)

data/app/helpers/solid_web_ui/queue/application_helper.rb

@@ -29,6 +29,34 @@ module SolidWebUi::Queue
       queue.respond_to?(:human_latency) ? queue.human_latency : queue.latency
     end
 
+    # Best available execution time for a job. Solid Queue does not persist a job's
+    # start time once it finishes (the claimed_execution row is deleted on finish),
+    # so:
+    #   - finished job  → finished_at - created_at (total time in the system)
+    #   - claimed job   → now - claimed_execution.created_at (live run time)
+    #   - anything else → nil (no meaningful duration yet)
+    def job_duration(job)
+      if job.finished_at?
+        human_duration(job.finished_at - job.created_at)
+      elsif job.claimed_execution
+        human_duration(Time.current - job.claimed_execution.created_at)
+      end
+    end
+
+    # Compact, sub-minute-precise duration: "1.2s", "3m 04s", "2h 01m".
+    def human_duration(seconds)
+      return "—" if seconds.nil?
+
+      seconds = seconds.to_f
+      return format("%.1fs", seconds) if seconds < 60
+
+      if seconds < 3600
+        format("%dm %02ds", seconds / 60, seconds % 60)
+      else
+        format("%dh %02dm", seconds / 3600, (seconds % 3600) / 60)
+      end
+    end
+
     def short_time(time)
       return "—" if time.nil?
 

data/app/views/layouts/solid_web_ui.html.erb

@@ -8,6 +8,18 @@
   <%= solid_web_ui_head_tags %>
 </head>
 <body>
+  <%# Flash lives in the gem's own layout only. When the dashboards are embedded %>
+  <%# in a host layout (config.layout = "your_layout"), the host renders flash, so %>
+  <%# rendering it here too would duplicate it. %>
+  <% if flash.any? %>
+    <div class="solid-web-ui" data-color-scheme="<%= SolidWebUi.config.color_scheme %>">
+      <div class="swui-flash-region">
+        <% flash.each do |type, message| %>
+          <div class="swui-flash swui-flash--<%= type.to_s == "alert" ? "alert" : "notice" %>"><%= message %></div>
+        <% end %>
+      </div>
+    </div>
+  <% end %>
   <%= yield %>
 </body>
 </html>

data/app/views/solid_web_ui/cable/channels/index.html.erb

@@ -2,8 +2,8 @@
 <%= swui_page(title: "Channels", nav: cable_nav(:channels)) do %>
   <%= swui_table(headers: [ "Channel", "Messages", "Last activity" ], empty_message: "No channels.") do %>
     <% @channels.each do |row| %>
-      <tr>
-        <td><code><%= readable_channel(row[:name]) %></code></td>
+      <tr data-swui-row-href="<%= channel_path(row[:hash]) %>">
+        <td><%= link_to channel_path(row[:hash]), data: { turbo_frame: "_top" } do %><code><%= readable_channel(row[:name]) %></code><% end %></td>
         <td><%= number_with_delimiter(row[:count]) %></td>
         <td><%= short_time(row[:last]) %></td>
       </tr>

data/app/views/solid_web_ui/cable/channels/show.html.erb

@@ -0,0 +1,35 @@
+<% title = readable_channel(@name) %>
+<% content_for :title, "Channel #{title}" %>
+<%= swui_page(title: "Channel", nav: cable_nav(:channels), refresh: false) do %>
+  <%= link_to "← Back to channels", channels_path, class: "swui-back" %>
+
+  <dl class="swui-detail">
+    <dt>Channel</dt>
+    <dd><code><%= readable_channel(@name, length: 1024) %></code></dd>
+
+    <dt>Channel hash</dt>
+    <dd><code><%= @channel_hash %></code></dd>
+
+    <dt>Messages</dt>
+    <dd><%= number_with_delimiter(@count) %></dd>
+
+    <dt>First activity</dt>
+    <dd><%= short_time(@first) %></dd>
+
+    <dt>Last activity</dt>
+    <dd><%= short_time(@last) %></dd>
+  </dl>
+
+  <h2 class="swui-section-title">Recent messages</h2>
+  <%= swui_table(headers: [ "ID", "Payload", "Created" ], empty_message: "No messages.") do %>
+    <% @messages.each do |message| %>
+      <tr data-swui-row-href="<%= message_path(message) %>">
+        <td><%= link_to message.id, message_path(message) %></td>
+        <td><code><%= readable_payload(message.payload) %></code></td>
+        <td><%= short_time(message.created_at) %></td>
+      </tr>
+    <% end %>
+  <% end %>
+
+  <%= swui_paginator(paginator: @paginator, page_url: ->(page) { channel_path(@channel_hash, page: page) }) %>
+<% end %>

data/app/views/solid_web_ui/cable/messages/show.html.erb

@@ -0,0 +1,21 @@
+<% content_for :title, "Message ##{@message.id}" %>
+<%= swui_page(title: "Message ##{@message.id}", nav: cable_nav(:channels), refresh: false) do %>
+  <%= link_to "← Back to channel", channel_path(@message.channel_hash), class: "swui-back" %>
+
+  <dl class="swui-detail">
+    <dt>ID</dt>
+    <dd><%= @message.id %></dd>
+
+    <dt>Channel</dt>
+    <dd><code><%= readable_channel(@message.channel, length: 1024) %></code></dd>
+
+    <dt>Channel hash</dt>
+    <dd><code><%= @message.channel_hash %></code></dd>
+
+    <dt>Created</dt>
+    <dd><%= short_time(@message.created_at) %></dd>
+
+    <dt>Payload</dt>
+    <dd><pre class="swui-codeblock"><%= readable_payload(@message.payload, length: 100_000) %></pre></dd>
+  </dl>
+<% end %>

data/app/views/solid_web_ui/cache/entries/_form.html.erb

@@ -0,0 +1,47 @@
+<%= form_with url: url, method: method, class: "swui-form" do |f| %>
+  <div class="swui-field">
+    <label class="swui-label" for="entry_key">Key</label>
+    <% if new_record %>
+      <%= text_field_tag :key, key, id: "entry_key", class: "swui-input", autocomplete: "off" %>
+    <% else %>
+      <input id="entry_key" class="swui-input" value="<%= key %>" disabled>
+      <p class="swui-hint">The key identifies the entry and can't be changed — delete and recreate to rename.</p>
+    <% end %>
+  </div>
+
+  <div class="swui-field">
+    <label class="swui-label" for="entry_value">Value</label>
+    <% if note %>
+      <div class="swui-flash swui-flash--alert"><%= note %></div>
+    <% end %>
+    <%= text_area_tag :value, value, id: "entry_value", class: "swui-textarea", rows: 12, disabled: !value_editable %>
+    <% if value_editable %>
+      <p class="swui-hint">Saved through the cache encoder, so <code>Rails.cache</code> reads it back
+        as a string.</p>
+    <% end %>
+  </div>
+
+  <fieldset class="swui-fieldset">
+    <legend class="swui-label">Metadata</legend>
+    <div class="swui-field">
+      <label class="swui-label" for="entry_expires_at">Expires at</label>
+      <%= text_field_tag :expires_at, expires_at, id: "entry_expires_at", class: "swui-input",
+                         type: "datetime-local", step: 1, disabled: !meta_editable %>
+      <p class="swui-hint">Time zone <code><%= SolidWebUi::Cache.config.time_zone %></code>. Leave blank for no expiry.</p>
+    </div>
+
+    <div class="swui-field">
+      <label class="swui-label" for="entry_version">Version</label>
+      <%= text_field_tag :version, version, id: "entry_version", class: "swui-input",
+                         autocomplete: "off", disabled: !meta_editable %>
+      <p class="swui-hint">Used by <code>Rails.cache</code>'s <code>:version</code> option. Leave blank for none.</p>
+    </div>
+  </fieldset>
+
+  <div class="swui-form__actions">
+    <% if meta_editable %>
+      <%= f.submit(new_record ? "Create entry" : "Save changes", class: "swui-btn") %>
+    <% end %>
+    <%= link_to "Cancel", cancel_url, class: "swui-btn" %>
+  </div>
+<% end %>

data/app/views/solid_web_ui/cache/entries/edit.html.erb

@@ -0,0 +1,9 @@
+<% content_for :title, "Edit cache entry ##{@entry.id}" %>
+<%= swui_page(title: "Edit cache entry ##{@entry.id}", nav: cache_nav(:entries), refresh: false) do %>
+  <%= link_to "← Back to entry", entry_path(@entry), class: "swui-back" %>
+
+  <%= render "form", url: entry_path(@entry), method: :patch, new_record: false,
+                     value_editable: @value_editable, meta_editable: @meta_editable, note: @note,
+                     cancel_url: entry_path(@entry),
+                     key: @key, value: @value, expires_at: @expires_at, version: @version %>
+<% end %>

data/app/views/solid_web_ui/cache/entries/index.html.erb

@@ -1,12 +1,26 @@
 <% content_for :title, "Cache entries" %>
 <%= swui_page(title: "Cache entries", nav: cache_nav(:entries)) do %>
-  <%= swui_table(headers: [ "ID", "Key", "Size", "Created" ], empty_message: "The cache is empty.") do %>
+  <% if SolidWebUi::Cache.config.enable_create %>
+    <div class="swui-actions">
+      <%= link_to "+ New entry", new_entry_path, class: "swui-btn", data: { turbo_frame: "_top" } %>
+    </div>
+  <% end %>
+
+  <% headers = [ "ID", "Key", "Size", "Created", "Expires", "Time to expire" ] %>
+  <% headers << "" if SolidWebUi::Cache.config.enable_delete %>
+  <%= swui_table(headers: headers, empty_message: "The cache is empty.") do %>
     <% @entries.each do |entry| %>
-      <tr>
-        <td><%= entry.id %></td>
+      <tr data-swui-row-href="<%= entry_path(entry) %>">
+        <td><%= link_to entry.id, entry_path(entry), data: { turbo_frame: "_top" } %></td>
         <td><code><%= readable_key(entry.key) %></code></td>
         <td><%= number_to_human_size(entry.byte_size) %></td>
         <td><%= short_time(entry.created_at) %></td>
+        <td><%= cache_expires_at(@expiry[entry.id]) %></td>
+        <td><%= cache_time_to_expire(@expiry[entry.id]) %></td>
+        <% if SolidWebUi::Cache.config.enable_delete %>
+          <td><%= swui_action_button(label: "Delete", url: entry_path(entry), method: :delete,
+                                     danger: true, confirm: "Delete this cache entry?") %></td>
+        <% end %>
       </tr>
     <% end %>
   <% end %>

data/app/views/solid_web_ui/cache/entries/new.html.erb

@@ -0,0 +1,8 @@
+<% content_for :title, "New cache entry" %>
+<%= swui_page(title: "New cache entry", nav: cache_nav(:entries), refresh: false) do %>
+  <%= link_to "← Back to entries", entries_path, class: "swui-back" %>
+
+  <%= render "form", url: entries_path, method: :post, new_record: true,
+                     value_editable: true, meta_editable: true, note: nil, cancel_url: entries_path,
+                     key: @key, value: @value, expires_at: @expires_at, version: @version %>
+<% end %>

data/app/views/solid_web_ui/cache/entries/show.html.erb

@@ -0,0 +1,50 @@
+<% content_for :title, "Cache entry ##{@entry.id}" %>
+<%= swui_page(title: "Cache entry ##{@entry.id}", nav: cache_nav(:entries), refresh: false) do %>
+  <%= link_to "← Back to entries", entries_path, class: "swui-back" %>
+
+  <dl class="swui-detail">
+    <dt>ID</dt>
+    <dd><%= @entry.id %></dd>
+
+    <dt>Key</dt>
+    <dd><code><%= readable_key(@entry.key, length: 1024) %></code></dd>
+
+    <dt>Key hash</dt>
+    <dd><code><%= @entry.key_hash %></code></dd>
+
+    <dt>Size</dt>
+    <dd><%= number_to_human_size(@entry.byte_size) %> (<%= number_with_delimiter(@entry.byte_size) %> bytes)</dd>
+
+    <dt>Created</dt>
+    <dd><%= short_time(@entry.created_at) %></dd>
+
+    <% if @decoded.respond_to?(:expires_at) %>
+      <dt>Expires</dt>
+      <dd><%= @decoded.expires_at ? short_time(Time.at(@decoded.expires_at)) : "Never" %></dd>
+    <% end %>
+
+    <% if @decoded.respond_to?(:version) %>
+      <dt>Version</dt>
+      <dd><%= @decoded.version.presence || "—" %></dd>
+    <% end %>
+
+    <dt>Value<% unless @value_readable %> <span class="swui-detail__hint">(raw — unreadable)</span><% end %></dt>
+    <dd>
+      <% if @value_readable %>
+        <pre class="swui-codeblock"><%= @value_text %></pre>
+      <% else %>
+        <pre class="swui-codeblock"><%= readable_value(@entry.value) %></pre>
+      <% end %>
+    </dd>
+  </dl>
+
+  <div class="swui-actions">
+    <% if SolidWebUi::Cache.config.enable_edit %>
+      <%= link_to "Edit", edit_entry_path(@entry), class: "swui-btn", data: { turbo_frame: "_top" } %>
+    <% end %>
+    <% if SolidWebUi::Cache.config.enable_delete %>
+      <%= swui_action_button(label: "Delete", url: entry_path(@entry), method: :delete,
+                             danger: true, confirm: "Delete this cache entry?") %>
+    <% end %>
+  </div>
+<% end %>

data/app/views/solid_web_ui/queue/jobs/index.html.erb

@@ -9,8 +9,8 @@
 
   <%= swui_table(headers: [ "ID", "Job", "Queue", "Status", "Created" ], empty_message: "No jobs.") do %>
     <% @jobs.each do |job| %>
-      <tr>
-        <td><%= job.id %></td>
+      <tr data-swui-row-href="<%= job_path(job) %>">
+        <td><%= link_to job.id, job_path(job), data: { turbo_frame: "_top" } %></td>
         <td><%= job.class_name %></td>
         <td><%= job.queue_name %></td>
         <td><%= swui_status_badge(label: job_status(job).to_s.humanize, status: job_status(job)) %></td>

data/app/views/solid_web_ui/queue/jobs/show.html.erb

@@ -0,0 +1,62 @@
+<% content_for :title, "Job ##{@job.id}" %>
+<%= swui_page(title: "Job ##{@job.id}", nav: queue_nav(:jobs), refresh: false) do %>
+  <%= link_to "← Back to jobs", jobs_path, class: "swui-back" %>
+
+  <dl class="swui-detail">
+    <dt>ID</dt>
+    <dd><%= @job.id %></dd>
+
+    <dt>Job</dt>
+    <dd><%= @job.class_name %></dd>
+
+    <dt>Queue</dt>
+    <dd><%= @job.queue_name %></dd>
+
+    <dt>Status</dt>
+    <dd><%= swui_status_badge(label: job_status(@job).to_s.humanize, status: job_status(@job)) %></dd>
+
+    <dt>Priority</dt>
+    <dd><%= @job.priority %></dd>
+
+    <dt>Active Job ID</dt>
+    <dd><code><%= @job.active_job_id || "—" %></code></dd>
+
+    <dt>Enqueued</dt>
+    <dd><%= short_time(@job.created_at) %></dd>
+
+    <dt>Scheduled</dt>
+    <dd><%= short_time(@job.scheduled_at) %></dd>
+
+    <dt>Finished</dt>
+    <dd><%= short_time(@job.finished_at) %></dd>
+
+    <dt>Duration<% if @job.finished_at? %> <span class="swui-detail__hint">(enqueue → finish)</span><% end %></dt>
+    <dd><%= job_duration(@job) || "—" %></dd>
+
+    <dt>Arguments</dt>
+    <dd><pre class="swui-codeblock"><%= JSON.pretty_generate(@job.arguments) rescue @job.arguments.inspect %></pre></dd>
+  </dl>
+
+  <% if (failed = @job.failed_execution) %>
+    <h2 class="swui-section-title">Error</h2>
+    <dl class="swui-detail">
+      <dt>Exception</dt>
+      <dd><%= swui_status_badge(label: failed.exception_class.to_s, status: :failed) %></dd>
+
+      <dt>Message</dt>
+      <dd><%= failed.message %></dd>
+
+      <dt>Failed at</dt>
+      <dd><%= short_time(failed.created_at) %></dd>
+
+      <dt>Backtrace</dt>
+      <dd>
+        <% if failed.backtrace.present? %>
+          <pre class="swui-codeblock"><%= Array(failed.backtrace).join("\n") %></pre>
+        <% else %>
+          —
+        <% end %>
+      </dd>
+    </dl>
+  <% end %>
+<% end %>

data/lib/solid_web_ui/cable/routes.rb

@@ -3,5 +3,7 @@
 SolidWebUi::Cable::Engine.routes.draw do
   root to: "dashboard#index"
   get "channels", to: "channels#index", as: :channels
+  get "channels/:channel_hash", to: "channels#show", as: :channel
   delete "messages/trim", to: "messages#trim", as: :trim_messages
+  get "messages/:id", to: "messages#show", as: :message
 end

data/lib/solid_web_ui/cache/routes.rb

@@ -2,6 +2,14 @@
 
 SolidWebUi::Cache::Engine.routes.draw do
   root to: "dashboard#index"
+
   get "entries", to: "entries#index", as: :entries
+  get "entries/new", to: "entries#new", as: :new_entry
+  post "entries", to: "entries#create"
   delete "entries", to: "entries#clear", as: :clear_entries
+
+  get "entries/:id", to: "entries#show", as: :entry
+  get "entries/:id/edit", to: "entries#edit", as: :edit_entry
+  patch "entries/:id", to: "entries#update"
+  delete "entries/:id", to: "entries#destroy", as: :delete_entry
 end

data/lib/solid_web_ui/cache.rb

@@ -11,6 +11,9 @@ module SolidWebUi
     config.page_title = "Solid Cache"
 
     setting :enable_clear, default: true
+    setting :enable_create, default: true
+    setting :enable_edit, default: true
+    setting :enable_delete, default: true
   end
 end
 

data/lib/solid_web_ui/queue/routes.rb

@@ -8,6 +8,7 @@ SolidWebUi::Queue::Engine.routes.draw do
   post "queues/:name/resume", to: "queues#resume", as: :resume_queue, constraints: { name: %r{[^/]+} }
 
   get "jobs", to: "jobs#index", as: :jobs
+  get "jobs/:id", to: "jobs#show", as: :job
 
   get "failed", to: "failed_executions#index", as: :failed_executions
   post "failed/:id/retry", to: "failed_executions#retry", as: :retry_failed_execution

data/lib/solid_web_ui/theme.rb

@@ -21,7 +21,10 @@ module SolidWebUi
       color_warning: [ "--swui-color-warning", "var(--color-warning, #d97706)" ],
       color_danger: [ "--swui-color-danger", "var(--color-danger, #dc2626)" ],
       font: [ "--swui-font", "var(--swui-host-font, ui-sans-serif, system-ui, sans-serif)" ],
-      radius: [ "--swui-radius", "0.5rem" ]
+      radius: [ "--swui-radius", "0.5rem" ],
+      # Max width of the centered page column. Set to "none" or "100%" to let the
+      # dashboards fill their container (useful when embedded in a host layout).
+      page_max_width: [ "--swui-page-max-width", "72rem" ]
     }.freeze
 
     # Dark scheme only re-points the surface/text family; brand color stays.

data/lib/solid_web_ui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidWebUi
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_web_ui
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Anton Radushev
@@ -151,12 +151,19 @@ files:
 - app/helpers/solid_web_ui/queue/application_helper.rb
 - app/views/layouts/solid_web_ui.html.erb
 - app/views/solid_web_ui/cable/channels/index.html.erb
+- app/views/solid_web_ui/cable/channels/show.html.erb
 - app/views/solid_web_ui/cable/dashboard/index.html.erb
+- app/views/solid_web_ui/cable/messages/show.html.erb
 - app/views/solid_web_ui/cache/dashboard/index.html.erb
+- app/views/solid_web_ui/cache/entries/_form.html.erb
+- app/views/solid_web_ui/cache/entries/edit.html.erb
 - app/views/solid_web_ui/cache/entries/index.html.erb
+- app/views/solid_web_ui/cache/entries/new.html.erb
+- app/views/solid_web_ui/cache/entries/show.html.erb
 - app/views/solid_web_ui/queue/dashboard/index.html.erb
 - app/views/solid_web_ui/queue/failed_executions/index.html.erb
 - app/views/solid_web_ui/queue/jobs/index.html.erb
+- app/views/solid_web_ui/queue/jobs/show.html.erb
 - app/views/solid_web_ui/queue/processes/index.html.erb
 - app/views/solid_web_ui/queue/queues/index.html.erb
 - app/views/solid_web_ui/queue/recurring_tasks/index.html.erb