termgui 0.0.5 → 0.0.6

data/src/node.rb

@@ -0,0 +1,117 @@
+require_relative 'util'
+require_relative 'node_attributes'
+require_relative 'node_visit'
+require_relative 'emitter'
+
+module TermGui
+  # analog to HTML DOM Node class
+  # Ways of declaring node hierarchies by using parent and children props, or append_child or append_to methods. For declarative complex structures probably you want to use children
+  # `main = Row.new(parent: screen, height: 0.5, children: [Button.new(text: 'clickme', Col.new(width: 0.8, x: 0.2, children: [Label.new(text: 'hello')]))])`
+  # or
+  # `main = screen.append_child(Row.new(height: 0.5, children: [Button.new(text: 'clickme', Col.new(width: 0.8, x: 0.2, children: [Label.new(text: 'hello')]))]))`
+  # or
+  # `main = Row.new(height: 0.5, children: [Button.new(text: 'clickme', Col.new(width: 0.8, x: 0.2, children: [Label.new(text: 'hello')]))]).append_to(screen)`
+  class Node < Emitter
+    include NodeVisit
+
+    attr_reader :children, :text, :parent, :name
+    attr_writer :parent, :text
+
+    def initialize(**args)
+      @name = args[:name] || 'node'
+      @attributes = Attributes.new args[:attributes] || {}
+      @children = args[:children] || []
+      children.each { |child| child.parent = self }
+      @text = args[:text] || ''
+      args[:parent]&.append_children(self)
+      install(%i[after_render before_render])
+    end
+
+    # returns child so we can write:  `button = screen.append_child Row.new(text: 'click me')`
+    def append_children(*children)
+      children.each do |child|
+        @children.push(child)
+        child.parent = self
+      end
+      children
+    end
+
+    def append_child(child)
+      (append_children child)[0]
+    end
+
+    def insert_children(index = 0, *children)
+      @children.insert(index, *children)
+      children
+    end
+
+    def prepend_child(child)
+      insert_child(0, child)
+    end
+
+    def insert_child(index, child)
+      (insert_children index, child)[0]
+    end
+
+    def remove_children(*children)
+      children.each do |child|
+        @children.delete(child)
+        child.parent = self
+      end
+      children
+    end
+
+    def remove_child(child)
+      (remove_children child)[0]
+    end
+
+    def append_to(parent)
+      parent.append_child(self)
+      self
+    end
+
+    def remove
+      parent&.remove_child(self)
+      self.parent = nil
+    end
+
+    def empty
+      children.each do |child|
+        child.parent = nil
+      end
+      @children = []
+      self
+    end
+
+    def attributes(attrs = nil)
+      attrs&.each_key { |key| set_attribute(key.to_s, attrs[key]) }
+      @attributes
+    end
+
+    def attributes=(attrs = nil)
+      attributes(attrs)
+    end
+
+    def set_attribute(name, value)
+      @attributes.set_attribute(name, value)
+      self
+    end
+
+    def get_attribute(name)
+      @attributes.get_attribute(name)
+    end
+
+    def to_s
+      "Node(name: #{name}, children: [#{children.map(&:to_s).join(', ')}])"
+    end
+
+    def pretty_print(d = 0)
+      "#{(' ' * d)}<#{name} #{(attributes.pairs.map { |p| "#{p[:name]}=#{pretty_print_attribute p[:value]}" }).join(' ')}>\n#{' ' * (d + 1)}#{text ? " #{text}\n#{' ' * d}" : ''}#{children.map { |c| c.pretty_print d + 1 }.join("\n" + (' ' * d))}\n#{(' ' * (d + 1))}</#{name}>"
+    end
+
+    def pretty_print_attribute(a)
+      a.respond_to?(:pretty_print) ? a.pretty_print : a.to_s
+    end
+  end
+end
+Node = TermGui::Node

data/src/node_attributes.rb

@@ -0,0 +1,27 @@
+# Manages Node's attributes
+class Attributes
+  def initialize(attrs = {})
+    @attrs = attrs
+  end
+
+  def names
+    @attrs.keys
+  end
+
+  def pairs
+    @attrs.keys.map { |n| { name: n, value: @attrs[n] } }
+  end
+
+  def set_attribute(name, value)
+    @attrs[name.to_sym] = value
+    self
+  end
+
+  def get_attribute(name)
+    @attrs[name.to_sym]
+  end
+
+  def to_s
+    @attrs.to_s
+  end
+end

data/src/node_visit.rb

@@ -0,0 +1,52 @@
+# adds node recirsive visit support and node query operations
+module NodeVisit
+  def query_by_attribute(attr, value)
+    result = []
+    visit_node(self, proc { |n|
+      result.push n if n.attributes.get_attribute(attr) == value
+      false
+    })
+    result
+  end
+
+  def query_by_name(name)
+    result = []
+    visit_node(self, proc { |n|
+      result.push n if n.name == name
+      false
+    })
+    result
+  end
+
+  def query_one_by_attribute(attr, value)
+    result = nil
+    p = proc do |n|
+      if n.attributes.get_attribute(attr) == value
+        result = n
+        true
+      else
+        false
+      end
+    end
+    visit_node(self, p)
+    result
+  end
+
+  def visit(visitor, children_first = true)
+    visit_node(self, visitor, children_first)
+  end
+end
+
+# visit given node children bottom-up. If visitor returns truthy then visiting finishes
+def visit_node(node, visitor, children_first = true)
+  result = nil
+  unless children_first
+    result = visitor.call node
+    return result if result
+  end
+  result = some(node.children, proc { |child| visit_node child, visitor, children_first })
+  return result if result
+
+  result = visitor.call node if children_first
+  result
+end

data/src/renderer.rb

@@ -0,0 +1,119 @@
+require_relative 'style'
+require_relative 'key'
+require_relative 'renderer_print'
+require_relative 'renderer_cursor'
+require_relative 'renderer_image'
+require_relative 'renderer_draw'
+
+module TermGui
+  # Responsible of (TODO: we should split Renderer into several delegate classes
+  #  * build charsequences to render text on a position. these are directly write to $stdout by screen
+  #  * maintain bitmap-like buffer of current screen state
+  #  * manages current applied style
+  # TODO: add line, empty-rect and more drawing primitives
+  class Renderer
+    include RendererPrint
+    include RendererCursor
+    include RendererImage
+    include RendererDraw
+
+    attr_reader :width, :height, :buffer, :style
+    attr_writer :style, :no_buffer
+
+    def initialize(width = 80, height = 20, no_buffer = false)
+      @width = width
+      @height = height
+      @style = Style.new
+      @no_buffer = no_buffer
+      self.fast_colouring = true
+      unless no_buffer
+        @buffer = (0...@height).to_a.map do
+          (0...@width).to_a.map do
+            Pixel.new
+          end
+        end
+      end
+    end
+
+    # all writing must be done using me
+    def write(x, y, s, style = nil)
+      if y < @height && y >= 0
+        # TODO: x could be negative now, trunc ch to respect screen bounds - if not negative values are printed at the right
+        if x < 0
+          s = s[[x * -1, s.length].min..s.length]
+          x = 0
+        end
+        unless @no_buffer
+          (x...[x + s.length, @width].min).to_a.each do |i|
+            @buffer[y][i].ch = s[i - x]
+            @buffer[y][i].style = (style || @style).clone
+          end
+        end
+        # apply the style after writing to the buffer so it don't contains escape secuences just the chars
+        s = style == nil ? s : style.print(s)
+        "#{move x, y + 1}#{s}" # TODO: investigate why y + 1
+      else
+        ''
+      end
+    end
+
+    def move(x, y)
+      Renderer.move x, y
+    end
+
+    def self.move(x, y)
+      "#{CSI}#{y};#{x}H"
+    end
+
+    def text(x: 0, y: 0, text: ' ', style: nil)
+      write(x, y, text, style)
+    end
+
+    def rect(x: 0, y: 0, width: 5, height: 3, ch: Pixel.EMPTY_CH, style: nil)
+      s = []
+      ch = Pixel.EMPTY_CH if ch == nil
+      height.times do |y_|
+        s .push write(x, y + y_, ch * width, style).to_s
+      end
+      s.join('')
+    end
+
+    def clear
+      @style = Style.new
+      unless @no_buffer
+        @buffer.each_index do |y|
+          @buffer[y].each do |p|
+            p.ch = Pixel.EMPTY_CH
+            p.style.reset
+          end
+        end
+      end
+      "#{CSI}0m#{CSI}2J"
+    end
+
+    def style_assign(style)
+      @style.assign(style)
+    end
+
+    def fast_colouring=(value)
+      Style.fast_colouring(value)
+    end
+  end
+
+  # Represents a pixel in renderer's buffer
+  class Pixel
+    attr_accessor :ch, :style
+
+    def self.EMPTY_CH
+      ' '
+    end
+
+    def initialize(ch = Pixel.EMPTY_CH, style = Style.new)
+      @ch = ch
+      @style = style
+    end
+  end
+end
+
+Renderer = TermGui::Renderer
+Pixel = TermGui::Pixel

data/src/renderer_cursor.rb

@@ -0,0 +1,18 @@
+# takes care of cursor related ansi escape sequences
+module RendererCursor
+  def cursor_save
+    "#{CSI}s"
+  end
+
+  def cursor_restore
+    "#{CSI}u"
+  end
+
+  def cursor_show
+    "#{CSI}?25h"
+  end
+
+  def cursor_hide
+    "#{CSI}?25l"
+  end
+end

data/src/renderer_draw.rb

@@ -0,0 +1,28 @@
+require 'chunky_png'
+
+# takes care of drawing shapes. Based on Image (uses chunky_png Canvas)
+# TODO: we should use TermGui::Image and not ChunkyPNG's so we add value there too
+module RendererDraw
+  def circle(x: nil, y: nil, radius: nil, stroke_ch: ' ', stroke: nil, fill: nil, fill_ch: stroke_ch)
+    canvas = draw_canvas
+    canvas.circle(x, y, radius, ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE)
+    radius = []
+    canvas.height.times do |y2|
+      canvas.width.times do |x2|
+        if canvas[x2, y2] == ChunkyPNG::Color::BLACK && stroke
+          radius.push text(x: x2, y: y2, text: stroke_ch, style: stroke)
+        elsif canvas[x2, y2] == ChunkyPNG::Color::WHITE && fill
+          radius.push text(x: x2, y: y2, text: fill_ch, style: fill)
+        end
+      end
+    end
+    radius.join
+  end
+
+  private
+
+  def draw_canvas
+    # TODO: reuse the canvas
+    ChunkyPNG::Canvas.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+  end
+end

data/src/renderer_image.rb

@@ -0,0 +1,31 @@
+require_relative 'image'
+
+# takes care rendering given Images
+module RendererImage
+  # renders given Image or file path at given x, y coords. Currently only PNG format supported.
+  # by default bg attribute is used and space is printed for each pixel but this could be configured using fg, bg, and ch
+  # ch can be an array of chars in which case a random one is taken for each pixel
+  def image(x: 0, y: 0, image: nil, ch: ' ', style: Style.new, fg: false, bg: true, h: height - y, w: width - x,
+            transparent_color: nil) # if a [r,g,b] color is given, then alpha channel will be considered to mix colors accordingly
+    output = []
+    image = image.is_a?(String) ? TermGui::Image.new(image) : image
+    (y..[y + image.height - 1, height - 1].min).to_a.each do |y2|
+      (x..[x + image.width - 1, width - 1].min).to_a.each do |x2|
+        pixel = image.rgb(x2 - x, y2 - y, transparent_color)
+        style.bg = pixel if bg
+        style.fg = pixel if fg
+        output .push text(x: x2, y: y2, text: ch.is_a?(Array) ? ch.sample : ch, style: style) if x2 < w && y2 < h
+      end
+    end
+    output.join('')
+  end
+
+  private
+
+  def mix_colors(fg, bg, alpha = 0.5)
+    r = (fg[0] * alpha + bg[0] * (1 - alpha)).to_i
+    g = (fg[1] * alpha + bg[1] * (1 - alpha)).to_i
+    b = (fg[2] * alpha + bg[2] * (1 - alpha)).to_i
+    [r, g, b]
+  end
+end

data/src/renderer_print.rb

@@ -0,0 +1,40 @@
+require_relative 'style'
+require_relative 'key'
+
+# takes care of printing renderer buffer in different ways
+module RendererPrint
+  # prints current buffer as string
+  def print
+    s = []
+    @buffer.each_index do |y|
+      @buffer[y].each do |p|
+        s .push p.ch
+      end
+      s .push '\n'
+    end
+    s.join('')
+  end
+
+  def print_rows
+    rows = []
+    @buffer.each_index do |y|
+      line = []
+      @buffer[y].each do |p|
+        line .push p.ch
+      end
+      rows.push(line.join(''))
+    end
+    rows
+  end
+
+  # prints to stdout a representation in ruby string concatenated syntax so its easy for devs copy&paste for test asserts
+  def print_dev_stdout
+    print.split('\\n').each { |line| puts "'#{line}\\n' + " }
+  end
+
+  def print_dev
+    s = "'' + \n"
+    print.split('\\n').each { |line| s = "#{s}#{line}\\n' + \n" }
+    s + "''"
+  end
+end

data/src/screen.rb

@@ -0,0 +1,96 @@
+require_relative 'element'
+require_relative 'renderer'
+require_relative 'input'
+require_relative 'event'
+require_relative 'focus'
+require_relative 'action'
+require_relative 'util'
+require_relative 'screen_element'
+require_relative 'screen_input'
+require_relative 'screen_renderer'
+
+module TermGui
+  # Main user API entry point
+  # Manages instances of Input, Event, Renderer (by default disabling its buffer)
+  # Is a Node so new elements can be append_child
+  # Once `start`is called it will block execution and start an event loop
+  # on each interval user input is read and event listeners are called
+  class Screen < Node
+    include ScreenElement
+    include ScreenInput
+    include ScreenRenderer
+    attr_reader :width, :height, :input_stream, :output_stream, :renderer, :input, :event, :focus, :action
+    attr_accessor :silent
+
+    def initialize(
+      children: [], text: '', attributes: {}, exit_keys: %w[q C-c], no_exit_keys: false,
+      width: nil, height: nil, silent: false
+    )
+      super(name: 'screen', children: children, text: text, attributes: attributes, parent: nil)
+      install(%i[destroy after_destroy start after_start])
+      @width = width == nil ? terminal_width : width
+      @height = height == nil ? terminal_height : height
+      @input_stream = $stdin
+      @silent = silent
+      @exit_keys = exit_keys
+      @output_stream = $stdout
+      @renderer = Renderer.new(@width, @height)
+      @input = Input.new
+      @event = EventManager.new @input
+      @focus = FocusManager.new(root: self, event: @event)
+      @action = ActionManager.new(focus: @focus, event: @event)
+      @renderer.no_buffer = true
+      install_exit_keys unless no_exit_keys
+    end
+
+    def self.new_for_testing(**args)
+      instance = new(args.merge(no_exit_keys: true, silent: true))
+      instance.renderer.no_buffer = false
+      instance
+    end
+
+    def terminal_width
+      $stdout.winsize[1]
+    rescue StandardError
+      80
+    end
+
+    def terminal_height
+      $stdout.winsize[0]
+    rescue StandardError
+      24
+    end
+
+    # start listening for user input. This starts an user input event loop
+    # that ends when screen.destroy is called
+    def start(clean: false)
+      emit :start
+      unless clean
+        clear
+        cursor_hide # TODO: move this to a CursorManager :start listener
+        render
+      end
+      emit :after_start
+      yield if block_given?
+      @input.start
+    end
+
+    def destroy
+      emit :destroy
+      @input.stop
+      cursor_show # TODO: move this to a CursorManager :destroy listener
+      emit :after_destroy
+    end
+
+    # writes directly to @output_stream. Shouldn't be used directly since these changes won't be tracked by the buffer.
+    def write(s)
+      @output_stream.write s unless @silent
+      s
+    end
+
+    def alert
+      puts "\a"
+    end
+  end
+end
+Screen = TermGui::Screen