r2ui 0.1.0

data/lib/r2ui/widgets/gauge.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module R2UI
+  module Widgets
+    # "Used ▕██████░░░░▏ 21G / 32G 67%" on one line.
+    module Gauge
+      module_function
+
+      def draw(canvas, rect, label:, value:, total:, column:)
+        return if rect.empty?
+
+        fraction = total.to_f.positive? ? (value.to_f / total).clamp(0, 1) : 0
+        right = "#{column.render(value)} / #{column.render(total)} #{(fraction * 100).round}%"
+        label = label.ljust(10)
+        bar_w = rect.width - label.length - right.length - 4
+        canvas.write(rect.x, rect.y, label, :bold)
+        if bar_w >= 4
+          filled = (fraction * bar_w).round
+          canvas.write(rect.x + label.length, rect.y, "▕", :muted)
+          canvas.write(rect.x + label.length + 1, rect.y, "█" * filled, style(fraction))
+          canvas.write(rect.x + label.length + 1 + filled, rect.y, "░" * (bar_w - filled), :muted)
+          canvas.write(rect.x + label.length + 1 + bar_w, rect.y, "▏", :muted)
+        end
+        canvas.write(rect.x + rect.width - right.length, rect.y, right)
+      end
+
+      def style(fraction)
+        if fraction >= 0.9 then :alert
+        elsif fraction >= 0.7 then :warn
+        else :ok
+        end
+      end
+    end
+  end
+end

data/lib/r2ui/widgets/sparkline.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module R2UI
+  module Widgets
+    module Sparkline
+      BARS = %w[▁ ▂ ▃ ▄ ▅ ▆ ▇ █].freeze
+      # Eighths of a full cell, for multi-line charts.
+      BLOCKS = [" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"].freeze
+
+      module_function
+
+      # One line of bars for the newest `width` values, scaled to the window's max (or `max:`).
+      def line(values, width, max: nil)
+        window = values.last(width).map(&:to_f)
+        return "" if window.empty?
+
+        top = max || window.max
+        top = 1.0 if top.nil? || top <= 0
+        window.map { |v| BARS[((v / top) * (BARS.size - 1)).round.clamp(0, BARS.size - 1)] }.join
+      end
+
+      # A chart `rect.height` lines tall, newest value at the right edge.
+      def draw(canvas, rect, values, max: nil, style: :ok)
+        return if rect.empty?
+
+        window = values.last(rect.width).map(&:to_f)
+        top = max || window.max
+        top = 1.0 if top.nil? || top <= 0
+        offset = rect.width - window.size
+        window.each_with_index do |v, i|
+          eighths = ((v / top).clamp(0, 1) * rect.height * 8).round
+          rect.height.times do |row|
+            fill = (eighths - (row * 8)).clamp(0, 8)
+            next if fill.zero?
+
+            canvas.write(rect.x + offset + i, rect.bottom - 1 - row, BLOCKS[fill], style)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/r2ui/widgets/stat.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module R2UI
+  module Widgets
+    # Label on the left, formatted value on the right, one per line.
+    module Stat
+      module_function
+
+      def draw(canvas, rect, pairs)
+        pairs.first(rect.height).each_with_index do |(column, value), i|
+          text = column.render(value)
+          canvas.write(rect.x, rect.y + i, column.label, :muted, max: rect.width - text.length - 1)
+          canvas.write(rect.x + rect.width - text.length, rect.y + i, text, :bold)
+        end
+      end
+    end
+  end
+end

data/lib/r2ui/widgets/table.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module R2UI
+  module Widgets
+    # The index table: header, sort marker, grouped/tree labels, inline sparklines, selection.
+    class Table
+      SPARK_WIDTH = 10
+      MIN_TEXT = 8
+
+      # `spark` is called with (line, column) and returns that line's recent values.
+      def initialize(resource, lines, state:, focused:, label_key: nil, spark: nil)
+        @resource = resource
+        @lines = lines
+        @state = state
+        @focused = focused
+        @spark = spark
+        @label_key = label_key || resource.columns.find { |c| !c.numeric? && c.format != :id }&.key
+      end
+
+      def draw(canvas, rect)
+        return if rect.empty?
+
+        layout = widths(rect.width)
+        draw_header(canvas, rect, layout)
+        body = rect.with(y: rect.y + 1, height: rect.height - 1)
+        @state.scroll_to_selection(body.height, @lines.size)
+        @lines.drop(@state.offset).first(body.height).each_with_index do |line, i|
+          index = @state.offset + i
+          selected = @focused && index == @state.selected
+          canvas.fill(body.with(y: body.y + i, height: 1), " ", :selected) if selected
+          draw_line(canvas, rect.x, body.y + i, line, layout, selected)
+        end
+        draw_footer(canvas, rect) if @lines.size > body.height
+      end
+
+      private
+
+      def draw_header(canvas, rect, layout)
+        sort_key, sort_dir = @state.sort
+        x = rect.x
+        layout.each do |col, w|
+          label = col.label
+          label = "#{label}#{sort_dir == :desc ? "▼" : "▲"}" if col.key == sort_key
+          canvas.write(x, rect.y, align(label, w, col.align), :header, max: w)
+          x += w + 1
+        end
+      end
+
+      def draw_line(canvas, x, y, line, layout, selected)
+        layout.each do |col, w|
+          text, style = cell(line, col, w)
+          canvas.write(x, y, text, selected ? :selected : style, max: w)
+          x += w + 1
+        end
+      end
+
+      def cell(line, col, width)
+        if col.key == @label_key && (line.label || line.depth.positive? || line.expandable?)
+          prefix, body, suffix = label_parts(line, col)
+          body = fit(body, [width - prefix.length - suffix.length, 1].max, Format.truncate_from(col.format))
+          return [fit("#{prefix}#{body}#{suffix}", width, :right), line.label ? :bold : :plain]
+        end
+
+        value = line.values[col.key]
+        value = "×#{line.count}" if col.aggregate == :count && line.label
+        text = value.is_a?(String) && col.aggregate == :count ? value : col.render(value)
+        if col.sparkline && @spark
+          text_w = width - SPARK_WIDTH - 1
+          text = "#{Sparkline.line(@spark.call(line, col), SPARK_WIDTH).rjust(SPARK_WIDTH)} #{align(text, text_w, col.align)}"
+          return [text, :plain]
+        end
+        [align(fit(text, width, Format.truncate_from(col.format)), width, col.align), style_for(col, value)]
+      end
+
+      # [indent and tree marker, the value (truncated to fit), count suffix]
+      def label_parts(line, col)
+        if line.label
+          body = Format.call(col.format, line.label)
+          counted = @resource.columns.any? { |c| c.aggregate == :count }
+          ["", body.empty? ? "(none)" : body, counted ? "" : " ×#{line.count}"]
+        else
+          marker = if line.expandable? then line.collapsed ? "▸ " : "▾ " else "  " end
+          ["#{"  " * line.depth}#{marker}", col.render(line.values[col.key]), line.count > 1 ? " (#{line.count})" : ""]
+        end
+      end
+
+      def style_for(col, value)
+        return :plain unless col.format == :percent && value.is_a?(Numeric)
+
+        if value >= 80 then :alert
+        elsif value >= 25 then :warn
+        else :plain
+        end
+      end
+
+      # Fixed-width columns get their width; text columns share the rest. Drops columns that don't fit.
+      def widths(total)
+        cols = @resource.columns
+        fixed = cols.to_h do |c|
+          w = c.width || Format.default_width(c.format)
+          w &&= [w, c.label.length + 1].max
+          w += SPARK_WIDTH + 1 if w && c.sparkline
+          [c, w]
+        end
+        loop do
+          flexible = fixed.count { |_, w| w.nil? }
+          used = fixed.values.compact.sum + fixed.size - 1
+          spare = total - used
+          break if flexible.zero? ? spare >= 0 : spare >= flexible * MIN_TEXT
+          break if fixed.size == 1
+
+          fixed.delete(fixed.keys.last)
+        end
+        flexible = fixed.count { |_, w| w.nil? }
+        spare = total - fixed.values.compact.sum - (fixed.size - 1)
+        fixed.to_h { |c, w| [c, w || [spare / [flexible, 1].max, 1].max] }
+      end
+
+      def draw_footer(canvas, rect)
+        text = " #{@state.selected + 1}/#{@lines.size} "
+        canvas.write(rect.x + rect.width - text.length, rect.bottom, text, :muted)
+      end
+
+      def fit(text, width, from)
+        return text if text.length <= width
+        return text[0, width] if width < 2
+
+        from == :left ? "…#{text[-(width - 1)..]}" : "#{text[0, width - 1]}…"
+      end
+
+      def align(text, width, side) = side == :right ? text.rjust(width) : text.ljust(width)
+    end
+  end
+end

data/lib/r2ui.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "r2ui/version"
+require_relative "r2ui/value"
+require_relative "r2ui/format"
+require_relative "r2ui/history"
+require_relative "r2ui/dsl/column"
+require_relative "r2ui/dsl/resource"
+require_relative "r2ui/dsl/dashboard"
+require_relative "r2ui/registry"
+require_relative "r2ui/search"
+require_relative "r2ui/query"
+require_relative "r2ui/canvas"
+require_relative "r2ui/widgets/box"
+require_relative "r2ui/widgets/table"
+require_relative "r2ui/widgets/gauge"
+require_relative "r2ui/widgets/stat"
+require_relative "r2ui/widgets/sparkline"
+require_relative "r2ui/panel_state"
+require_relative "r2ui/feed"
+require_relative "r2ui/renderer"
+require_relative "r2ui/keys"
+require_relative "r2ui/terminal"
+require_relative "r2ui/app"
+
+# R2UI: declare terminal dashboards the way ActiveAdmin declares admin pages.
+#
+#   R2UI.resource :process do
+#     source { MyProbe.processes }
+#     scope :all, default: true
+#     group_by :name
+#     index { column :pid, format: :id; column :cpu, format: :percent }
+#   end
+#
+#   R2UI.run
+module R2UI
+  class Error < StandardError; end
+
+  class << self
+    def registry = @registry ||= Registry.new
+
+    def resource(name, &) = registry.add_resource(DSL::Resource.build(name, &))
+
+    def dashboard(name = :main, &) = registry.add_dashboard(DSL::Dashboard.build(name, &))
+
+    def run(name = nil) = App.new(registry, name).run
+
+    # One frame as plain text, without a terminal. Used by `r2ui --snapshot` and tests.
+    def snapshot(name = nil, width: 120, height: 40, ticks: 1) = App.new(registry, name).snapshot(width:, height:, ticks:)
+
+    def reset! = @registry = Registry.new
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: r2ui
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryan Gavin
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Declare resources, scopes, groupings, columns and actions; R2UI draws
+  the tables, charts and key bindings in your terminal.
+email:
+- ryan.michael.gavin@gmail.com
+executables:
+- r2ui
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/r2ui
+- lib/r2ui.rb
+- lib/r2ui/app.rb
+- lib/r2ui/canvas.rb
+- lib/r2ui/dsl/column.rb
+- lib/r2ui/dsl/dashboard.rb
+- lib/r2ui/dsl/resource.rb
+- lib/r2ui/feed.rb
+- lib/r2ui/format.rb
+- lib/r2ui/history.rb
+- lib/r2ui/keys.rb
+- lib/r2ui/panel_state.rb
+- lib/r2ui/query.rb
+- lib/r2ui/registry.rb
+- lib/r2ui/renderer.rb
+- lib/r2ui/search.rb
+- lib/r2ui/terminal.rb
+- lib/r2ui/value.rb
+- lib/r2ui/version.rb
+- lib/r2ui/widgets/box.rb
+- lib/r2ui/widgets/gauge.rb
+- lib/r2ui/widgets/sparkline.rb
+- lib/r2ui/widgets/stat.rb
+- lib/r2ui/widgets/table.rb
+homepage: https://github.com/satoramoto/r2ui
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/satoramoto/r2ui
+  changelog_uri: https://github.com/satoramoto/r2ui/commits/main
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: ActiveAdmin-style DSL for terminal dashboards
+test_files: []