r2ui 0.1.0

data/lib/r2ui/format.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module R2UI
+  # Column formats: how a value is shown, aligned, aggregated and parsed back from a search.
+  module Format
+    NUMERIC = %i[bytes bytes_per_sec percent number integer ratio].freeze
+    SUMMED = %i[bytes bytes_per_sec percent number integer].freeze
+    UNITS = { "" => 1, "K" => 1024, "M" => 1024**2, "G" => 1024**3, "T" => 1024**4 }.freeze
+
+    module_function
+
+    def numeric?(format) = NUMERIC.include?(format)
+
+    # What a grouped line shows for this column: :sum, :count or :distinct.
+    def default_aggregate(format)
+      return :sum if SUMMED.include?(format)
+      return :count if format == :id
+
+      :distinct
+    end
+
+    def default_align(format) = numeric?(format) || format == :id ? :right : :left
+
+    # Paths keep their tail when they don't fit.
+    def truncate_from(format) = format == :short_path ? :left : :right
+
+    def default_width(format)
+      case format
+      when :bytes, :bytes_per_sec then 8
+      when :percent then 7
+      when :ratio then 6
+      when :id, :integer, :number then 8
+      end
+    end
+
+    def call(format, value)
+      return "" if value.nil?
+
+      case format
+      when :bytes then bytes(value)
+      when :bytes_per_sec then "#{bytes(value)}/s"
+      when :percent then format("%.1f%%", value)
+      when :ratio then format("%.1fx", value)
+      when :number then value.is_a?(Float) ? format("%.1f", value) : value.to_s
+      when :short_path then short_path(value)
+      else value.to_s
+      end
+    end
+
+    def bytes(value)
+      value = value.to_f
+      unit = UNITS.keys.reverse.find { |u| value >= UNITS[u] } || ""
+      scaled = value / UNITS[unit]
+      unit.empty? ? "#{value.round}B" : format(scaled < 10 ? "%.1f%s" : "%.0f%s", scaled, unit)
+    end
+
+    def short_path(value)
+      home = Dir.home
+      value.to_s.start_with?(home) ? "~#{value.to_s.delete_prefix(home)}" : value.to_s
+    end
+
+    # Parse a search operand ("500M", "1.5G", "5") into the column's units.
+    def parse(format, text)
+      case format
+      when :bytes, :bytes_per_sec
+        m = text.strip.upcase.match(/\A([\d.]+)\s*([KMGT]?)I?B?\z/) or return nil
+        m[1].to_f * UNITS[m[2]]
+      when *NUMERIC, :id
+        Float(text.delete("%x"), exception: false)
+      else
+        text
+      end
+    end
+  end
+end

data/lib/r2ui/history.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module R2UI
+  # Recent values per (series id, attribute), for sparklines.
+  class History
+    def initialize(capacity: 120)
+      @capacity = capacity
+      @series = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def record(id, key, value)
+      list = @series[[id, key]]
+      list << value.to_f
+      list.shift while list.size > @capacity
+    end
+
+    def [](id, key) = @series.fetch([id, key], [])
+
+    # Sum several series aligned at their newest value (for grouped lines).
+    def sum(ids, key)
+      lists = ids.map { |id| self[id, key] }.reject(&:empty?)
+      return [] if lists.empty?
+
+      len = lists.map(&:size).max
+      Array.new(len) do |i|
+        lists.sum { |l| l[l.size - len + i] || 0.0 }
+      end
+    end
+
+    # Forget series whose ids are no longer present.
+    def prune(live_ids)
+      live = live_ids.to_set
+      @series.delete_if { |(id, _), _| !live.include?(id) }
+    end
+  end
+end

data/lib/r2ui/keys.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module R2UI
+  # Splits raw terminal input into key names (:up, :tab, "q", ...).
+  module Keys
+    SEQUENCES = {
+      "\e[A" => :up, "\e[B" => :down, "\e[C" => :right, "\e[D" => :left,
+      "\e[5~" => :page_up, "\e[6~" => :page_down, "\e[H" => :home, "\e[F" => :end,
+      "\e[Z" => :back_tab, "\t" => :tab, "\r" => :enter, "\n" => :enter,
+      "\x7F" => :backspace, "\b" => :backspace, "\x03" => :interrupt, "\e" => :escape
+    }.freeze
+    PATTERN = Regexp.union(*SEQUENCES.keys.sort_by { -_1.length }, /./m)
+
+    module_function
+
+    def parse(input) = input.scan(PATTERN).map { |k| SEQUENCES.fetch(k, k) }
+  end
+end

data/lib/r2ui/panel_state.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "set"
+
+module R2UI
+  # What the viewer has chosen for one table panel: scope, grouping, sort, search, selection.
+  class PanelState
+    attr_accessor :search
+    attr_reader :sort, :selected, :offset, :collapsed
+
+    def initialize(resource, table = nil)
+      @resource = resource
+      @scope_index = index_of(resource.scopes, table&.scope) || resource.scopes.index(resource.default_scope)
+      @group_index = index_of(resource.groupings, table&.group_by)
+      @sort = normalize_sort(table&.sort) || resource.default_sort
+      @search = ""
+      @selected = 0
+      @offset = 0
+      @collapsed = Set.new
+    end
+
+    def scope = @scope_index && @resource.scopes[@scope_index]
+
+    def grouping = @group_index && @resource.groupings[@group_index]
+
+    def scope_tabs = @resource.scopes.each_with_index.map { |s, i| [s.label, i == @scope_index] }
+
+    def cycle_scope(step)
+      return if @resource.scopes.empty?
+
+      @scope_index = ((@scope_index || 0) + step) % @resource.scopes.size
+      reset_position
+    end
+
+    # Off → each grouping in turn → off.
+    def cycle_grouping
+      count = @resource.groupings.size
+      return if count.zero?
+
+      @group_index = @group_index.nil? ? 0 : (@group_index + 1 < count ? @group_index + 1 : nil)
+      reset_position
+    end
+
+    # Next column; numbers sort descending first, text ascending.
+    def cycle_sort
+      keys = @resource.columns.map(&:key)
+      current = keys.index(@sort&.first)
+      key = keys[current.nil? ? 0 : (current + 1) % keys.size]
+      @sort = [key, @resource.column(key).numeric? ? :desc : :asc]
+    end
+
+    def reverse_sort
+      @sort = [@sort.first, @sort.last == :desc ? :asc : :desc] if @sort
+    end
+
+    def move(delta, count)
+      @selected = (@selected + delta).clamp(0, [count - 1, 0].max)
+    end
+
+    def toggle(line)
+      return unless line&.expandable?
+
+      @collapsed.include?(line.id) ? @collapsed.delete(line.id) : @collapsed.add(line.id)
+    end
+
+    def scroll_to_selection(height, count)
+      @selected = @selected.clamp(0, [count - 1, 0].max)
+      @offset = @selected if @selected < @offset
+      @offset = @selected - height + 1 if height.positive? && @selected >= @offset + height
+      @offset = @offset.clamp(0, [count - height, 0].max)
+    end
+
+    def status
+      parts = []
+      parts << "group: #{grouping.label}" if grouping
+      parts << "sort: #{@resource.column(sort.first)&.label}#{sort.last == :desc ? "▼" : "▲"}" if sort
+      parts << "search: #{search}" unless search.empty?
+      parts.join("  ")
+    end
+
+    private
+
+    def reset_position
+      @selected = 0
+      @offset = 0
+    end
+
+    def index_of(list, name) = name && list.index { |item| item.name == name }
+
+    def normalize_sort(sort)
+      case sort
+      when nil then nil
+      when Array then sort
+      else [sort, @resource.column(sort)&.numeric? ? :desc : :asc]
+      end
+    end
+  end
+end

data/lib/r2ui/query.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "set"
+
+module R2UI
+  # One table line: a row, a group of rows, or a tree node with its subtree rolled up.
+  Line = Data.define(:id, :label, :values, :depth, :rows, :children, :collapsed) do
+    def count = rows.size
+    def expandable? = children.positive?
+  end
+
+  # Turns raw rows into table lines: scope → search → group or tree → sort. Pure, so it is easy to test.
+  class Query
+    def initialize(resource, rows, scope: nil, grouping: nil, search: nil, sort: nil, collapsed: Set.new)
+      @resource = resource
+      @rows = rows
+      @scope = scope
+      @grouping = grouping
+      @search = search
+      @sort_key, @sort_dir = sort || resource.default_sort
+      @collapsed = collapsed
+    end
+
+    def lines
+      rows = @scope ? @scope.call(@rows) : @rows
+      rows = Search.new(@resource, @search).call(rows)
+      return sort(rows.map { |row| line_for(row) }) unless @grouping
+
+      @grouping.tree? ? tree(rows) : groups(rows)
+    end
+
+    private
+
+    def columns = @resource.columns
+
+    def line_for(row)
+      Line.new(id: @resource.identify(row), label: nil, values: columns.to_h { |c| [c.key, c.read(row)] },
+               depth: 0, rows: [row], children: 0, collapsed: false)
+    end
+
+    def groups(rows)
+      by = @grouping.by
+      reader = @resource.column(by)&.method(:read) || ->(row) { Value.fetch(row, by) }
+      grouped = rows.group_by(&reader)
+      sort(grouped.map do |key, members|
+        Line.new(id: [:group, by, key], label: key, values: aggregate(members), depth: 0, rows: members,
+                 children: 0, collapsed: false)
+      end)
+    end
+
+    def aggregate(rows)
+      columns.to_h do |c|
+        values = rows.map { |r| c.read(r) }
+        value = case c.aggregate
+                when :sum then values.compact.sum
+                when :count then rows.size
+                else values.uniq.size == 1 ? values.first : nil
+                end
+        [c.key, value]
+      end
+    end
+
+    # Each node's summed columns hold its whole subtree; other columns hold its own value.
+    def tree(rows)
+      by_id = rows.to_h { |r| [@resource.identify(r), r] }
+      kids = Hash.new { |h, k| h[k] = [] }
+      roots = []
+      rows.each do |row|
+        id = @resource.identify(row)
+        parent = Value.fetch(row, @resource.parent_key)
+        parent != id && by_id.key?(parent) ? kids[parent] << row : roots << row
+      end
+
+      subtree = {}
+      collect = lambda do |row, seen|
+        id = @resource.identify(row)
+        return [] unless seen.add?(id)
+
+        subtree[id] ||= [row] + kids[id].flat_map { |k| collect.call(k, seen) }
+      end
+
+      nodes = lambda do |siblings, depth|
+        lines = sort(siblings.map do |row|
+          id = @resource.identify(row)
+          members = subtree[id] || collect.call(row, Set.new)
+          own = line_for(row).values
+          values = aggregate(members).to_h { |k, v| [k, @resource.column(k).aggregate == :sum ? v : own[k]] }
+          Line.new(id:, label: nil, values:, depth:, rows: members, children: kids[id].size,
+                   collapsed: @collapsed.include?(id))
+        end)
+        lines.flat_map do |line|
+          line.collapsed ? [line] : [line, *nodes.call(kids[line.id], depth + 1)]
+        end
+      end
+      nodes.call(roots, 0)
+    end
+
+    def sort(lines)
+      return lines unless @sort_key
+
+      sorted = lines.sort_by do |line|
+        v = line.values[@sort_key]
+        v.nil? ? [1, 0] : [0, v.is_a?(Numeric) ? v : v.to_s.downcase]
+      end
+      return sorted unless @sort_dir == :desc
+
+      present, missing = sorted.partition { |l| !l.values[@sort_key].nil? }
+      present.reverse + missing
+    end
+  end
+end

data/lib/r2ui/registry.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module R2UI
+  class Registry
+    attr_reader :resources, :dashboards
+
+    def initialize
+      @resources = {}
+      @dashboards = {}
+    end
+
+    def add_resource(resource) = @resources[resource.name] = resource
+
+    def add_dashboard(dashboard) = @dashboards[dashboard.name] = dashboard
+
+    def resource(name) = @resources.fetch(name.to_sym) { raise Error, "no resource named #{name}" }
+
+    # A dashboard by name, or a resource shown full screen. With no name: :main, else the first defined.
+    def screen(name = nil)
+      name = name&.to_sym
+      return dashboards[name] if name && dashboards.key?(name)
+      return DSL::Dashboard.for_resource(resource(name)) if name
+      return dashboards[:main] if dashboards.key?(:main)
+      return dashboards.values.first if dashboards.any?
+      raise Error, "nothing to show: define a resource or dashboard" if resources.empty?
+
+      DSL::Dashboard.for_resource(resources.values.first)
+    end
+  end
+end

data/lib/r2ui/renderer.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module R2UI
+  # Lays out a dashboard and draws every panel into a canvas.
+  class Renderer
+    HINTS = "tab panel  [ ] scope  g group  s/S sort  / search  ⏎ fold  z zoom  q quit"
+
+    # The lines each table panel showed in the last frame, for selection and actions.
+    attr_reader :lines
+
+    def initialize(registry, feeds, states)
+      @registry = registry
+      @feeds = feeds
+      @states = states
+      @lines = {}
+    end
+
+    def render(dashboard, width:, height:, focus:, zoomed: false, prompt: nil)
+      canvas = Canvas.new(width, height)
+      body = Rect.new(x: 0, y: 0, width:, height: height - 1)
+      if zoomed
+        draw_panel(canvas, body, focus, true)
+      else
+        rows_layout(dashboard, body).each do |rect, panel|
+          draw_panel(canvas, rect, panel, panel == focus)
+        end
+      end
+      draw_status(canvas, height - 1, width, focus, prompt)
+      canvas
+    end
+
+    private
+
+    def rows_layout(dashboard, body)
+      fixed = dashboard.rows.sum { |r| r.height || 0 }
+      flexible = dashboard.rows.count { |r| r.height.nil? }
+      share = flexible.zero? ? 0 : (body.height - fixed) / flexible
+      y = body.y
+      dashboard.rows.each_with_index.flat_map do |row, i|
+        last = i == dashboard.rows.size - 1
+        h = last ? body.bottom - y : (row.height || share)
+        rect = Rect.new(x: body.x, y:, width: body.width, height: [h, 0].max)
+        y += rect.height
+        split(rect, row.panels)
+      end
+    end
+
+    def split(rect, panels)
+      total = panels.sum(&:span)
+      x = rect.x
+      panels.each_with_index.map do |panel, i|
+        w = i == panels.size - 1 ? rect.x + rect.width - x : (rect.width * panel.span / total)
+        r = rect.with(x:, width: w)
+        x += w
+        [r, panel]
+      end
+    end
+
+    def draw_panel(canvas, rect, panel, focused)
+      resource = @registry.resource(panel.resource)
+      feed = @feeds.fetch(resource.name)
+      state = @states[panel]
+      title = panel.title || (panel.name == resource.name ? resource.title : panel.name.to_s.tr("_", " ").capitalize)
+      inner = Widgets::Box.draw(canvas, rect, title:, focused:, tabs: state ? state.scope_tabs : [])
+      return if inner.empty?
+
+      if (error = feed.error)
+        canvas.write(inner.x, inner.y, error, :alert, max: inner.width)
+        inner = inner.take(1).last
+      end
+
+      rows = feed.rows
+      record = rows.first
+      panel.items.each do |item|
+        break if inner.empty?
+
+        inner = case item
+                when DSL::Gauge then draw_gauge(canvas, inner, resource, record, item)
+                when DSL::Stat then draw_stats(canvas, inner, resource, record, item)
+                when DSL::Sparkline then draw_sparkline(canvas, inner, resource, feed, item)
+                when DSL::Table then draw_table(canvas, inner, resource, feed, rows, panel, state, focused, item)
+                end
+      end
+    end
+
+    def draw_gauge(canvas, rect, resource, record, item)
+      line, rest = rect.take(1)
+      return rest unless record
+
+      column = column_for(resource, item.attr)
+      Widgets::Gauge.draw(canvas, line, label: item.label || column.label, value: column.read(record),
+                                        total: column_for(resource, item.of).read(record), column:)
+      rest
+    end
+
+    def draw_stats(canvas, rect, resource, record, item)
+      area, rest = rect.take(item.attrs.size)
+      return rest unless record
+
+      Widgets::Stat.draw(canvas, area, item.attrs.map { |a| column_for(resource, a).then { |c| [c, c.read(record)] } })
+      rest
+    end
+
+    def draw_sparkline(canvas, rect, resource, feed, item)
+      area, rest = rect.take(item.height + 1)
+      column = column_for(resource, item.attr)
+      values = feed.history[Feed::SINGLE, column.key]
+      label, chart = area.take(1)
+      canvas.write(label.x, label.y, item.label || column.label, :muted)
+      now = column.render(values.last)
+      canvas.write(label.x + label.width - now.length, label.y, now, :bold)
+      Widgets::Sparkline.draw(canvas, chart, values, max: column.format == :percent ? 100 : nil, style: :accent)
+      rest
+    end
+
+    def draw_table(canvas, rect, resource, feed, rows, panel, state, focused, item)
+      lines = Query.new(resource, rows, scope: state.scope, grouping: state.grouping, search: state.search,
+                                        sort: state.sort, collapsed: state.collapsed).lines
+      lines = lines.first(item.limit) if item.limit
+      @lines[panel] = lines
+      label_key = state.grouping && !state.grouping.tree? && resource.column(state.grouping.by) ? state.grouping.by : nil
+      spark = ->(line, col) { feed.history.sum(line.rows.map { |r| feed.series_id(r) }, col.key) }
+      Widgets::Table.new(resource, lines, state:, focused:, label_key:, spark:).draw(canvas, rect)
+      rect.with(height: 0)
+    end
+
+    def draw_status(canvas, y, width, focus, prompt)
+      left = prompt || @states[focus]&.status.to_s
+      canvas.fill(Rect.new(x: 0, y:, width:, height: 1), " ", :reverse)
+      canvas.write(1, y, left, :reverse, max: width - 2)
+      hints = HINTS
+      canvas.write(width - hints.length - 1, y, hints, :reverse) if left.length + hints.length + 4 <= width
+    end
+
+    def column_for(resource, key)
+      resource.column(key) || DSL::Column.build(key)
+    end
+  end
+end

data/lib/r2ui/search.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module R2UI
+  # The "/" search. Space-separated terms, all must match:
+  #   codex          free text, case-insensitive, against the resource's `filter` attributes
+  #   cpu>5          comparison on a column, operand parsed by its format ("mem>=500M")
+  #   cwd~starseed   substring match on one column
+  class Search
+    TERM = /\A(?<field>\w+)(?<op>>=|<=|!=|>|<|=|~)(?<operand>.+)\z/
+
+    def initialize(resource, text)
+      @resource = resource
+      @predicates = text.to_s.split.map { |term| predicate(term) }
+    end
+
+    def call(rows) = @predicates.empty? ? rows : rows.select { |row| @predicates.all? { |p| p.call(row) } }
+
+    private
+
+    def predicate(term)
+      m = TERM.match(term)
+      column = m && @resource.column(m[:field].to_sym)
+      return free_text(term) unless column
+
+      compare(column, m[:op], m[:operand])
+    end
+
+    def free_text(term)
+      needle = term.downcase
+      keys = @resource.searchable.any? ? @resource.searchable : text_columns
+      readers = keys.map { |k| @resource.column(k)&.method(:read) || ->(row) { Value.fetch(row, k) } }
+      ->(row) { readers.any? { |read| read.call(row).to_s.downcase.include?(needle) } }
+    end
+
+    def compare(column, op, operand)
+      return ->(row) { column.read(row).to_s.downcase.include?(operand.downcase) } if op == "~"
+
+      target = Format.parse(column.format, operand)
+      return ->(_) { false } if target.nil?
+
+      lambda do |row|
+        value = column.read(row)
+        value = value.to_s.downcase if target.is_a?(String)
+        target = target.downcase if target.is_a?(String)
+        case op
+        when ">" then value > target
+        when "<" then value < target
+        when ">=" then value >= target
+        when "<=" then value <= target
+        when "=" then value == target
+        when "!=" then value != target
+        end
+      rescue ArgumentError, NoMethodError
+        false
+      end
+    end
+
+    def text_columns = @resource.columns.reject(&:numeric?).map(&:key)
+  end
+end

data/lib/r2ui/terminal.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module R2UI
+  # Raw mode, alternate screen, line-diffed redraws. Always restores the terminal on exit.
+  class Terminal
+    def initialize(input: $stdin, output: $stdout)
+      @in = input
+      @out = output
+      @previous = []
+    end
+
+    def open
+      @in.raw!
+      @out.write("\e[?1049h\e[?25l\e[2J")
+      @out.flush
+      yield self
+    ensure
+      @out.write("\e[0m\e[?25h\e[?1049l")
+      @out.flush
+      @in.cooked!
+    end
+
+    def size
+      rows, cols = @out.winsize
+      [cols, rows]
+    end
+
+    def clear = @previous = []
+
+    def draw(canvas)
+      out = +""
+      lines = canvas.ansi_lines
+      lines.each_with_index do |line, y|
+        next if @previous[y] == line
+
+        out << "\e[#{y + 1};1H" << line
+      end
+      @previous = lines
+      @out.write(out)
+      @out.flush
+    end
+
+    # Key names typed within `timeout` seconds (empty if none).
+    def read_keys(timeout)
+      return [] unless @in.wait_readable(timeout)
+
+      data = @in.read_nonblock(64, exception: false)
+      data.is_a?(String) ? Keys.parse(data) : []
+    end
+  end
+end

data/lib/r2ui/value.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module R2UI
+  # Rows can be hashes, Data/Struct objects or ActiveRecord models; read them all the same way.
+  module Value
+    module_function
+
+    def fetch(row, key)
+      case row
+      when Hash then row.key?(key) ? row[key] : row[key.to_s]
+      else row.public_send(key)
+      end
+    end
+  end
+end

data/lib/r2ui/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module R2UI
+  VERSION = "0.1.0"
+end

data/lib/r2ui/widgets/box.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module R2UI
+  module Widgets
+    # A bordered panel with a title on the top edge. Returns the inner rect.
+    module Box
+      module_function
+
+      def draw(canvas, rect, title: nil, focused: false, tabs: [])
+        return rect if rect.width < 2 || rect.height < 2
+
+        style = focused ? :focus : :border
+        right = rect.x + rect.width - 1
+        canvas.write(rect.x, rect.y, "╭#{"─" * (rect.width - 2)}╮", style)
+        (rect.height - 2).times do |i|
+          canvas.write(rect.x, rect.y + 1 + i, "│", style)
+          canvas.write(right, rect.y + 1 + i, "│", style)
+        end
+        canvas.write(rect.x, rect.bottom - 1, "╰#{"─" * (rect.width - 2)}╯", style)
+
+        x = rect.x + 2
+        max = right - 1
+        if title
+          canvas.write(x, rect.y, " #{title} ", :title, max: max - x)
+          x += title.length + 3
+        end
+        tabs.each do |label, active|
+          break if x >= max
+
+          canvas.write(x, rect.y, active ? "[#{label}]" : " #{label} ", active ? :accent : :muted, max: max - x)
+          x += label.length + 2
+        end
+        rect.inner
+      end
+    end
+  end
+end