solid_web_ui 0.1.0

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SolidWebUi::Queue
+  class FailedExecutionsController < ApplicationController
+    before_action :ensure_retry_enabled, only: :retry
+    before_action :ensure_discard_enabled, only: :discard
+
+    def index
+      scope = SolidQueue::FailedExecution.includes(:job).order(id: :desc)
+      @paginator = SolidWebUi::Paginator.new(scope, page: params[:page], per_page: per_page)
+      @failed = @paginator.records
+    end
+
+    def retry
+      SolidQueue::FailedExecution.find(params[:id]).retry
+      redirect_to failed_executions_path, notice: "Job re-enqueued."
+    end
+
+    def discard
+      SolidQueue::FailedExecution.find(params[:id]).job.destroy
+      redirect_to failed_executions_path, notice: "Failed job discarded."
+    end
+
+    private
+
+    def ensure_retry_enabled
+      head :forbidden unless SolidWebUi::Queue.config.enable_retry
+    end
+
+    def ensure_discard_enabled
+      head :forbidden unless SolidWebUi::Queue.config.enable_discard
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SolidWebUi::Queue
+  class JobsController < ApplicationController
+    STATUS_SCOPES = {
+      "ready" => -> { SolidQueue::Job.where(id: SolidQueue::ReadyExecution.select(:job_id)) },
+      "scheduled" => -> { SolidQueue::Job.where(id: SolidQueue::ScheduledExecution.select(:job_id)) },
+      "in_progress" => -> { SolidQueue::Job.where(id: SolidQueue::ClaimedExecution.select(:job_id)) },
+      "blocked" => -> { SolidQueue::Job.where(id: SolidQueue::BlockedExecution.select(:job_id)) },
+      "failed" => -> { SolidQueue::Job.where(id: SolidQueue::FailedExecution.select(:job_id)) },
+      "finished" => -> { SolidQueue::Job.where.not(finished_at: nil) }
+    }.freeze
+
+    def index
+      @status = params[:status].presence_in(STATUS_SCOPES.keys) || "all"
+      scope = (STATUS_SCOPES[@status]&.call || SolidQueue::Job.all)
+              .includes(:ready_execution, :scheduled_execution, :claimed_execution, :blocked_execution, :failed_execution)
+              .order(id: :desc)
+
+      @paginator = SolidWebUi::Paginator.new(scope, page: params[:page], per_page: per_page)
+      @jobs = @paginator.records
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SolidWebUi::Queue
+  class ProcessesController < ApplicationController
+    def index
+      @processes = SolidQueue::Process.order(:kind, :name)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SolidWebUi::Queue
+  class QueuesController < ApplicationController
+    before_action :ensure_pause_enabled, only: %i[pause resume]
+
+    def index
+      @queues = SolidQueue::Queue.all
+    end
+
+    def pause
+      SolidQueue::Queue.find_by_name(params[:name]).pause
+      redirect_to queues_path, notice: "Queue #{params[:name]} paused."
+    end
+
+    def resume
+      SolidQueue::Queue.find_by_name(params[:name]).resume
+      redirect_to queues_path, notice: "Queue #{params[:name]} resumed."
+    end
+
+    private
+
+    def ensure_pause_enabled
+      head :forbidden unless SolidWebUi::Queue.config.enable_pause
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SolidWebUi::Queue
+  class RecurringTasksController < ApplicationController
+    def index
+      @tasks = SolidQueue::RecurringTask.order(:key)
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SolidWebUi::Cable
+  module ApplicationHelper
+    def cable_nav(active)
+      [
+        { label: "Dashboard", href: root_path, active: active == :dashboard },
+        { label: "Channels", href: channels_path, active: active == :channels }
+      ]
+    end
+
+    def readable_channel(channel)
+      truncate(channel.to_s.dup.force_encoding("UTF-8").scrub("?"), length: 80)
+    end
+
+    def short_time(time)
+      return "—" if time.nil?
+
+      time.in_time_zone(SolidWebUi::Cable.config.time_zone).strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidWebUi::Cache
+  module ApplicationHelper
+    def cache_nav(active)
+      [
+        { label: "Dashboard", href: root_path, active: active == :dashboard },
+        { label: "Entries", href: entries_path, active: active == :entries }
+      ]
+    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)
+    end
+
+    def short_time(time)
+      return "—" if time.nil?
+
+      time.in_time_zone(SolidWebUi::Cache.config.time_zone).strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+end

data/app/helpers/solid_web_ui/component_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidWebUi
+  # Thin view helpers wrapping the shared Ui::* ViewComponents, so engine views
+  # read `swui_page(...)` instead of `render SolidWebUi::Ui::PageComponent.new(...)`.
+  # Included into each engine's controller via `helper SolidWebUi::ComponentHelper`.
+  module ComponentHelper
+    def swui_page(title:, nav: [], &block)
+      render(Ui::PageComponent.new(title: title, nav: nav), &block)
+    end
+
+    def swui_stat_card(label:, value:, tone: :neutral, href: nil)
+      render(Ui::StatCardComponent.new(label: label, value: value, tone: tone, href: href))
+    end
+
+    def swui_status_badge(label:, status: nil)
+      render(Ui::StatusBadgeComponent.new(label: label, status: status))
+    end
+
+    def swui_table(headers:, empty_message: "Nothing to show.", &block)
+      render(Ui::TableComponent.new(headers: headers, empty_message: empty_message), &block)
+    end
+
+    def swui_paginator(paginator:, page_url:)
+      render(Ui::PaginatorComponent.new(paginator: paginator, page_url: page_url))
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SolidWebUi::Queue
+  module ApplicationHelper
+    def queue_nav(active)
+      [
+        { label: "Dashboard", href: root_path, active: active == :dashboard },
+        { label: "Queues", href: queues_path, active: active == :queues },
+        { label: "Jobs", href: jobs_path, active: active == :jobs },
+        { label: "Failed", href: failed_executions_path, active: active == :failed },
+        { label: "Processes", href: processes_path, active: active == :processes },
+        { label: "Recurring", href: recurring_tasks_path, active: active == :recurring }
+      ]
+    end
+
+    # Status of a job derived from which execution table holds it.
+    def job_status(job)
+      return :finished if job.finished_at?
+      return :failed if job.failed_execution
+      return :blocked if job.blocked_execution
+      return :in_progress if job.claimed_execution
+      return :scheduled if job.scheduled_execution
+      return :ready if job.ready_execution
+
+      :unknown
+    end
+
+    def queue_latency(queue)
+      queue.respond_to?(:human_latency) ? queue.human_latency : queue.latency
+    end
+
+    def short_time(time)
+      return "—" if time.nil?
+
+      time.in_time_zone(SolidWebUi::Queue.config.time_zone).strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title><%= content_for?(:title) ? yield(:title) : "Solid Web" %></title>
+  <%= csrf_meta_tags %>
+
+  <% if SolidWebUi.config.stylesheet %>
+    <%= stylesheet_link_tag "solid_web_ui", "data-turbo-track": "reload" %>
+  <% end %>
+  <% Array(SolidWebUi.config.extra_stylesheets).each do |sheet| %>
+    <%= stylesheet_link_tag sheet, "data-turbo-track": "reload" %>
+  <% end %>
+
+  <%# Theme tokens (host re-themes by overriding these values, never the stylesheet). %>
+  <style>
+    .solid-web-ui { <%= SolidWebUi::Theme.css_vars(SolidWebUi.config.theme).html_safe %> }
+    <% if SolidWebUi.config.color_scheme.to_s == "dark" %>
+      .solid-web-ui { <%= SolidWebUi::Theme.dark_css_vars(SolidWebUi.config.theme).html_safe %> }
+    <% elsif SolidWebUi.config.color_scheme.to_s == "auto" %>
+      @media (prefers-color-scheme: dark) {
+        .solid-web-ui { <%= SolidWebUi::Theme.dark_css_vars(SolidWebUi.config.theme).html_safe %> }
+      }
+    <% end %>
+  </style>
+</head>
+<body>
+  <div class="solid-web-ui" data-color-scheme="<%= SolidWebUi.config.color_scheme %>">
+    <%= yield %>
+  </div>
+</body>
+</html>

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

@@ -0,0 +1,12 @@
+<% content_for :title, "Channels" %>
+<%= 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>
+        <td><%= number_with_delimiter(row[:count]) %></td>
+        <td><%= short_time(row[:last]) %></td>
+      </tr>
+    <% end %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,24 @@
+<% content_for :title, "#{SolidWebUi::Cable.config.page_title} · Dashboard" %>
+<%= swui_page(title: SolidWebUi::Cable.config.page_title, nav: cable_nav(:dashboard)) do %>
+  <div class="swui-grid">
+    <%= swui_stat_card(label: "Messages", value: number_with_delimiter(@total), tone: :primary) %>
+    <%= swui_stat_card(label: "Channels", value: @channel_count, href: channels_path) %>
+    <%= swui_stat_card(label: "Last hour", value: number_with_delimiter(@last_hour)) %>
+    <%= swui_stat_card(label: "Trimmable", value: number_with_delimiter(@trimmable), tone: @trimmable.positive? ? :warning : :neutral) %>
+  </div>
+
+  <% if SolidWebUi::Cable.config.enable_trim %>
+    <%= button_to "Trim old messages", trim_messages_path, method: :delete, class: "swui-btn swui-btn--danger",
+                  form: { data: { turbo_confirm: "Delete messages older than the retention window?" } } %>
+  <% end %>
+
+  <h2 class="swui-section-title">Top channels</h2>
+  <%= swui_table(headers: [ "Channel", "Messages" ], empty_message: "No messages broadcast yet.") do %>
+    <% @top_channels.each do |channel, count| %>
+      <tr>
+        <td><code><%= readable_channel(channel) %></code></td>
+        <td><%= number_with_delimiter(count) %></td>
+      </tr>
+    <% end %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,15 @@
+<% content_for :title, "#{SolidWebUi::Cache.config.page_title} · Dashboard" %>
+<%= swui_page(title: SolidWebUi::Cache.config.page_title, nav: cache_nav(:dashboard)) do %>
+  <div class="swui-grid">
+    <%= swui_stat_card(label: "Entries", value: number_with_delimiter(@count), tone: :primary, href: entries_path) %>
+    <%= swui_stat_card(label: "Total size", value: number_to_human_size(@total_bytes)) %>
+    <%= swui_stat_card(label: "Avg entry", value: number_to_human_size(@avg_bytes)) %>
+    <%= swui_stat_card(label: "Oldest", value: short_time(@oldest)) %>
+    <%= swui_stat_card(label: "Newest", value: short_time(@newest)) %>
+  </div>
+
+  <% if SolidWebUi::Cache.config.enable_clear %>
+    <%= button_to "Clear cache", clear_entries_path, method: :delete, class: "swui-btn swui-btn--danger",
+                  form: { data: { turbo_confirm: "Delete ALL cache entries?" } } %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,15 @@
+<% 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 %>
+    <% @entries.each do |entry| %>
+      <tr>
+        <td><%= entry.id %></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>
+      </tr>
+    <% end %>
+  <% end %>
+
+  <%= swui_paginator(paginator: @paginator, page_url: ->(page) { entries_path(page: page) }) %>
+<% end %>

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

@@ -0,0 +1,13 @@
+<% content_for :title, "#{SolidWebUi::Queue.config.page_title} · Dashboard" %>
+<%= swui_page(title: SolidWebUi::Queue.config.page_title, nav: queue_nav(:dashboard)) do %>
+  <div class="swui-grid">
+    <%= swui_stat_card(label: "Ready", value: @counts[:ready], tone: :primary, href: jobs_path(status: "ready")) %>
+    <%= swui_stat_card(label: "Scheduled", value: @counts[:scheduled], href: jobs_path(status: "scheduled")) %>
+    <%= swui_stat_card(label: "In progress", value: @counts[:in_progress], href: jobs_path(status: "in_progress")) %>
+    <%= swui_stat_card(label: "Blocked", value: @counts[:blocked], tone: :warning, href: jobs_path(status: "blocked")) %>
+    <%= swui_stat_card(label: "Failed", value: @counts[:failed], tone: :danger, href: failed_executions_path) %>
+    <%= swui_stat_card(label: "Finished", value: @counts[:finished], tone: :success, href: jobs_path(status: "finished")) %>
+    <%= swui_stat_card(label: "Queues", value: @queue_count, href: queues_path) %>
+    <%= swui_stat_card(label: "Processes", value: @process_count, href: processes_path) %>
+  </div>
+<% end %>

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

@@ -0,0 +1,26 @@
+<% content_for :title, "Failed jobs" %>
+<%= swui_page(title: "Failed jobs", nav: queue_nav(:failed)) do %>
+  <%= swui_table(headers: [ "ID", "Job", "Queue", "Exception", "Message", "Failed at", "" ], empty_message: "No failed jobs. 🎉") do %>
+    <% @failed.each do |failed| %>
+      <tr>
+        <td><%= failed.id %></td>
+        <td><%= failed.job.class_name %></td>
+        <td><%= failed.job.queue_name %></td>
+        <td><%= swui_status_badge(label: failed.exception_class.to_s, status: :failed) %></td>
+        <td><%= truncate(failed.message.to_s, length: 80) %></td>
+        <td><%= short_time(failed.created_at) %></td>
+        <td>
+          <% if SolidWebUi::Queue.config.enable_retry %>
+            <%= button_to "Retry", retry_failed_execution_path(failed), class: "swui-btn" %>
+          <% end %>
+          <% if SolidWebUi::Queue.config.enable_discard %>
+            <%= button_to "Discard", failed_execution_path(failed), method: :delete, class: "swui-btn swui-btn--danger",
+                          form: { data: { turbo_confirm: "Discard this job permanently?" } } %>
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  <% end %>
+
+  <%= swui_paginator(paginator: @paginator, page_url: ->(page) { failed_executions_path(page: page) }) %>
+<% end %>

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

@@ -0,0 +1,23 @@
+<% content_for :title, "Jobs" %>
+<%= swui_page(title: "Jobs", nav: queue_nav(:jobs)) do %>
+  <nav class="swui-nav" style="margin-bottom: 1rem;">
+    <% %w[all ready scheduled in_progress blocked finished failed].each do |status| %>
+      <%= link_to status.humanize, jobs_path(status: status),
+                  class: "swui-nav__link #{'swui-nav__link--active' if @status == status}" %>
+    <% end %>
+  </nav>
+
+  <%= swui_table(headers: [ "ID", "Job", "Queue", "Status", "Created" ], empty_message: "No jobs.") do %>
+    <% @jobs.each do |job| %>
+      <tr>
+        <td><%= job.id %></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>
+        <td><%= short_time(job.created_at) %></td>
+      </tr>
+    <% end %>
+  <% end %>
+
+  <%= swui_paginator(paginator: @paginator, page_url: ->(page) { jobs_path(status: @status, page: page) }) %>
+<% end %>

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

@@ -0,0 +1,14 @@
+<% content_for :title, "Processes" %>
+<%= swui_page(title: "Processes", nav: queue_nav(:processes)) do %>
+  <%= swui_table(headers: [ "Kind", "Name", "PID", "Host", "Last heartbeat" ], empty_message: "No running processes.") do %>
+    <% @processes.each do |process| %>
+      <tr>
+        <td><%= swui_status_badge(label: process.kind, status: :info) %></td>
+        <td><%= process.name %></td>
+        <td><%= process.pid %></td>
+        <td><%= process.hostname %></td>
+        <td><%= short_time(process.last_heartbeat_at) %></td>
+      </tr>
+    <% end %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,25 @@
+<% content_for :title, "Queues" %>
+<%= swui_page(title: "Queues", nav: queue_nav(:queues)) do %>
+  <%= swui_table(headers: [ "Queue", "Size", "Latency", "Status", "" ], empty_message: "No queues with activity.") do %>
+    <% @queues.each do |queue| %>
+      <tr>
+        <td><%= queue.name %></td>
+        <td><%= queue.size %></td>
+        <td><%= queue_latency(queue) %></td>
+        <td>
+          <%= swui_status_badge(label: queue.paused? ? "paused" : "active",
+                                status: queue.paused? ? :paused : :ready) %>
+        </td>
+        <td>
+          <% if SolidWebUi::Queue.config.enable_pause %>
+            <% if queue.paused? %>
+              <%= button_to "Resume", resume_queue_path(queue.name), class: "swui-btn" %>
+            <% else %>
+              <%= button_to "Pause", pause_queue_path(queue.name), class: "swui-btn" %>
+            <% end %>
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,17 @@
+<% content_for :title, "Recurring tasks" %>
+<%= swui_page(title: "Recurring tasks", nav: queue_nav(:recurring)) do %>
+  <%= swui_table(headers: [ "Key", "Schedule", "Class / Command", "Queue", "Type" ], empty_message: "No recurring tasks.") do %>
+    <% @tasks.each do |task| %>
+      <tr>
+        <td><%= task.key %></td>
+        <td><code><%= task.schedule %></code></td>
+        <td><%= task.class_name.presence || task.command %></td>
+        <td><%= task.queue_name %></td>
+        <td>
+          <%= swui_status_badge(label: task.static? ? "static" : "dynamic",
+                                status: task.static? ? :info : :neutral) %>
+        </td>
+      </tr>
+    <% end %>
+  <% end %>
+<% end %>

data/lib/solid_web_ui/cable/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module SolidWebUi
+  module Cable
+    class Engine < ::Rails::Engine
+      isolate_namespace SolidWebUi::Cable
+
+      config.paths["config/routes.rb"] = [ "lib/solid_web_ui/cable/routes.rb" ]
+    end
+  end
+end

data/lib/solid_web_ui/cable/routes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+SolidWebUi::Cable::Engine.routes.draw do
+  root to: "dashboard#index"
+  get "channels", to: "channels#index", as: :channels
+  delete "messages/trim", to: "messages#trim", as: :trim_messages
+end

data/lib/solid_web_ui/cable.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "solid_cable"
+
+module SolidWebUi
+  # Mountable dashboard for Solid Cable. Part of the solid_web_ui gem; mount its
+  # engine independently: `mount SolidWebUi::Cable::Engine => "/admin/cable"`.
+  module Cable
+    extend SolidWebUi::Configurable
+
+    config.page_title = "Solid Cable"
+
+    setting :enable_trim, default: true
+    setting :retention, default: 1.day
+  end
+end
+
+require "solid_web_ui/cable/engine"

data/lib/solid_web_ui/cache/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module SolidWebUi
+  module Cache
+    class Engine < ::Rails::Engine
+      isolate_namespace SolidWebUi::Cache
+
+      config.paths["config/routes.rb"] = [ "lib/solid_web_ui/cache/routes.rb" ]
+    end
+  end
+end

data/lib/solid_web_ui/cache/routes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+SolidWebUi::Cache::Engine.routes.draw do
+  root to: "dashboard#index"
+  get "entries", to: "entries#index", as: :entries
+  delete "entries", to: "entries#clear", as: :clear_entries
+end

data/lib/solid_web_ui/cache.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "solid_cache"
+
+module SolidWebUi
+  # Mountable dashboard for Solid Cache. Part of the solid_web_ui gem; mount its
+  # engine independently: `mount SolidWebUi::Cache::Engine => "/admin/cache"`.
+  module Cache
+    extend SolidWebUi::Configurable
+
+    config.page_title = "Solid Cache"
+
+    setting :enable_clear, default: true
+  end
+end
+
+require "solid_web_ui/cache/engine"

data/lib/solid_web_ui/configurable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "dry/configurable"
+
+module SolidWebUi
+  # Shared dry-configurable base for the three web engines. Each engine does
+  # `extend SolidWebUi::Configurable` and then adds its own feature-flag settings
+  # (enable_retry, enable_clear, enable_trim, …). Centralizes the settings every
+  # dashboard needs: which controller to inherit (host auth), page size, time zone
+  # and the page title.
+  module Configurable
+    def self.extended(base)
+      base.extend Dry::Configurable
+      base.setting :base_controller_class, default: "ActionController::Base"
+      base.setting :per_page, default: 25
+      base.setting :time_zone, default: "UTC"
+      base.setting :page_title, default: base.respond_to?(:name) ? base.name : "Solid Web"
+    end
+  end
+end

data/lib/solid_web_ui/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails"
+require "view_component"
+
+module SolidWebUi
+  # Not isolated on purpose: this engine is a shared design library. Keeping its
+  # app/views, app/components and app/assets on the global lookup paths lets the
+  # three web engines (queue/cache/cable) resolve the shared layout, components
+  # and the single precompiled stylesheet without any manual view-path wiring.
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/solid_web_ui/paginator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidWebUi
+  # Tiny offset paginator so the gems don't take a hard dependency on
+  # kaminari/pagy. Works with any object responding to #count, #limit and
+  # #offset (an ActiveRecord::Relation), or with a precomputed Integer count.
+  class Paginator
+    attr_reader :page, :per_page, :total_count
+
+    def initialize(scope, page:, per_page: 25)
+      @scope = scope
+      @per_page = [ per_page.to_i, 1 ].max
+      @total_count = scope.is_a?(Integer) ? scope : scope.count
+      @page = [ page.to_i, 1 ].max
+    end
+
+    def total_pages
+      [ (total_count.to_f / per_page).ceil, 1 ].max
+    end
+
+    def current_page
+      [ [ page, total_pages ].min, 1 ].max
+    end
+
+    def offset
+      (current_page - 1) * per_page
+    end
+
+    def records
+      @scope.limit(per_page).offset(offset)
+    end
+
+    def first_page?
+      current_page <= 1
+    end
+
+    def last_page?
+      current_page >= total_pages
+    end
+
+    def prev_page
+      first_page? ? nil : current_page - 1
+    end
+
+    def next_page
+      last_page? ? nil : current_page + 1
+    end
+  end
+end

data/lib/solid_web_ui/queue/engine.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module SolidWebUi
+  module Queue
+    class Engine < ::Rails::Engine
+      isolate_namespace SolidWebUi::Queue
+
+      # All sub-engines share the gem root, so point each at its own routes file
+      # (the default config/routes.rb would collide across the parts).
+      config.paths["config/routes.rb"] = [ "lib/solid_web_ui/queue/routes.rb" ]
+    end
+  end
+end