foruiman 0.1.2

data/lib/foruiman/ring.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Foruiman::Ring
+  include Enumerable
+
+  attr_reader :capacity, :size
+
+  def initialize(capacity)
+    raise Foruiman::Error, "log-lines must be a positive integer" unless capacity.is_a?(Integer) && capacity.positive?
+
+    @capacity = capacity
+    @slots = []
+    @positions = {}
+    @head = 0
+    @size = 0
+  end
+
+  def append(record)
+    index = (@head + @size) % capacity
+    if size == capacity
+      @positions.delete(@slots[index].sequence)
+      @head = (@head + 1) % capacity
+    else
+      @size += 1
+    end
+    @slots[index] = record
+    @positions[record.sequence] = index
+    record
+  end
+
+  def replace(record)
+    index = @positions[record.sequence]
+    @slots[index] = record if index
+    record
+  end
+
+  def [](index)
+    return unless index >= 0 && index < size
+
+    @slots[(@head + index) % capacity]
+  end
+
+  def index_of(sequence)
+    position = @positions[sequence]
+    (position - @head) % capacity if position
+  end
+
+  def each
+    return enum_for(:each) unless block_given?
+
+    size.times { |index| yield self[index] }
+  end
+end

data/lib/foruiman/tui/application.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "terminal"
+require_relative "state"
+require_relative "keyboard"
+require_relative "renderer"
+
+module Foruiman::TUI
+  class Application
+    attr_reader :state
+
+    def initialize(engine, terminal: Terminal.new, renderer: Renderer.new)
+      @engine = engine
+      @terminal = terminal
+      @renderer = renderer
+      @keyboard = Keyboard.new
+      @state = State.new(engine.processes.map(&:name))
+      @last_frame = nil
+      @next_frame_at = 0
+      @was_shutting_down = false
+      @feedback_until = 0
+    end
+
+    def run
+      @terminal.session do
+        @engine.run(keep_open: true) do
+          rows, columns = @terminal.size
+          input = @terminal.read
+          @engine.shutdown if input.nil?
+          height = [Renderer.log_height(rows: rows, columns: columns), 1].max
+          @keyboard.feed(input.is_a?(String) ? input : "").each { |key| handle(key, height) }
+          state.feedback = nil if monotonic >= @feedback_until
+          next if monotonic < @next_frame_at && @was_shutting_down == @engine.shutting_down?
+
+          @was_shutting_down = @engine.shutting_down?
+
+          @next_frame_at = monotonic + (1.0 / 30)
+          frame = @renderer.render(state, @engine, rows: rows, columns: columns)
+          if frame != @last_frame
+            @terminal.draw(frame)
+            @last_frame = frame
+          end
+        end
+      end
+    ensure
+      @engine.close
+    end
+
+    def handle(key, height)
+      return if @engine.shutting_down?
+
+      if key.is_a?(Integer)
+        state.select(key.zero? ? state.tabs.size - 1 : key - 1)
+        return
+      end
+      buffer = @engine.logs[state.name]
+      case key
+      when :next then state.move(1)
+      when :previous then state.move(-1)
+      when :up then state.viewport.scroll(-1, buffer, height)
+      when :down then state.viewport.scroll(1, buffer, height)
+      when :page_up then state.viewport.scroll(-height, buffer, height)
+      when :page_down then state.viewport.scroll(height, buffer, height)
+      when :home then state.viewport.home(buffer)
+      when :end, :follow then state.viewport.follow
+      when :toggle_follow then state.viewport.toggle(buffer, height)
+      when :help then state.help = !state.help
+      when :escape then state.help = false
+      when :restart, :stop then control(key)
+      when :restart_all, :stop_all
+        control_all(key == :restart_all ? :restart : :stop)
+      when :quit then @engine.shutdown
+      end
+    end
+
+    private
+
+    def control(action)
+      if state.name == "all"
+        if action == :restart
+          control_all(action)
+        else
+          feedback("Select a process first; S stops all processes")
+        end
+      else
+        @engine.public_send(action, state.name)
+        feedback("#{action == :restart ? 'Restarting' : 'Stopping'} #{state.name}")
+      end
+    end
+
+    def control_all(action)
+      @engine.processes.each { |entry| @engine.public_send(action, entry.name) }
+      feedback("#{action == :restart ? 'Restarting' : 'Stopping'} all processes")
+    end
+
+    def feedback(message)
+      state.feedback = message
+      @feedback_until = monotonic + 2
+    end
+
+    def monotonic
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/foruiman/tui/keyboard.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Foruiman::TUI
+  class Keyboard
+    SEQUENCES = {
+      "\e[A" => :up, "\e[B" => :down, "\e[C" => :next, "\e[D" => :previous,
+      "\e[5~" => :page_up, "\e[6~" => :page_down, "\e[H" => :home, "\e[F" => :end,
+      "\e[1~" => :home, "\e[4~" => :end, "\eOH" => :home, "\eOF" => :end,
+      "\e[Z" => :previous
+    }.freeze
+    KEYS = {
+      "\t" => :next, "h" => :previous, "l" => :next, "k" => :up, "j" => :down,
+      "g" => :home, "G" => :end, "f" => :follow, " " => :toggle_follow,
+      "r" => :restart, "R" => :restart_all, "s" => :stop, "S" => :stop_all,
+      "?" => :help, "q" => :quit, "\x03" => :quit,
+      "\x15" => :page_up, "\x04" => :page_down
+    }.freeze
+
+    def initialize
+      @buffer = +"".b
+      @escape_at = nil
+    end
+
+    def feed(bytes, now: monotonic)
+      @buffer << bytes
+      actions = []
+      until @buffer.empty?
+        if @buffer.start_with?("\e")
+          sequence = SEQUENCES.keys.find { |key| @buffer.start_with?(key) }
+          if sequence
+            actions << SEQUENCES.fetch(sequence)
+            @buffer.slice!(0, sequence.bytesize)
+          elsif incomplete_escape?
+            @escape_at ||= now
+            break if now - @escape_at < 0.1 && @buffer.bytesize < 64
+
+            actions << :escape if @buffer == "\e"
+            @buffer.clear
+          else
+            # Ignore an unknown complete escape as a unit; its final byte must
+            # never accidentally become a destructive shortcut such as R.
+            match = @buffer.match(%r{\A\e(?:\[[0-?]*[ -/]*[@-~]|O.|.)}m)
+            @buffer.slice!(0, match ? match[0].bytesize : 1)
+          end
+        else
+          key = @buffer.slice!(0, 1)
+          actions << (key.match?(/[0-9]/) ? key.to_i : KEYS[key])
+        end
+        @escape_at = nil
+      end
+      actions.compact
+    end
+
+    private
+
+    def incomplete_escape?
+      return true if @buffer == "\e" || @buffer == "\eO"
+
+      @buffer.start_with?("\e[") && !@buffer.match?(%r{\A\e\[[0-?]*[ -/]*[@-~]})
+    end
+
+    def monotonic
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/foruiman/tui/log_formatter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "text"
+require_relative "theme"
+
+module Foruiman::TUI
+  class LogFormatter
+    def initialize(theme, names)
+      @theme = theme
+      @colors = names.each_with_index.to_h { |name, index| [name, theme.process(index)] }
+      @name_width = names.map { |name| Text.width(name) }.max.to_i.clamp(3, 14)
+    end
+
+    def row(record, aggregate:, width:)
+      prefix = +""
+      prefix << @theme.paint("#{record.time.strftime('%H:%M:%S')}  ", :faint) if width >= 55
+      if aggregate
+        name_width = [@name_width, width / 5].min
+        name = Text.pad(Text.clip(record.name, name_width, ellipsis: true), name_width)
+        prefix << @theme.paint(name, @colors.fetch(record.name, :cyan)) << "  "
+      end
+      marker, color = stream_style(record.stream)
+      prefix << @theme.paint(marker, color) << @theme.paint(" │ ", :border)
+      content = record.stream == :lifecycle ? record.text.delete_prefix("--- ").delete_suffix(" ---") : record.text
+      content = Text.clip(content, [width - Text.width(prefix), 0].max, ellipsis: true)
+      prefix + @theme.log(content, color: body_color(record.stream))
+    end
+
+    private
+
+    def stream_style(stream)
+      case stream
+      when :stderr then ["err", :red]
+      when :lifecycle then ["sys", :amber]
+      else ["out", :faint]
+      end
+    end
+
+    def body_color(stream)
+      case stream
+      when :stderr then :red
+      when :lifecycle then :muted
+      else :text
+      end
+    end
+  end
+end

data/lib/foruiman/tui/renderer.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+require_relative "text"
+require_relative "theme"
+require_relative "log_formatter"
+require "pathname"
+
+module Foruiman::TUI
+  class Renderer
+    HELP = [
+      ["↔ NAVIGATE", "Tab / Shift-Tab", "Change tab", "← →  or  h l"],
+      [nil, "1–9 / 0", "Select a process / all logs", nil],
+      ["≡ READ LOGS", "↑ ↓  or  k j", "Scroll a line", nil],
+      [nil, "PgUp / PgDn", "Scroll a page", "Ctrl-U / Ctrl-D"],
+      [nil, "g / Home", "Oldest retained line", nil],
+      [nil, "f / G / End", "Follow newest output", nil],
+      [nil, "Space", "Pause / resume following", nil],
+      ["⚙ PROCESSES", "r / R", "Restart selected / all", "r on all restarts all"],
+      [nil, "s / S", "Stop selected / all", nil],
+      ["◇ SESSION", "? / Escape", "Close help", nil],
+      [nil, "q / Ctrl-C", "Stop processes and quit", nil]
+    ].freeze
+
+    def initialize(theme: Theme.new)
+      @theme = theme
+      @first_tab = 0
+    end
+
+    def self.expanded?(rows:, columns:)
+      rows >= 14 && columns >= 60
+    end
+
+    def self.log_height(rows:, columns:)
+      return 0 if rows < 6 || columns < 24
+
+      rows - (expanded?(rows: rows, columns: columns) ? 7 : 5)
+    end
+
+    def render(state, engine, rows:, columns:)
+      @width = [columns - 1, 1].max
+      @inside = [@width - 4, 0].max
+      @height = self.class.log_height(rows: rows, columns: columns)
+      return tiny_frame(state, engine, rows) if @height.zero?
+
+      lines = [header(engine)]
+      if self.class.expanded?(rows: rows, columns: columns)
+        hint = @inside >= 70 ? " Tab switch · 1–9 / 0 select " : ""
+        lines << border(@theme.paint(" processes ", :muted, bold: true), @theme.paint(hint, :faint))
+        lines << panel(tab_row(state, engine, @inside - 2))
+        lines << border("", "", bottom: true)
+      else
+        lines << " #{@theme.paint('│', :border)} #{tab_row(state, engine, @inside - 2)}"
+      end
+      lines << log_header(state, engine)
+      lines.concat(state.help ? help_rows : log_rows(state, engine))
+      lines << log_footer(state, engine)
+      lines << controls(state, engine)
+      frame(lines, rows)
+    end
+
+    def self.width(text)
+      Text.width(text)
+    end
+
+    def self.truncate(text, columns)
+      Text.clip(text, columns) + Foruiman::ANSI::RESET
+    end
+
+    private
+
+    def header(engine)
+      brand = @width >= 45 ? "▰ FORUIMAN" : "▰"
+      left = " #{@theme.paint(brand, :accent, bold: true)}"
+      right = if engine.shutting_down?
+                @theme.paint("◌ shutting down", :amber)
+              elsif @width >= 60
+                summary(engine)
+              else
+                ""
+              end
+      source = if engine.procfile_path
+                 Text.clean(Pathname.new(engine.procfile_path).relative_path_from(Pathname.new(engine.root)).to_s)
+               end
+      project = @theme.paint("  / #{Text.clean(File.basename(engine.root))}", :muted)
+      left += project if @width >= 70 && Text.width(left + project + source.to_s + right) + 5 <= @width
+      if source
+        available = [@width - Text.width(left + right) - 4, 0].max
+        source = "…/#{File.basename(source)}" if Text.width(source) > available && source.include?("/")
+        left += @theme.paint("  #{Text.clip(source, available, ellipsis: true)}")
+      end
+      distribute(left, "#{right} ", @width)
+    end
+
+    def summary(engine)
+      running = engine.processes.count { |entry| entry.status == :running }
+      failed = engine.processes.count { |entry| entry.status == :failed }
+      summary = @theme.paint("● #{running} running", running.positive? ? :green : :muted)
+      summary += @theme.paint("  × #{failed} failed", :red) if failed.positive? && @width >= 55
+      summary
+    end
+
+    def tab_row(state, engine, width)
+      @first_tab = state.selected if state.selected < @first_tab
+      labels = state.tabs.each_with_index.map { |name, index| tab(name, index, state, engine, width) }
+      @first_tab += 1 while @first_tab < state.selected && tab_span(labels, @first_tab, state.selected) > width
+      output = +(@first_tab.positive? ? @theme.paint("‹ ", :muted) : "")
+      index = @first_tab
+      while index < labels.size
+        separator = index == @first_tab ? "" : " "
+        more = index < labels.size - 1 ? 2 : 0
+        available = width - Text.width(output) - more - separator.size
+        break if Text.width(labels[index]) > available && index > @first_tab
+
+        output << separator << Text.clip(labels[index], [available, 0].max) << @theme.reset
+        index += 1
+      end
+      output << @theme.paint(" ›", :muted) if index < labels.size
+      Text.clip(output, width)
+    end
+
+    def tab_span(labels, first, last)
+      Text.width(labels[first..last].join(" ")) + (first.positive? ? 2 : 0) + (last < labels.size - 1 ? 2 : 0)
+    end
+
+    def tab(name, index, state, engine, width)
+      selected = index == state.selected
+      entry = name == "all" ? nil : engine.processes.find { |process| process.name == name }
+      mark = name == "all" ? "≡" : Theme::STATUS_MARKS.fetch(entry&.status, "○")
+      number = if name == "all"
+                 "0"
+               else
+                 (index < 9 ? (index + 1).to_s : "·")
+               end
+      name = Text.clip(name, [width - 12, 6].max.clamp(6, 22), ellipsis: true)
+      color = name == "all" ? :accent : @theme.process(index)
+      mark_color = entry ? Theme::STATUS_COLORS.fetch(entry.status, :muted) : :muted
+      @theme.paint(" #{number} ", selected ? :muted : :faint, selected: selected) +
+        @theme.paint("#{mark} ", mark_color, selected: selected) +
+        @theme.paint("#{name} ", color, selected: selected, bold: selected)
+    end
+
+    def log_header(state, engine)
+      if state.help
+        return border(@theme.paint(" ⌨ keyboard shortcuts ", :text, bold: true),
+                      @theme.paint(" ? / Escape close help ", :muted))
+      end
+
+      title = state.name == "all" ? " ≡ all logs " : " › #{state.name} "
+      detail = if state.name == "all"
+                 "#{engine.processes.size} processes"
+               else
+                 entry = engine.state(state.name)
+                 process_detail(entry)
+               end
+      active = if state.name == "all"
+                 engine.processes.any? { |entry| entry.status == :running }
+               else
+                 engine.state(state.name).status == :running
+               end
+      mode = if !state.viewport.following
+               @theme.paint(" Ⅱ PAUSED ", :amber)
+             elsif active
+               @theme.paint(" ● LIVE ", :green)
+             else
+               @theme.paint(" ↓ FOLLOW ", :muted)
+             end
+      title = @theme.paint(title, :text, bold: true)
+      if @inside >= 45
+        title += @theme.paint(" #{detail} ", :muted)
+      elsif state.name != "all" && @inside >= 28
+        entry = engine.state(state.name)
+        title += @theme.paint(" #{entry.status} ", Theme::STATUS_COLORS.fetch(entry.status, :muted))
+      end
+      border(title, mode)
+    end
+
+    def process_detail(entry)
+      detail = "#{entry.status} · PID #{entry.pid || '-'}"
+      if entry.exit_status
+        code = entry.exit_status.exitstatus || "signal #{entry.exit_status.termsig}"
+        detail += " · exit #{code}"
+      elsif entry.port && @inside >= 75
+        detail += " · PORT #{entry.port}"
+      end
+      detail
+    end
+
+    def log_rows(state, engine)
+      @formatter ||= LogFormatter.new(@theme, engine.process_names)
+      buffer = engine.logs[state.name]
+      records = state.viewport.rows(buffer, @height)
+      @visible = records
+      first = records.empty? ? 0 : buffer.index_of(records.first.sequence).to_i
+      thumb_size = buffer.none? ? @height : [(@height * @height / buffer.size), 1].max.clamp(1, @height)
+      travel = @height - thumb_size
+      thumb_start = buffer.size <= @height ? 0 : (first * travel / (buffer.size - @height))
+      Array.new(@height) do |index|
+        content = if records[index]
+                    @formatter.row(records[index], aggregate: state.name == "all", width: @inside - 2)
+                  elsif records.empty? && index == @height / 2
+                    @theme.paint("Waiting for output…", :faint)
+                  else
+                    ""
+                  end
+        thumb = buffer.size > @height && index.between?(thumb_start, thumb_start + thumb_size - 1)
+        panel(content, scroll: if thumb
+                                 state.viewport.following ? :green : :amber
+                               end)
+      end
+    end
+
+    def log_footer(state, engine)
+      return border("", "", bottom: true) if state.help
+
+      buffer = engine.logs[state.name]
+      first = @visible&.first
+      last = @visible&.last
+      range = first ? "#{buffer.index_of(first.sequence) + 1}–#{buffer.index_of(last.sequence) + 1}" : "0"
+      count = " #{range} / #{buffer.size} lines "
+      location = if state.viewport.following
+                   " following "
+                 else
+                   " f resume "
+                 end
+      location = " PID #{engine.state(state.name).pid || '-'} " if state.name != "all" && @inside < 45
+      border(@theme.paint(count, :faint), @theme.paint(location, state.viewport.following ? :faint : :amber),
+             bottom: true)
+    end
+
+    def help_rows
+      rows = []
+      HELP.each do |section, key, description, alias_keys|
+        if section && @height >= 15
+          rows << panel("") if !rows.empty? && @height >= 18
+          rows << panel(@theme.paint(section, :accent, bold: true))
+        end
+        line = @theme.paint(Text.pad(key, 18), :amber, bold: true) + @theme.paint(description)
+        line += @theme.paint("  #{alias_keys}", :faint) if alias_keys && @inside >= 75
+        rows << panel(line)
+      end
+      rows = rows.first(@height)
+      rows << panel("") while rows.size < @height
+      rows
+    end
+
+    def controls(state, engine)
+      quit = @theme.paint(" q ", :accent, bold: true) + @theme.paint(" × quit ", :muted)
+      left = if engine.shutting_down?
+               @theme.paint(" ◌ Stopping process groups · TERM → KILL after 5s", :amber)
+             elsif state.feedback
+               @theme.paint(" #{state.feedback}", :amber)
+             elsif state.help
+               @theme.paint(" ? / Escape close help", :muted)
+             else
+               shortcuts(state)
+             end
+      distribute(left, quit, @width)
+    end
+
+    def shortcuts(state)
+      restart = ["r", state.name == "all" ? "↻ restart all" : "↻ restart"]
+      pairs = [%w[Tab switch], ["↑↓", "scroll"], %w[f follow], restart, ["?", "help"]]
+      pairs = [restart, ["?", "help"]] if @width < 65
+      pairs.map do |key, label|
+        @theme.paint(" #{key} ", :accent, bold: true) + @theme.paint(" #{label}  ", :muted)
+      end.join
+    end
+
+    def border(left, right = "", bottom: false)
+      corners = bottom ? %w[╰ ╯] : %w[╭ ╮]
+      middle = distribute(left, right, @inside, fill: "─")
+      " #{@theme.paint(corners.first, :border)}#{@theme.paint(middle, :border)}#{@theme.paint(corners.last, :border)} "
+    end
+
+    def panel(content, scroll: nil)
+      inside = Text.pad(Text.clip(content, @inside - 2), @inside - 2)
+      edge = @theme.paint(scroll ? "┃" : "│", scroll || :border)
+      " #{@theme.paint('│', :border)} #{inside}#{@theme.reset} #{edge} "
+    end
+
+    def distribute(left, right, width, fill: " ")
+      right = Text.clip(right, [width / 2, Text.width(right)].min)
+      available = [width - Text.width(right), 0].max
+      left = Text.clip(left, available, ellipsis: true)
+      gap = [width - Text.width(left) - Text.width(right), 0].max
+      left + @theme.reset + @theme.paint(fill * gap, :border) + right + @theme.reset
+    end
+
+    def tiny_frame(state, engine, rows)
+      title = @theme.paint(" FORUIMAN", :accent, bold: true)
+      message = engine.shutting_down? ? " Stopping…" : " #{state.name} · enlarge terminal"
+      lines = [title, @theme.paint(message, :muted)]
+      lines[rows - 1] = @theme.paint(" q quit", :accent) if rows > 2
+      frame(lines, rows)
+    end
+
+    def frame(lines, rows)
+      rendered = Array.new(rows) do |index|
+        # Erase before drawing, then restore the theme defaults. Reserve the last
+        # cell to avoid terminal autowrap.
+        "\e[2K#{@theme.base}#{self.class.truncate(lines[index].to_s, @width)}"
+      end.join("\r\n")
+      "\e[H#{rendered}"
+    end
+  end
+end

data/lib/foruiman/tui/state.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "viewport"
+
+module Foruiman::TUI
+  class State
+    attr_reader :tabs, :selected, :viewports
+    attr_accessor :help, :feedback
+
+    def initialize(names)
+      @tabs = [*names, "all"].freeze
+      @selected = tabs.size - 1
+      @viewports = tabs.to_h { |name| [name, Viewport.new] }
+      @help = false
+      @feedback = nil
+    end
+
+    def name
+      tabs[selected]
+    end
+
+    def viewport
+      viewports.fetch(name)
+    end
+
+    def select(index)
+      @selected = index if index.between?(0, tabs.size - 1)
+    end
+
+    def move(delta)
+      @selected = (selected + delta) % tabs.size
+    end
+  end
+end

data/lib/foruiman/tui/terminal.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Foruiman::TUI
+  class Terminal
+    ENTER = "\e[?1049h\e[?25l\e[0m"
+    LEAVE = "\e[0m\e[?25h\e[?1049l"
+
+    def initialize(input: $stdin, output: $stdout)
+      @input = input
+      @output = output
+    end
+
+    def session(&)
+      @output.write(ENTER)
+      @output.flush
+      @input.raw(intr: false, &)
+    ensure
+      begin
+        @output.write(LEAVE)
+        @output.flush
+      rescue IOError, SystemCallError
+        # Input's raw block has already restored its exact prior terminal mode.
+      end
+    end
+
+    def size
+      rows, columns = @output.winsize
+      [[rows, 1].max, [columns, 1].max]
+    rescue IOError, SystemCallError
+      [24, 80]
+    end
+
+    def read
+      @input.read_nonblock(4096, exception: false)
+    end
+
+    def draw(frame)
+      @output.write(frame)
+      @output.flush
+    end
+  end
+end