termgui 0.0.4 → 0.0.5

data/src/node.rb

@@ -1,117 +0,0 @@
-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

@@ -1,27 +0,0 @@
-# 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

@@ -1,52 +0,0 @@
-# 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

@@ -1,119 +0,0 @@
-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

@@ -1,18 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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