rcurses 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0a752aa8312d1c3b9ec5683f490da7666ca4e82599d7157105fcdfcfa7ce526
+  data.tar.gz: a86545340dd98c390fca814a0e5d5521fc3def15ec56ba9c13d6ab12766109ee
+SHA512:
+  metadata.gz: '038fb306d29aab4f30fa355a637cbd2338970458432fddca29f2e92faca3404a670b4641220e72cffd7f821bf6514c3f0838d7a764a6899eb00b8d84cd502120'
+  data.tar.gz: 51e91e08b86d542d9b5d15050218decc2f0ed0debbe1d9c9eaacc2033b2b9c1cf0dd9ec39f27003670298590639bc5c6b66a730057e1f0af491a9858ab2f2e25

data/README.md

@@ -0,0 +1,197 @@
+# rcurses - An alternative curses library written in pure Ruby
+
+![Ruby](https://img.shields.io/badge/language-Ruby-red) ![Unlicense](https://img.shields.io/badge/license-Unlicense-green) ![Stay Amazing](https://img.shields.io/badge/Stay-Amazing-important)
+
+<img src="img/rcurses-logo.png" width="150" height="150">
+
+
+# Why?
+Having struggled with the venerable curses library and the ruby interface to it for many years, I finally got around to write an alternative - in pure Ruby.
+
+# Design principles
+Simple. One file. No external requirements.
+
+# Installation
+Clone this repo and drop `lib/rcurses.rb` into `/usr/lib/ruby/vendor_ruby/`
+
+Or simply `gem install rcurses` (when I get around to create the gem and this comment is removed).
+
+To use this library do:
+```
+require 'rcurses'
+```
+
+# Features
+* Create panes (with the colors and(or border), manipulate the panes and add content
+* Dress up text (in panes or anywhere in the terminal) in bold, italic, underline, reverse color, blink and in any 256 terminal colors for foreground and background
+* Use a simple editor to let users edit text in panes
+* Left, right or center align text in panes
+* Cursor movement around the terminal
+
+# The elements
+`rcurses` gives you the following elements:
+* The class `Pane` to create and manilpulate panes/boxes
+* Extensions to the class String to print text in various degrees of fancy and also strip any fanciness
+* A module `Cursor` to give you cursor movements around the terminal
+* A top level function `getchr` to capture a single character input from the user (much better than any Ruby built-ins)
+
+# class Pane
+To create a pane do something like this:
+```
+mypane = Pane.new(80, 30, 30, 10, 19, 229)
+```
+This will create a pane/box starting at terminal column/x 80 and row/y 30 with the width of 30 characters and a hight of 10 characters and with the foreground color 19 and background color 229 (from the 256 choices available)
+
+The format for creating a pane is:
+```
+Pane.new(startx, starty, width, height, foregroundcolor, backgroundcolor)
+```
+You can drop the last two 256-color codes to create a pane with the defaults for your terminal. Also, you can add anything as `startx`, `starty`, `width` or `height` as those values will be run through a Ruby eval and stored in readable variables `x`, `y`, `w` and `h` respectively. So, a hight value of "@maxrow/2" is valid to create a pane with the height of half the terminal height (the integer corresponding to half the terminal height will then be accessible as the variable `h`). Use the variables @maxrow for terminal height and @maxcol for terminal width.
+
+Avaliable properties/variables:
+
+Property       | Description
+---------------|---------------------------------------------------------------
+startx         | The `x` value to be "Eval-ed"
+x              | The readable x-value for the Pane
+starty         | The `y` value to be "Eval-ed"
+y              | The readable y-value for the Pane
+width          | The Pane width to be "Eval-ed"
+w              | The readable w-value for the Pane
+height         | The Pane height to be "Eval-ed"
+h              | The readable h-value for the Pane
+fg             | Foreground color for the Pane
+bg             | Background color for the Pane
+border         | Draw border around the Pane (=true) or not (=false), default being false
+scroll         | Whether to indicate more text to be shown above/below the Pane, default is true
+text           | The text/content of the Pane
+ix             | "Index" - the line number at the top of the Pane, starts at 0, the first line of text in the Pane
+align          | Text alignment in the Pane: "l" = lefts aligned, "c" = center, "r" = right, with the default "l"
+prompt         | The prompt to print at the beginning of a one-liner Pane used as an input box
+
+The methods for Pane:
+
+Method         | Description
+---------------|---------------------------------------------------------------
+new/init       | Initializes a Pane with optional arguments startx, starty, width, height, foregroundcolor and backgroundcolor
+move(x,y)      | Move the pane by `x`and `y` (`mypane.move(-4,5)` will move the pane left four characters and five characters down)
+refresh        | Refreshes/redraws the Pane with content
+edit           | An editor for the Pane. When this is invoked, all existing font dressing is stripped and the user gets to edit the raw text. The user can add font effects similar to Markdown; Use an asterisk before and after text to be drawn in bold, text between forward-slashes become italic, and underline before and after text means the text will be underlined, a hash-sign before and after text makes the text reverse colored. You can also combine a whole set of dressings in this format: `<23,245,biurl|Hello World!>` - this will make "Hello World!" print in the color 23 with the background color 245 (regardless of the Pane's fg/bg setting) in bold, italic, underlined, reversed colored and blinking. Hitting `ESC` while in edit mode will disregard the edits, while `Ctrl-S` will save the edits
+editline       | Used for one-line Panes. It will print the content of the property `prompt` and then the property `text` that can then be edited by the user. Hitting `ESC` will disregard the edits, while `ENTER` will save the edited text
+
+# class String extensions
+Method extensions provided for the class String:
+
+Method         | Description
+---------------|---------------------------------------------------------------
+fg(fg)         | Set text to be printed with the foreground color `fg` (example: `"TEST".fg(84)`)
+bg(bg)         | Set text to be printed with the background color `bg` (example: `"TEST".bg(196)`)
+fb(fg, bg)     | Set text to be printed with the foreground color `fg` and background color `bg` (example: `"TEST".fb(84,196)`)
+b              | Set text to be printed in bold (example: `"TEST".b`)
+i              | Set text to be printed in italic (example: `"TEST".i`)
+u              | Set text to be printed underlined (example: `"TEST".u`)
+l              | Set text to be printed blinking (example: `"TEST".l`)
+r              | Set text to be printed in reverse colors (example: `"TEST".r`)
+c(code)        | Use coded format like "TEST".c("204,45,bui") to print "TEST" in bold, underline italic, fg=204 and bg=45 (the format is `.c("fg,bg,biulr"))
+pure           | Strip text of any "dressing" (example: with `text = "TEST".b`, you will have bold text in the variable `text`, then with `text.pure` it will show "uncoded" or pure text)
+
+# module Cursor
+Create a new cursor object with `mycursor = Cursor`. Then you can apply the following methods to `mycursor`:
+
+Method            | Description
+------------------|---------------------------------------------------------------
+save              | Save current position
+restore           | Restore cursor position
+pos               | Query cursor current position (example: `row,col = mycursor.pos`)
+colget            | Query cursor current cursor col/x position (example: `row = mycursor.rowget`)
+rowget            | Query cursor current cursor row/y position (example: `row = mycursor.rowget`)         
+up(n = 1)         | Move cursor up by n (default is 1 character up)
+down(n = 1)       | Move cursor down by n (default is 1 character down)
+left(n = 1)       | Move cursor backward by n (default is one character)
+right(n = 1)      | Move cursor forward by n (default is one character)
+col(n = 1)        | Cursor moves to the nth position horizontally in the current line (default = first column)
+row(n = 1)        | Cursor moves to the nth position vertically in the current column (default = first/top row)
+next_line)        | Move cursor down to beginning of next line
+prev_line)        | Move cursor up to beginning of previous line
+clear_char(n = 1) | Erase n characters from the current cursor position (default is one character)
+clear_line        | Erase the entire current line and return to beginning of the line
+clear_line_before | Erase from the beginning of the line up to and including the current cursor position
+clear_line_after  | Erase from the current position (inclusive) to the end of the line
+scroll_up         | Scroll display up one line
+scroll_down       | Scroll display down one line
+clear_screen_down | Clear screen down from current row
+
+# function getchr
+rcurses provides a vital extension to Ruby in reading characters entered by the user. This is especially needed for curses applications where readline inputs are required.
+
+Simply use `chr = getchr` in a program to read any character input by the user. The returning code (the content of `chr` in this example could be any of the following:
+
+Key pressed     | string returned
+----------------|----------------------------------------------------------
+`esc`           | "ESC"
+`up`            | "UP"
+`ctrl-up`       | "C-UP"
+`down`          | "DOWN"
+`ctrl-down`     | "C-DOWN"
+`right`         | "RIGHT"
+`ctrl-right`    | "C-RIGHT"
+`left`          | "LEFT"
+`ctrl-left`     | "C-LEFT"
+`shift-tab`     | "S-TAB"
+`insert`        | "INS"   
+`ctrl-insert`   | "C-INS"
+`del`           | "DEL"   
+`ctrl-del`      | "C-DEL"
+`pageup`        | "PgUP"  
+`ctrl-pageup`   | "C-PgUP"
+`pagedown`      | "PgDOWN"
+`ctrl-pagedown` | "C-PgDOWN"
+`home`          | "HOME"  
+`ctrl-home`     | "C-HOME"
+`end`           | "END"   
+`ctrl-end`      | "C-END"
+`backspace`     | "BACK"
+`ctrl-h`        | "BACK"
+`ctrl-a`        | "C-A"
+`ctrl-b`        | "C-B"
+`ctrl-c`        | "C-C"
+`ctrl-d`        | "C-D"
+`ctrl-e`        | "C-E"
+`ctrl-f`        | "C-F"
+`ctrl-g`        | "C-G"
+`ctrl-i`        | "C-I"
+`ctrl-j`        | "C-J"
+`ctrl-k`        | "C-K"
+`ctrl-l`        | "C-L"
+`ctrl-m`        | "C-M"
+`ctrl-n`        | "C-N"
+`ctrl-o`        | "C-O"
+`ctrl-p`        | "C-P"
+`ctrl-q`        | "C-Q"
+`ctrl-r`        | "C-R"
+`ctrl-s`        | "C-S"
+`ctrl-t`        | "C-T"
+`ctrl-u`        | "C-U"
+`ctrl-v`        | "C-V"
+`ctrl-a`        | "WBACK"
+`ctrl-x`        | "C-X"
+`ctrl-y`        | "C-Y"
+`ctrl-z`        | "C-Z"
+`enter`         | "ENTER"
+`tab`           | "TAB"
+
+Any other character enter will be returned (to `chr` in the example above).
+
+In order to handle several character pased into STDIN by the user (and not only returned the first character only, your program should empty the STDIN like this:
+
+```
+while $stdin.ready?
+  chr += $stdin.getc
+end
+```
+
+# Not yet implemented
+Let me know what other features you like to see.
+
+# License and copyright
+Just steal or borrow anything you like. This is now Public Domain.

data/extconf.rb

@@ -0,0 +1,33 @@
+require 'fileutils'
+
+# Define the source file and the target directory
+source_file = File.join(File.dirname(__FILE__), 'lib/rcurses.rb')
+target_dir = '/usr/lib/ruby/vendor_ruby'
+
+# Check if we have write permission to the target directory
+unless File.writable?(target_dir)
+  abort("You need root permissions to install to #{target_dir}. Please run as root or use sudo.")
+end
+
+# Create the target directory if it doesn't exist
+FileUtils.mkdir_p(target_dir)
+
+# Copy the file
+FileUtils.cp(source_file, target_dir)
+
+puts "Installed #{source_file} to #{target_dir}"
+
+# Create a dummy Makefile to satisfy Ruby's gem installation process
+File.open('Makefile', 'w') do |f|
+  f.puts <<-MAKEFILE
+all:
+\t@echo "Nothing to build"
+
+clean:
+\t@echo "Nothing to clean"
+
+install:
+\t@echo "Installation handled by extconf.rb"
+  MAKEFILE
+end
+

data/lib/rcurses.rb

@@ -0,0 +1,528 @@
+# INFORMATION
+# Name:       rcurses - Ruby CURSES
+# Language:   Pure Ruby, best viewed in VIM
+# Author:     Geir Isene <g@isene.com>
+# Web_site:   http://isene.com/
+# Github:     https://github.com/isene/rcurses
+# License:    Public domain
+# Version    = 0.1 : Initial upload to GitHub
+
+class Pane
+  attr_accessor :startx, :starty, :width, :height, :fg, :bg
+  attr_reader :x, :y, :w, :h
+  attr_accessor :border, :scroll, :text, :ix, :align, :prompt
+  def initialize(startx=1, starty=1, width=1, height=1, fg=nil, bg=nil)
+    @startx, @starty, @width, @height, @fg, @bg = startx, starty, width, height, fg, bg
+    @text   = ""      # Initialize text variable
+    @align  = "l"     # Default alignment
+    @scroll = true    # Initialize scroll indicators to true
+    @prompt = ""      # Initialize prompt for editline
+    @c      = Cursor  # Local cursor object
+    @ix     = 0       # Text index (starting text line in pane)
+    self.refresh      # Draw the pane upon creation
+  end
+  def move (x,y)
+    self.startx = self.x + x
+    self.starty = self.y + y
+    self.refresh
+  end
+  def ansicheck(string, ansi)
+    ansi_beg = /\u0001\e\[#{ansi[0].to_s}m\u0002/
+    if ansi[0] == 38 or ansi[0] == 48
+      ansi_beg = /\u0001\e\[#{ansi[0].to_s}[\d;m]+\u0002/
+    end
+    ansi_end = /\u0001\e\[#{ansi[1].to_s}m\u0002/
+    begix = string.rindex(ansi_beg)
+    begix = -1 if begix == nil
+    endix = string.rindex(ansi_end)
+    endix = -1 if endix == nil
+    dirty = string[begix..-1].match(ansi_beg)[0] if begix > endix
+    dirty.to_s
+  end
+  def textformat(cont=self.text)
+    @txt = cont.split("\n") # Split text into array
+    if @txt.any? { |line| line.length >= self.w } # Splitx for lines breaking width
+      @txt = cont.splitx(self.w) 
+      if cont != cont.pure # Treat lines that break ANSI escape codes
+        @dirty = "" # Initiate dirty flag (for unclosed ANSI escape sequence)
+        @txt.each_index do |i|
+          if @dirty != "" # If dirty flag is set from previous line then add the ANSI sequence to beginning of this line
+            @txt[i] = @dirty + @txt[i]; @dirty = ""
+          end
+          @dirty += ansicheck(@txt[i], [1,22]) # Bold
+          @dirty += ansicheck(@txt[i], [3,23]) # Italic
+          @dirty += ansicheck(@txt[i], [4,24]) # Underline
+          @dirty += ansicheck(@txt[i], [5,25]) # Blink
+          @dirty += ansicheck(@txt[i], [7,27]) # Reverse
+          @dirty += ansicheck(@txt[i], [38,0]) # Foreground color
+          @dirty += ansicheck(@txt[i], [48,0]) # Background color
+          @txt[i].sub!(/[\u0001\u0002\e\[\dm]*$/, '')
+        end
+      end
+    end
+    @txt
+  end
+  def refresh(cont=self.text)
+    o_row, o_col = @c.pos
+    @c.row(8000); @c.col(8000) # Set for maxrow/maxcol
+    @maxrow, @maxcol = @c.pos
+    self.x = eval(self.startx.to_s)
+    self.y = eval(self.starty.to_s)
+    self.w = eval(self.width.to_s)
+    self.h = eval(self.height.to_s)
+    if self.border # Keep panes inside screen
+      self.x = 2 if self.x < 2; self.x = @maxcol - self.w if self.x + self.w > @maxcol
+      self.y = 2 if self.y < 2; self.y = @maxrow - self.h if self.y + self.h > @maxrow
+    else
+      self.x = 1 if self.x < 1; self.x = @maxcol - self.w + 1 if self.x + self.w > @maxcol + 1
+      self.y = 1 if self.y < 1; self.y = @maxrow - self.h + 1 if self.y + self.h > @maxrow + 1
+    end
+    @c.col(self.x); @c.row(self.y) # Cursor to start of pane
+    fmt = self.fg.to_s + "," + self.bg.to_s # Format for printing in pane (fg,bg)
+    @txt = textformat(cont) # Call function to create an array out of the pane text
+    @ix = @txt.length - 1 if @ix > @txt.length - 1; @ix = 0 if @ix < 0 # Ensuring no out-of-bounds
+    self.h.times do |i| # Print pane content
+      l = @ix + i # The current line to be printed
+      if @txt[l].to_s != "" # Print the text line for line
+        pl = self.w - @txt[l].pure.length; hl = pl/2 # Get padding width and half width
+        print @txt[l].c(fmt) + " ".c(fmt) * pl if self.align == "l"
+        print " ".c(fmt) * pl + @txt[l].c(fmt) if self.align == "r"
+        print " ".c(fmt) * hl + @txt[l].c(fmt) + " ".c(fmt) * (pl - hl) if self.align == "c"
+      else
+        print  "".rjust(self.w).bg(self.bg)
+      end
+      r,c = @c.pos
+      @c.row(r + 1)  # Cursor down one line
+      @c.col(self.x) # Cursor to start of pane
+    end
+    if @ix > 0 and self.scroll # Print "more" marker at top
+      @c.col(self.x + self.w - 1); @c.row(self.y)
+      print "▲".c(fmt)
+    end
+    if @txt.length - @ix > self.h and self.scroll # Print bottom "more" marker
+      @c.col(self.x + self.w - 1); @c.row(self.y + self.h - 1)
+      print "▼".c(fmt)
+    end
+    if self.border # Print border if self.border is set to "true"
+      @c.row(self.y - 1); @c.col(self.x - 1)
+      print ("┌" + "─" * self.w + "┐").c(fmt) 
+      self.h.times do |i|
+        @c.row(self.y + i); @c.col(self.x - 1)
+        print "│".c(fmt)  
+        @c.col(self.x + self.w)
+        print "│".c(fmt)
+      end
+      @c.row(self.y + self.h); @c.col(self.x - 1)
+      print ("└" + "─" * self.w + "┘").c(fmt) 
+    end
+    @c.row(o_row)
+    @c.col(o_col)
+    @txt
+  end
+  def right
+    if @pos < @txt[self.ix + @line].length
+      @pos += 1 
+    else
+      if @line == self.h
+        self.ix += 1 unless self.ix >= @txt.length
+        @pos = 0
+      elsif @line + self.ix + 2 <= @txt.length
+        @line += 1
+        @pos = 0
+      end
+    end
+  end
+  def left
+  if @pos == 0
+    if @line == 0
+        unless self.ix == 0
+          self.ix -= 1 
+          @pos = @txt[self.ix + @line].length - 1
+        end
+      else
+        @line -= 1
+        @pos = @txt[self.ix + @line].length - 1
+      end
+    else
+      @pos -= 1
+    end
+  end
+  def up
+    if @line == 0
+      self.ix -= 1 unless self.ix == 0
+    else
+      @line -= 1
+    end
+    begin
+      @pos = @txt[self.ix + @line].length - 1 if @pos > @txt[self.ix + @line].length - 1
+    rescue
+    end
+  end
+  def down
+    if @line == self.h - 1
+      self.ix += 1 unless self.ix + @line >= @txt.length - 1
+    elsif @line + self.ix + 2 <= @txt.length
+      @line += 1
+    end
+    begin
+      @pos = @txt[self.ix + @line].length - 1 if @pos > @txt[self.ix + @line].length - 1
+    rescue
+    end
+  end
+  def parse(cont)
+    cont.gsub!(/\*(.+?)\*/,           '\1'.b)
+    cont.gsub!(/\/(.+?)\//,           '\1'.i)
+    cont.gsub!(/_(.+?)_/,             '\1'.u)
+    cont.gsub!(/#(.+?)#/,             '\1'.r)
+    cont.gsub!(/<([^|]+)\|([^>]+)>/) do |m|
+      text = $2; codes = $1
+      text.c(codes)
+    end
+    cont
+  end
+  def edit
+    cont = self.text.pure.gsub(/\n/, "¬\n") 
+    @line = self.ix
+    @pos  = 0
+    chr   = ""
+    while chr != "ESC" # Keep going with readline until user presses ESC
+      @txt = self.refresh(cont)
+      @c.row(self.y + @line)
+      @c.col(self.x + @pos)
+      chr = getchr
+      case chr
+      when 'C-L'    # Left justify
+        self.align = "l"
+      when 'C-R'    # Right Justify
+        self.align = "r"
+      when 'C-C'    # Center justify
+        self.align = "c"
+      when 'C-Y'    # Copy pane content to clipboard
+        system("echo '#{self.text.pure}' | xclip")
+      when 'C-S'    # Save edited text back to self.text
+        cont = cont.gsub("¬", "\n")
+        cont = parse(cont)
+        self.text = cont
+        chr = "ESC"
+      when 'DEL'    # Delete character
+        posx = 0; (self.ix + @line).times {|i| posx += @txt[i].length + 1}; posx += @pos
+        cont[posx] = ""
+      when 'BACK'   # Backspace
+        left
+        posx = 0; (self.ix + @line).times {|i| posx += @txt[i].length + 1}; posx += @pos
+        cont[posx] = ""
+      when 'WBACK'  # Word backspace
+        posx = 0; (self.ix + @line).times {|i| posx += @txt[i].length + 1}; posx += @pos
+        until cont[posx - 1] == " " or @pos == 0
+          left
+          posx = 0; (self.ix + @line).times {|i| posx += @txt[i].length + 1}; posx += @pos
+          cont[posx] = ""
+        end
+      when 'C-K'    # Kill line
+        begin
+          prev_l = 0
+          line_c = self.ix + @line
+          line_c.times {|i| prev_l += @txt[i].length + 1}
+          cur_l  = @txt[line_c].length
+          cont.slice!(prev_l,cur_l)
+        rescue
+        end
+      when 'UP'     # Up one line
+        up
+      when 'DOWN'   # Down one line
+        down
+      when 'RIGHT'  # Right one character
+        right
+      when 'LEFT'   # Left one character
+        left
+      when 'HOME'   # Start of line
+        @pos = 0
+      when 'END'    # End of line
+        @pos = @txt[self.ix + @line].length - 1
+      when 'C-HOME' # Start of pane
+        @line = 0
+        @pos = 0
+      when 'C-END'  # End of pane
+      when 'ENTER'
+        posx = 0; (self.ix + @line).times {|i| posx += @txt[i].length + 1}; posx += @pos
+        cont.insert(posx,"¬\n")
+        right
+      when /^.$/
+        posx = 0; (self.ix + @line).times {|i| posx += @txt[i].length + 1}; posx += @pos
+        cont.insert(posx,chr)
+      end
+      charx = 1
+      posx  = 0; (self.ix + @line).times {|i| posx += @txt[i].length + 1}; posx += @pos
+      while $stdin.ready?
+        chr = $stdin.getc
+        charx += 1
+        posx  += 1
+        cont.insert(posx,chr)
+      end
+      if chr =~ /^.$/
+        self.refresh(cont)
+        charx.times {right}
+      end
+
+    end
+    # Keep?
+    @c.row(nil)
+    @c.col(nil)
+  end
+  def editline
+    self.x = eval(self.startx.to_s)
+    self.y = eval(self.starty.to_s)
+    self.w = eval(self.width.to_s)
+    self.h = eval(self.height.to_s)
+    self.x = 1 if self.x < 1; self.x = @maxcol - self.w + 1 if self.x + self.w > @maxcol + 1
+    self.y = 1 if self.y < 1; self.y = @maxrow - self.h + 1 if self.y + self.h > @maxrow + 1
+    self.scroll = false
+    @c.row(self.y)
+    fmt = self.fg.to_s + "," + self.bg.to_s   # Format for printing in pane (fg,bg)
+    @c.col(self.x); print self.prompt.c(fmt)  # Print prompt from start of pane
+    pl    = self.prompt.pure.length           # Prompt length
+    cl    = self.w - pl                       # Available content length
+    cont  = self.text.pure                    # Actual content
+    @pos  = cont.length                       # Initial position set at end of content
+    chr   = ""                                # Initialize chr
+    while chr != "ESC"                        # Keep going with readline until user presses ESC
+      @c.col(self.x + pl)                     # Set cursor at start of content
+      cont = cont.slice(0,cl)                 # Trim content to max length
+      print cont.ljust(cl).c(fmt)             # Print content left justified to max length
+      @c.col(self.x + pl + @pos)              # Set cursor to current position (@pos)
+      chr = getchr                            # Read character from user input
+      case chr
+      when 'LEFT'                             # One character left
+        @pos -= 1 unless @pos == 0
+      when 'RIGHT'                            # One character right
+        @pos += 1 unless @pos >= cont.length
+      when 'HOME'                             # To start of content
+        @pos = 0
+      when 'END'                              # To end of content
+        @pos = cont.length - 1
+      when 'DEL'                              # Delete character
+        cont[@pos] = ""
+      when 'BACK'                             # Backspace
+        @pos -= 1 unless @pos == 0
+        cont[@pos] = ""
+      when 'WBACK'                            # Word backspace
+        until cont[@pos - 1] == " " or @pos == 0
+          @pos -= 1
+          cont[@pos] = ""
+        end
+      when 'C-K'                              # Kill line (set content to nothing)
+        cont = ""
+        @pos = 0
+      when 'ENTER'                            # Save content to self.text and end
+        self.text = parse(cont)
+        chr = 'ESC'
+      when /^.$/                              # Add character to content
+        unless @pos >= cl - 1
+          cont.insert(@pos,chr)
+          @pos += 1
+        end
+      end
+      while $stdin.ready?                     # Add characters from pasted input  
+        chr = $stdin.getc
+        unless @pos >= cl - 1
+          cont.insert(@pos,chr)
+          @pos += 1
+        end
+      end
+    end
+    # Keep? Set cursor away from pane
+    @c.row(nil)
+    @c.col(nil)
+  end
+end
+
+class String # Add coloring to strings (with escaping for Readline)
+  def fg(fg);     color(self, "\001\e[38;5;#{fg}m\002", "\001\e[0m\002"); end # Foreground color code
+  def bg(bg);     color(self, "\001\e[48;5;#{bg}m\002", "\001\e[0m\002"); end # Background color code
+  def fb(fg, bg); color(self, "\001\e[38;5;#{fg};48;5;#{bg}m\002"); end       # Fore/Background color code
+  def b;          color(self, "\001\e[1m\002", "\001\e[22m\002"); end         # Bold
+  def i;          color(self, "\001\e[3m\002", "\001\e[23m\002"); end         # Italic
+  def u;          color(self, "\001\e[4m\002", "\001\e[24m\002"); end         # Underline
+  def l;          color(self, "\001\e[5m\002", "\001\e[25m\002"); end         # Blink
+  def r;          color(self, "\001\e[7m\002", "\001\e[27m\002"); end         # Reverse
+  def color(text, sp, ep) "#{sp}#{text}#{ep}" end                             # Internal function
+  def c(code) # Use format "TEST".c("204,45,bui") to print "TEST" in bold, underline italic, fg=204 and bg=45 
+    prop  = "\001\e["
+    prop += "38;5;#{code.match(/^\d+/).to_s};"      if code.match(/^\d+/) 
+    prop += "48;5;#{code.match(/(?<=,)\d+/).to_s};" if code.match(/(?<=,)\d+/) 
+    prop += "1;" if code.match(/b/) 
+    prop += "3;" if code.match(/i/) 
+    prop += "4;" if code.match(/u/) 
+    prop += "5;" if code.match(/l/) 
+    prop += "7;" if code.match(/r/) 
+    prop.chop! if prop[-1] == ";"
+    prop += "m\002"
+    prop += self
+    prop += "\001\e[0m\002"
+    #puts "\n XX\n" + code
+    prop
+  end
+  def pure
+    self.gsub(/\u0001.*?\u0002/, '')
+  end
+  def splitx(x)
+    lines = self.split("\n")
+    until lines.all? { |line| line.pure.length <= x } do
+      lines.map! do |l| 
+        if l.pure.length > x and l[0..x].match(/ /)
+          @ix = l[0..x].rindex(" ")
+          [ l[0...@ix], l[(@ix + 1)..-1] ]
+        elsif l.pure.length > x
+          [l[0...x], l[x..-1]]
+        else
+          l
+        end
+      end
+      lines.flatten!
+    end
+    lines.reject { |e| e.to_s.empty? }
+  end
+end
+
+module Cursor # Terminal cursor movement ANSI codes (thanks to https://github.com/piotrmurach/tty-cursor)
+  module_function
+  ESC = "\e".freeze
+  CSI = "\e[".freeze
+  def save # Save current position
+    print(Gem.win_platform? ? CSI + 's' : ESC + '7')
+  end
+  def restore # Restore cursor position
+    print(Gem.win_platform? ? CSI + 'u' : ESC + '8')
+  end
+  def pos # Query cursor current position
+    res = ''
+    $stdin.raw do |stdin|
+      $stdout << CSI + '6n' # Tha actual ANSI get-position
+      $stdout.flush
+      while (c = stdin.getc) != 'R'
+        res << c if c
+      end
+    end
+    m = res.match /(?<row>\d+);(?<col>\d+)/
+    return m[:row].to_i, m[:col].to_i
+  end
+  def rowget
+    row, col = self.pos
+    return row
+  end
+  def colget
+    row, col = self.pos
+    return col
+  end
+  def up(n = 1) # Move cursor up by n
+    print(CSI + "#{(n || 1)}A")
+  end
+  def down(n = 1) # Move the cursor down by n
+    print(CSI + "#{(n || 1)}B")
+  end
+  def left(n = 1) # Move the cursor backward by n
+    print(CSI + "#{n || 1}D")
+  end
+  def right(n = 1) # Move the cursor forward by n
+    print(CSI + "#{n || 1}C")
+  end
+  def col(n = 1) # Cursor moves to nth position horizontally in the current line
+    print(CSI + "#{n || 1}G")
+  end
+  def row(n = 1) # Cursor moves to the nth position vertically in the current column
+    print(CSI + "#{n || 1}d")
+  end
+  def next_line # Move cursor down to beginning of next line
+    print(CSI + 'E' + CSI + "1G")
+  end
+  def prev_line # Move cursor up to beginning of previous line
+    print(CSI + 'A' +  CSI + "1G")
+  end
+  def clear_char(n = 1) # Erase n characters from the current cursor position
+    print(CSI + "#{n}X")
+  end
+  def clear_line # Erase the entire current line and return to beginning of the line
+    print(CSI + '2K' +  CSI + "1G")
+  end
+  def clear_line_before # Erase from the beginning of the line up to and including the current cursor position.
+    print(CSI + '1K')
+  end
+  def clear_line_after # Erase from the current position (inclusive) to the end of the line
+    print(CSI + '0K')
+  end
+  def scroll_up # Scroll display up one line
+    print(ESC + 'M')
+  end
+  def scroll_down # Scroll display down one line
+    print(ESC + 'D')
+  end
+  def clear_screen_down # Clear screen down from current row
+    print(CSI + 'J')
+  end
+end
+
+def getchr # Function to process key presses
+  c = $stdin.getch
+  case c
+  when "\e"    # ANSI escape sequences (with only ESC, it should stop right here)
+    return "ESC" if $stdin.ready? == nil
+    case $stdin.getc
+    when '['   # CSI
+      case $stdin.getc  # Will get (or ASK) for more (remaining part of special character)
+      when 'A' then chr = "UP"
+      when 'B' then chr = "DOWN"
+      when 'C' then chr = "RIGHT"
+      when 'D' then chr = "LEFT"
+      when 'Z' then chr = "S-TAB"
+      when '2' then chr = "INS"    ; chr = "C-INS"    if $stdin.getc == "^"
+      when '3' then chr = "DEL"    ; chr = "C-DEL"    if $stdin.getc == "^"
+      when '5' then chr = "PgUP"   ; chr = "C-PgUP"   if $stdin.getc == "^"
+      when '6' then chr = "PgDOWN" ; chr = "C-PgDOWN" if $stdin.getc == "^"
+      when '7' then chr = "HOME"   ; chr = "C-HOME"   if $stdin.getc == "^"
+      when '8' then chr = "END"    ; chr = "C-END"    if $stdin.getc == "^"
+      else chr = ""
+      end
+    when 'O'   # Set Ctrl+ArrowKey equal to ArrowKey; May be used for other purposes in the future
+      case $stdin.getc
+      when 'a' then chr = "C-UP"
+      when 'b' then chr = "C-DOWN"
+      when 'c' then chr = "C-RIGHT"
+      when 'd' then chr = "C-LEFT"
+      else chr = ""
+      end
+    end
+  when "", "" then chr = "BACK"
+  when "
" then chr = "C-A"
+  when "" then chr = "C-B"
+  when "" then chr = "C-C"
+  when "^D" then chr = "C-D"
+  when "" then chr = "C-E"
+  when "" then chr = "C-F"
+  when "^G" then chr = "C-G"
+  when "	" then chr = "C-I"
+  when "" then chr = "C-J"
+  when "" then chr = "C-K"
+  when "" then chr = "C-L"
+  when "
+  when "^N" then chr = "C-N"
+  when "^O" then chr = "C-O"
+  when "^P" then chr = "C-P"
+  when "" then chr = "C-Q"
+  when "" then chr = "C-R"
+  when "^T" then chr = "C-T"
+  when "" then chr = "C-U"
+  when "" then chr = "C-V"
+  when "" then chr = "C-X"
+  when "" then chr = "C-Y"
+  when "" then chr = "C-Z"
+  when "" then chr = "WBACK"
+  when "\r" then chr = "ENTER"
+  when "\t" then chr = "TAB"
+  when "" then chr = "C-S"
+  when /[[:print:]]/  then chr = c
+  else chr = ""
+  end
+  return chr
+end
+
+# vim: set sw=2 sts=2 et filetype=ruby fdm=syntax fdn=2 fcs=fold\:\ :

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: rcurses
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Geir Isene
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-11-16 00:00:00.000000000 Z
+dependencies: []
+description: Create panes (with the colors and(or border), manipulate the panes and
+  add content. Dress up text (in panes or anywhere in the terminal) in bold, italic,
+  underline, reverse color, blink and in any 256 terminal colors for foreground and
+  background. Use a simple editor to let users edit text in panes. Left, right or
+  center align text in panes. Cursor movement around the terminal.
+email: g@isene.com
+executables: []
+extensions:
+- extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- extconf.rb
+- lib/rcurses.rb
+homepage: https://isene.com/
+licenses:
+- Unlicense
+metadata:
+  source_code_uri: https://github.com/isene/rcurses
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: rcurses - An alternative curses library written in pure Ruby
+test_files: []