r2ui 0.1.0 → 0.2.0

data/lib/r2ui/compat/lipgloss/tree/go_tree.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+# A port of lipgloss v1.1.0 tree/ (tree.go, children.go, enumerator.go, renderer.go) and the
+# enumerators of list/ (list/enumerator.go). Lipgloss::Tree and Lipgloss::List wrap a GoTree::Node,
+# the way the gem's Ruby objects wrap a handle to a Go *tree.Tree / *list.List: every method mutates
+# that shared node, and the returned Ruby object is a fresh wrapper around the same node.
+#
+# Only what the gem's Ruby API can reach is ported: no hidden nodes, no style or enumerator funcs
+# that look at the children (the Ruby API only sets constant styles and the built-in enumerators).
+module R2UI
+  module Compat
+    module Gloss
+      module GoTree
+        UTF_8 = Encoding::UTF_8
+
+        # tree.Leaf
+        class Leaf
+          attr_accessor :value
+
+          def initialize(value)
+            @value = value
+          end
+        end
+
+        # tree.Tree
+        class Node
+          attr_accessor :value, :children, :offset, :r
+
+          def initialize
+            @value = +""
+            @children = []
+            @offset = [0, 0]
+            @r = nil
+          end
+
+          # Tree.Root(string)
+          def root(value)
+            @value = value
+            self
+          end
+
+          # Tree.Children(): the children inside the offset window.
+          def visible_children
+            (@offset[0]...(@children.length - @offset[1])).map { |i| @children[i] }
+          end
+
+          # Tree.Child for one *Tree, Node or string.
+          def child(item)
+            case item
+            when Node
+              new_item, rm = ensure_parent(@children, item)
+              @children.delete_at(rm) if rm >= 0
+              @children << new_item
+            when Leaf
+              @children << item
+            when String
+              @children << Leaf.new(item)
+            end
+            self
+          end
+
+          # Tree.Offset
+          def set_offset(start, stop)
+            start, stop = stop, start if start > stop
+            start = 0 if start.negative?
+            stop = @children.length if stop.negative? || stop > @children.length
+            @offset = [start, stop]
+            self
+          end
+
+          def ensure_renderer
+            @r ||= Renderer.new
+          end
+
+          # Tree.String()
+          def to_s
+            ensure_renderer.render(self, true, "")
+          end
+
+          private
+
+          # tree.go ensureParent: a tree without a root takes over the previous leaf's value (or merges
+          # into the previous subtree).
+          def ensure_parent(nodes, item)
+            return [item, -1] if item.value != "" || nodes.empty?
+
+            j = nodes.length - 1
+            parent = nodes[j]
+            case parent
+            when Node
+              i = 0
+              while i < item.visible_children.length
+                parent.child(item.children[i])
+                i += 1
+              end
+              [parent, j]
+            else
+              item.value = parent.value
+              [item, j]
+            end
+          end
+        end
+
+        DEFAULT_ENUMERATOR = ->(children, index) { children.length - 1 == index ? "└──" : "├──" }
+        ROUNDED_ENUMERATOR = ->(children, index) { children.length - 1 == index ? "╰──" : "├──" }
+        DEFAULT_INDENTER = ->(children, index) { children.length - 1 == index ? "   " : "│  " }
+
+        # list/enumerator.go
+        module ListEnumerators
+          ABC_LEN = 26
+          ROMAN = %w[M CM D CD C XC L XL X IX V IV I].freeze
+          ARABIC = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1].freeze
+
+          BULLET = ->(_items, _i) { "•" }
+          ASTERISK = ->(_items, _i) { "*" }
+          DASH = ->(_items, _i) { "-" }
+          ARABIC_ENUM = ->(_items, i) { "#{i + 1}." }
+
+          ALPHABET = lambda do |_items, i|
+            a = "A".ord
+            if i >= ABC_LEN * ABC_LEN + ABC_LEN
+              [a + i / ABC_LEN / ABC_LEN - 1, a + (i / ABC_LEN) % ABC_LEN - 1, a + i % ABC_LEN].pack("U*") + "."
+            elsif i >= ABC_LEN
+              [a + i / ABC_LEN - 1, a + i % ABC_LEN].pack("U*") + "."
+            else
+              [a + i % ABC_LEN].pack("U*") + "."
+            end
+          end
+
+          ROMAN_ENUM = lambda do |_items, i|
+            result = +""
+            ARABIC.each_with_index do |value, v|
+              while i >= value - 1
+                i -= value
+                result << ROMAN[v]
+              end
+            end
+            result << "."
+          end
+
+          INDENTER = ->(_items, _i) { " " }
+        end
+
+        # list.New(): a tree with the bullet enumerator and a one-space indenter.
+        def self.new_list
+          node = Node.new
+          r = node.ensure_renderer
+          r.enumerator = ListEnumerators::BULLET
+          r.indenter = ListEnumerators::INDENTER
+          node
+        end
+
+        # tree/renderer.go
+        class Renderer
+          attr_accessor :enumerator_style, :item_style, :root_style, :enumerator, :indenter
+
+          def initialize
+            @enumerator_style = ::Lipgloss::Style.new.padding_right(1)
+            @item_style = ::Lipgloss::Style.new
+            @root_style = ::Lipgloss::Style.new
+            @enumerator = DEFAULT_ENUMERATOR
+            @indenter = DEFAULT_INDENTER
+          end
+
+          def render(node, root, prefix)
+            strs = []
+            max_len = 0
+            children = node.is_a?(Node) ? node.visible_children : []
+
+            name = node.value
+            strs << style_render(@root_style, name) if name != "" && root
+
+            children.each_index do |i|
+              p = style_render(@enumerator_style, @enumerator.call(children, i))
+              w = layout.width(p)
+              max_len = w if w > max_len
+            end
+
+            children.each_with_index do |child, i|
+              indent = @indenter.call(children, i)
+              node_prefix = style_render(@enumerator_style, @enumerator.call(children, i))
+              l = max_len - layout.width(node_prefix)
+              node_prefix = (" " * l) + node_prefix if l.positive?
+
+              item = style_render(@item_style, child.value)
+              multiline_prefix = prefix
+
+              while layout.height(item) > layout.height(node_prefix)
+                node_prefix = layout.join_vertical(0.0, [node_prefix, style_render(@enumerator_style, indent)])
+              end
+              while layout.height(node_prefix) > layout.height(multiline_prefix)
+                multiline_prefix = layout.join_vertical(0.0, [multiline_prefix, prefix])
+              end
+
+              strs << layout.join_horizontal(0.0, [multiline_prefix, node_prefix, item])
+
+              renderer = (child.is_a?(Node) && child.r) || self
+              s = renderer.render(child, false, prefix + style_render(@enumerator_style, indent))
+              strs << s unless s.empty?
+            end
+            strs.join("\n")
+          end
+
+          private
+
+          def layout = Layout
+
+          def style_render(style, str)
+            style.send(:go_render, str)
+          end
+        end
+
+        # --- Ruby-side argument handling shared by Lipgloss::List and Lipgloss::Tree --------------
+
+        # Check_Type(value, T_STRING) + StringValueCStr, copied the way Go copies a C string.
+        def self.c_string_arg(value)
+          Layout.check_string(value)
+          String.new(Layout.c_string(value), encoding: UTF_8)
+        end
+
+        # Array#to_json unmarshalled into []string (nil when the unmarshal fails).
+        def self.json_string_array(array)
+          Layout.check_array(array)
+          strs = Layout.json_strings(array)
+          return nil if strs.equal?(Layout::JSON_FAIL)
+
+          strs.map { |s| String.new(s, encoding: UTF_8) }
+        end
+
+        # TypedData_Get_Struct(style, ..., &style_type)
+        def self.style_arg(style)
+          return style if style.is_a?(::Lipgloss::Style)
+
+          raise TypeError, "wrong argument type #{Layout.type_name(style)} (expected Lipgloss::Style)"
+        end
+
+        def self.render(node)
+          Layout.c_result(node.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/r2ui/compat/lipgloss/tree.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "tree/go_tree"
+
+module Lipgloss
+  # Lipgloss::Tree as the gem's C extension (tree.c) defines it over Go lipgloss tree.Tree. Every method
+  # mutates the underlying tree and returns a new Lipgloss::Tree wrapping that same tree.
+  class Tree
+    def self.root(root)
+      value = R2UI::Compat::Gloss::GoTree.c_string_arg(root)
+      tree = allocate
+      tree.instance_variable_set(:@tree, R2UI::Compat::Gloss::GoTree::Node.new.root(value))
+      tree
+    end
+
+    def initialize(*args)
+      node = go_tree
+      node.root(R2UI::Compat::Gloss::GoTree.c_string_arg(args[0])) if args.length == 1
+    end
+
+    def root=(root)
+      node = go_tree
+      node.root(R2UI::Compat::Gloss::GoTree.c_string_arg(root))
+      wrap(node)
+    end
+
+    def child(*children)
+      node = go_tree
+      raise ArgumentError, "wrong number of arguments (given 0, expected 1+)" if children.empty?
+
+      children.each do |child|
+        if child.is_a?(Lipgloss::Tree)
+          node.child(child.send(:go_tree))
+        else
+          node.child(R2UI::Compat::Gloss::GoTree.c_string_arg(child))
+        end
+      end
+      wrap(node)
+    end
+
+    def children(children)
+      node = go_tree
+      strs = R2UI::Compat::Gloss::GoTree.json_string_array(children)
+      strs&.each { |s| node.child(s) }
+      wrap(node)
+    end
+
+    def enumerator(enum_symbol)
+      node = go_tree
+      node.ensure_renderer.enumerator =
+        if enum_symbol.equal?(:rounded)
+          R2UI::Compat::Gloss::GoTree::ROUNDED_ENUMERATOR
+        else
+          R2UI::Compat::Gloss::GoTree::DEFAULT_ENUMERATOR
+        end
+      wrap(node)
+    end
+
+    def enumerator_style(style)
+      node = go_tree
+      node.ensure_renderer.enumerator_style = R2UI::Compat::Gloss::GoTree.style_arg(style)
+      wrap(node)
+    end
+
+    def item_style(style)
+      node = go_tree
+      node.ensure_renderer.item_style = R2UI::Compat::Gloss::GoTree.style_arg(style)
+      wrap(node)
+    end
+
+    def root_style(style)
+      node = go_tree
+      node.ensure_renderer.root_style = R2UI::Compat::Gloss::GoTree.style_arg(style)
+      wrap(node)
+    end
+
+    def offset(start, stop)
+      node = go_tree
+      layout = R2UI::Compat::Gloss::Layout
+      node.set_offset(layout.num2int(start), layout.num2int(stop))
+      wrap(node)
+    end
+
+    def render
+      R2UI::Compat::Gloss::GoTree.render(go_tree)
+    end
+
+    def to_s
+      render
+    end
+
+    private
+
+    # The gem allocates the Go tree in the alloc function, so even an uninitialized object has one.
+    def go_tree
+      @tree ||= R2UI::Compat::Gloss::GoTree::Node.new
+    end
+
+    def wrap(node)
+      tree = self.class.allocate
+      tree.instance_variable_set(:@tree, node)
+      tree
+    end
+  end
+end

data/lib/r2ui/compat/lipgloss/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lipgloss
+  VERSION = "0.2.2"
+end
+
+module R2UI
+  module Compat
+    # Internals of the pure-Ruby lipgloss (see lib/r2ui/compat/lipgloss.rb).
+    module Gloss
+      # The Go lipgloss version the real gem wraps; returned by Lipgloss.upstream_version.
+      UPSTREAM_VERSION = "v1.1.0"
+    end
+  end
+end

data/lib/r2ui/compat/lipgloss.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Pure-Ruby Lipgloss: a drop-in for the lipgloss gem 0.2.2 (marcoroth/lipgloss-ruby, MIT), which wraps
+# Go lipgloss v1.1.0 through a C extension. This port follows the Go sources (lipgloss v1.1.0,
+# charmbracelet/x/ansi v0.8.0, muesli/termenv v0.16.0, lucasb-eyer/go-colorful v1.2.0, rivo/uniseg v0.4.7)
+# so output is byte-identical to the real gem for the same calls and color profile.
+#
+# Public API lives under `Lipgloss`, exactly as the gem exposes it. Internals (text width and wrapping,
+# terminal color handling, color math) live under `R2UI::Compat::Gloss` so they never leak into the
+# gem's namespace.
+
+require_relative "lipgloss/version"
+require_relative "lipgloss/text"
+require_relative "lipgloss/colorful"
+require_relative "lipgloss/termenv"
+require_relative "lipgloss/position"
+require_relative "lipgloss/border"
+require_relative "lipgloss/color"
+require_relative "lipgloss/color_blend"
+require_relative "lipgloss/style"
+require_relative "lipgloss/layout"
+require_relative "lipgloss/table"
+require_relative "lipgloss/list"
+require_relative "lipgloss/tree"
+
+module Lipgloss
+  TOP = Position::TOP
+  BOTTOM = Position::BOTTOM
+  LEFT = Position::LEFT
+  RIGHT = Position::RIGHT
+  CENTER = Position::CENTER
+
+  NORMAL_BORDER = Border::NORMAL
+  ROUNDED_BORDER = Border::ROUNDED
+  THICK_BORDER = Border::THICK
+  DOUBLE_BORDER = Border::DOUBLE
+  HIDDEN_BORDER = Border::HIDDEN
+  BLOCK_BORDER = Border::BLOCK
+  ASCII_BORDER = Border::ASCII
+
+  NO_TAB_CONVERSION = -1
+
+  class << self
+    def join_horizontal(position, *strings)
+      _join_horizontal(Position.resolve(position), strings)
+    end
+
+    def join_vertical(position, *strings)
+      _join_vertical(Position.resolve(position), strings)
+    end
+
+    def place(width, height, horizontal, vertical, string, **opts)
+      _place(width, height, Position.resolve(horizontal), Position.resolve(vertical), string, **opts)
+    end
+
+    def place_horizontal(width, position, string)
+      _place_horizontal(width, Position.resolve(position), string)
+    end
+
+    def place_vertical(height, position, string)
+      _place_vertical(height, Position.resolve(position), string)
+    end
+  end
+end

data/lib/r2ui/compat/load_path/bubbletea.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Loaded by `require "bubbletea"` after `require "r2ui/drop_in"`. The engine lane owns the implementation.
+require_relative "../bubbletea"

data/lib/r2ui/compat/load_path/lipgloss.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Loaded by `require "lipgloss"` after `require "r2ui/drop_in"`. The style lane owns the implementation.
+require_relative "../lipgloss"

data/lib/r2ui/component.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module R2UI
+  # Hosts Bubbletea-style models (bubbles components, or your own: `update(msg)` → [model, cmd],
+  # `view` → String) as panel items. An extension declares one with
+  #
+  #   component(SpinnerItem) { |item| Bubbles::Spinner.new }                # build block, runs on a Context
+  #   component(InputItem, focusable: true) { |item| Bubbles::TextInput.new }
+  #
+  # and the app then, for every panel item of that class:
+  # - builds the model once, in App#init, and runs its `init` (if it has one);
+  # - sends it every non-key message (ticks, window size, mouse, your own messages) and batches the
+  #   commands it returns;
+  # - if `focusable`, sends it the key messages while its panel has focus (the first focusable item
+  #   in the panel), except tab / shift+tab (panel focus) and ctrl+c (quit); calls its `focus`
+  #   (or `focus!`) / `blur` as its panel gains and loses focus;
+  # - draws `model.view` in the panel, unless the extension registers its own `panel_item` drawer.
+  module Component
+    # One hosted model. `item` is the DSL object the panel holds; `model` changes as update returns.
+    Instance = Struct.new(:panel, :item, :spec, :model, :focused, keyword_init: true) do
+      def name = item.respond_to?(:name) ? item.name : nil
+      def focusable? = spec.options.fetch(:focusable, false)
+    end
+
+    Spec = Data.define(:matcher, :options, :build)
+
+    # Keys a focused component never sees.
+    RESERVED = %i[tab back_tab interrupt].freeze
+
+    module_function
+
+    # Bubbles is an optional dependency: component extensions call this when first used (not at
+    # load time). It opts into r2ui/drop_in, so bubbles' `require "bubbletea"`/`"lipgloss"` load
+    # r2ui's engine instead of the real gems.
+    def require_bubbles!
+      return if defined?(::Bubbles)
+
+      begin
+        require_relative "drop_in"
+      rescue LoadError => e
+        raise Error, "bubbles components run on r2ui's Bubbletea, but #{e.message}"
+      end
+      begin
+        require "bubbles"
+      rescue LoadError
+        raise Error, "this needs the bubbles gem: add `gem \"bubbles\"` to your Gemfile"
+      end
+    end
+
+    # [model, command] from an init/update result (a pair, a bare command, or nil).
+    def split(model, result)
+      return result if result.is_a?(Array) && result.size == 2 && !Context.command?(result.first)
+
+      [model, Context.command?(result) ? result : nil]
+    end
+
+    def focus(instance)
+      model = instance.model
+      method = %i[focus focus!].find { |m| model.respond_to?(m) }
+      method && model.public_send(method)
+    end
+
+    def blur(instance)
+      instance.model.blur if instance.model.respond_to?(:blur)
+    end
+  end
+end

data/lib/r2ui/context.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module R2UI
+  # What a hook or user block runs on (instance_exec). Holds the running app and the commands the
+  # block enqueues; the app batches them into the Bubbletea command its init/update returns.
+  #
+  # Core helpers are below; extensions add more with `helpers do ... end`. Command helpers enqueue
+  # with `command(...)` and return the command, so a block can also just return one.
+  class Context
+    attr_reader :app, :message
+    # Set while drawing a panel item.
+    attr_accessor :panel, :width, :height
+
+    def initialize(app, message = nil)
+      @app = app
+      @message = message
+      @commands = []
+    end
+
+    def self.command?(value) = value.is_a?(Bubbletea::Command) || value.is_a?(Proc)
+
+    # nil, one command, or a batch of several.
+    def self.combine(commands)
+      commands = commands.compact
+      commands.size <= 1 ? commands.first : Bubbletea.batch(*commands)
+    end
+
+    # The app's user state: a Hash any block may read and write.
+    def state = app.state
+
+    # Private runtime state for one extension (timers it scheduled, component models, ...).
+    def store(name) = app.store(name)
+
+    # The app's animation state (R2UI::Motion), for panel items that tween, pulse or age values.
+    def motion = app.motion
+
+    def dashboard = app.dashboard
+
+    # The focused panel (a DSL::Panel).
+    def focus = app.focus
+
+    # Rows under the selection in the focused table panel ([] if none).
+    def selected_rows = app.selected_rows
+
+    # The hosted model of the component item named `name` (see R2UI::Component), or nil.
+    def component(name) = app.component(name)
+
+    # Moves key focus to the named component, or away from all with nil (App#focus_component).
+    def focus_component(name)
+      app.focus_component(name, self)
+      nil
+    end
+
+    # Shows text on the status bar for a few seconds.
+    def flash(text) = app.flash(text)
+
+    def quit = command(Bubbletea.quit)
+
+    # Enqueues a Bubbletea command (or a Proc, run in the background). Returns it.
+    def command(cmd)
+      @commands << cmd if cmd && @commands.none? { |c| c.equal?(cmd) }
+      cmd
+    end
+
+    # Inside an `on` handler: decline the message, so lower-priority handlers and the core see it.
+    def pass = throw(:r2ui_pass)
+
+    # Runs `block` here; a returned command is enqueued too. Returns the block's value.
+    def call(block, *args)
+      result = instance_exec(*args, &block)
+      (result.is_a?(Array) ? result : [result]).each { |r| command(r) if Context.command?(r) }
+      result
+    end
+
+    # Runs an `on` handler: true if it consumed the message (didn't `pass`).
+    def handle(block, message)
+      catch(:r2ui_pass) do
+        call(block, message)
+        return true
+      end
+      false
+    end
+
+    # The enqueued commands as one Bubbletea command (nil if none).
+    def commands = Context.combine(@commands)
+  end
+end

data/lib/r2ui/drop_in.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Makes `require "bubbletea"` and `require "lipgloss"` load r2ui's pure-Ruby versions, so code
+# written for the Charm Ruby gems (and pure-Ruby gems on top of them, like bubbles) runs unchanged:
+#
+#   require "r2ui/drop_in"
+#   require "bubbles"   # now runs on r2ui
+#
+# Load it before anything requires the real gems.
+
+loaded = $LOADED_FEATURES.grep(%r{/gems/(bubbletea|lipgloss)-[^/]+/})
+unless loaded.empty?
+  raise LoadError, "r2ui/drop_in must be required before the real bubbletea/lipgloss gems (already loaded: #{loaded.first})"
+end
+
+$LOAD_PATH.unshift(File.expand_path("compat/load_path", __dir__))

data/lib/r2ui/dsl/column.rb

@@ -3,11 +3,19 @@
 module R2UI
   module DSL
     # One attribute of a resource: how to read it, show it and roll it up.
-    Column = Data.define(:key, :label, :format, :sparkline, :aggregate, :width, :align, :sort, :reader) do
+    #
+    # Drawing options for the index table: `style` is a callable (value, line) -> style or nil (a
+    # palette Symbol or an SGR String; nil keeps the default colouring). `sparkline` is true (block
+    # bars) or :braille; `spark_width` its width in cells, `spark_max` its scale (else the window
+    # max), `spark_style` a style or a callable (values, line) -> style. When columns don't fit, the
+    # lowest `priority` is dropped first (ties: the last declared).
+    Column = Data.define(:key, :label, :format, :sparkline, :aggregate, :width, :align, :sort, :reader,
+                         :style, :spark_width, :spark_max, :spark_style, :priority) do
       def self.build(key, label: nil, format: :text, sparkline: false, aggregate: nil, width: nil, align: nil,
-                     sort: nil, &reader)
+                     sort: nil, style: nil, spark_width: nil, spark_max: nil, spark_style: nil, priority: 0, &reader)
         new(
-          key:, format:, sparkline:, width:, sort:, reader:,
+          key:, format:, sparkline:, width:, sort:, reader:, style:, spark_width:, spark_max:, spark_style:,
+          priority:,
           label: label || key.to_s.tr("_", " ").capitalize,
           aggregate: aggregate || Format.default_aggregate(format),
           align: align || Format.default_align(format)