rcurses 4.9.3 → 4.9.5

data/lib/string_extensions.rb

@@ -0,0 +1,160 @@
+# string_extensions.rb
+
+class String
+  # 256-color or truecolor RGB foregroundb
reset only the fg (SGR 39)
+  def fg(color)
+    sp, ep = if color.to_s =~ /\A[0-9A-Fa-f]{6}\z/
+      r, g, b = color.scan(/../).map { |c| c.to_i(16) }
+      ["\e[38;2;#{r};#{g};#{b}m", "\e[39m"]
+    else
+      ["\e[38;5;#{color}m", "\e[39m"]
+    end
+    color(self, sp, ep)
+  end
+
+  # 256-color or truecolor RGB backgroundb
reset only the bg (SGR 49)
+  def bg(color)
+    sp, ep = if color.to_s =~ /\A[0-9A-Fa-f]{6}\z/
+      r, g, b = color.scan(/../).map { |c| c.to_i(16) }
+      ["\e[48;2;#{r};#{g};#{b}m", "\e[49m"]
+    else
+      ["\e[48;5;#{color}m", "\e[49m"]
+    end
+    color(self, sp, ep)
+  end
+
+  # Both fg and bg in one go
+  def fb(fg_color, bg_color)
+    parts = []
+    if fg_color.to_s =~ /\A[0-9A-Fa-f]{6}\z/
+      r, g, b = fg_color.scan(/../).map { |c| c.to_i(16) }
+      parts << "38;2;#{r};#{g};#{b}"
+    else
+      parts << "38;5;#{fg_color}"
+    end
+
+    if bg_color.to_s =~ /\A[0-9A-Fa-f]{6}\z/
+      r, g, b = bg_color.scan(/../).map { |c| c.to_i(16) }
+      parts << "48;2;#{r};#{g};#{b}"
+    else
+      parts << "48;5;#{bg_color}"
+    end
+
+    sp = "\e[#{parts.join(';')}m"
+    color(self, sp, "\e[39;49m")
+  end
+
+  # bold, italic, underline, blink, reverse
+  def b; color(self, "\e[1m",   "\e[22m"); end
+  def i; color(self, "\e[3m",   "\e[23m"); end
+  def u; color(self, "\e[4m",   "\e[24m"); end
+  def l; color(self, "\e[5m",   "\e[25m"); end
+  def r; color(self, "\e[7m",   "\e[27m"); end
+
+  # Internal helper - wraps +text+ in start/end sequences,
+  # and re-applies start on every newline.
+  def color(text, sp, ep = "\e[0m")
+    t = text.gsub("\n", "#{ep}\n#{sp}")
+    "#{sp}#{t}#{ep}"
+  end
+
+  # Combined code:  "foo".c("FF0000,00FF00,bui")
+  # — 6-hex or decimal for fg, then for bg, then letters b/i/u/l/r
+  def c(code)
+    parts = code.split(',')
+    seq   = []
+
+    fg = parts.shift
+    if fg =~ /\A[0-9A-Fa-f]{6}\z/
+      r,g,b = fg.scan(/../).map{|c|c.to_i(16)}
+      seq << "38;2;#{r};#{g};#{b}"
+    elsif fg =~ /\A\d+\z/
+      seq << "38;5;#{fg}"
+    end
+
+    if parts.any?
+      bg = parts.shift
+      if bg =~ /\A[0-9A-Fa-f]{6}\z/
+        r,g,b = bg.scan(/../).map{|c|c.to_i(16)}
+        seq << "48;2;#{r};#{g};#{b}"
+      elsif bg =~ /\A\d+\z/
+        seq << "48;5;#{bg}"
+      end
+    end
+
+    seq << '1' if code.include?('b')
+    seq << '3' if code.include?('i')
+    seq << '4' if code.include?('u')
+    seq << '5' if code.include?('l')
+    seq << '7' if code.include?('r')
+
+    "\e[#{seq.join(';')}m#{self}\e[0m"
+  end
+
+  # Strip all ANSI SGR sequences
+  def pure
+    gsub(/\e\[\d+(?:;\d+)*m/, '')
+  end
+
+  # Remove stray leading/trailing reset if the string has no other styling
+  def clean_ansi
+    gsub(/\A(?:\e\[0m)+/, '').gsub(/\e\[0m\z/, '')
+  end
+
+  # Truncate the *visible* length to n, but preserve embedded ANSI
+  def shorten(n)
+    count = 0
+    out   = ''
+    i     = 0
+
+    while i < length && count < n
+      if self[i] == "\e" && (m = self[i..-1].match(/\A(\e\[\d+(?:;\d+)*m)/))
+        out << m[1]
+        i   += m[1].length
+      else
+        out << self[i]
+        i   += 1
+        count += 1
+      end
+    end
+
+    out
+  end
+
+  # Insert +insertion+ at visible position +pos+ (negative → end),
+  # respecting and re-inserting existing ANSI sequences.
+  def inject(insertion, pos)
+    pure_txt      = pure
+    visible_len   = pure_txt.length
+    pos           = visible_len if pos < 0
+
+    count, out, i, injected = 0, '', 0, false
+
+    while i < length
+      if self[i] == "\e" && (m = self[i..-1].match(/\A(\e\[\d+(?:;\d+)*m)/))
+        out << m[1]
+        i   += m[1].length
+      else
+        if count == pos && !injected
+          out << insertion
+          injected = true
+        end
+        out << self[i]
+        count  += 1
+        i      += 1
+      end
+    end
+
+    unless injected
+      if out =~ /(\e\[\d+(?:;\d+)*m)\z/
+        trailing = $1
+        out      = out[0...-trailing.length] + insertion + trailing
+      else
+        out << insertion
+      end
+    end
+
+    out
+  end
+end
+

data/rcurses-README.md

@@ -0,0 +1,257 @@
+# rcurses - An alternative curses library written in pure Ruby
+ 
+![Ruby](https://img.shields.io/badge/language-Ruby-red) [![Gem Version](https://badge.fury.io/rb/rcurses.svg)](https://badge.fury.io/rb/rcurses) ![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">
+
+Create curses applications for the terminal easier than ever.
+
+Here's a somewhat simple example of a TUI program using rcurses: The [T-REX](https://github.com/isene/T-REX) calculator.
+
+And here's a much more involved example: The [RTFM](https://github.com/isene/RTFM) terminal file manager.
+
+# NOTE: Version 4.5 gives full RGB support in addition to 256-colors
+Just write a color as a string - e.g. `"d533e0"` for a hexadecimal RGB color (or use the terminal 256 colors by supplying an integer in the range 0-255)
+
+# 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 and with minimum of external dependencies.
+
+# Installation
+Simply run `gem install rcurses`.
+
+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 module `Rinput` providing the 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 = Rcurses::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:
+```
+Rcurses::Pane.new(x, y, w, h, fg, bg)
+```
+You can drop the last two 256-color codes to create a pane with the defaults for your terminal. 
+
+By adding values for the terminal size in your program:
+```
+@max_h, @max_w = IO.console.winsize
+```
+...you can use these values to create proportinally sized panes. So, a hight value of "@max_h/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 `@max_h` for terminal height and `@max_w` for terminal width.
+
+Avaliable properties/variables:
+
+Property       | Description
+---------------|---------------------------------------------------------------
+x              | The x (column) position of the Pane
+y              | The y (row) position of the Pane
+w              | The width of the Pane
+h              | The heigth of 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             | The line number at the top of the Pane, starts at 0, the first line of text in the Pane
+index          | An attribute that can be used to track the selected line/element 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
+moreup         | Set to true when there is more text above what is shown (top scroll bar i showing)
+moredown       | Set to true when there is more text below what is shown (bottom scroll bar i showing)
+
+The methods for Pane:
+
+Method         | Description
+---------------|---------------------------------------------------------------
+new/init       | Initializes a Pane with optional arguments `x, y, w, h, fg and bg`
+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
+border_refresh | Refresh the Pane border only
+full_refresh   | Refreshes/redraws the Pane with content completely (without diff rendering)
+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
+clear          | Clears the pane
+say(text)      | Short form for setting panel.text, then doing a refresh of that panel
+ask(prompt,text) | Short form of setting panel.prompt, then panel.text, doing a panel.editline and then returning panel.text
+pagedown       | Scroll down one page height in the text (minus one line), but not longer than the length of the text
+pageup         | Scroll up one page height in the text (minus one line)
+linedown       | Scroll down one line in the text
+lineup         | Scroll up one line in the text
+bottom         | Scroll to the bottom of the text in the pane
+top            | Scroll to the top of the text in the pane
+
+# class String extensions
+Method extensions provided for the class String.
+
+A color can either be an integer in the range 0-255 for the usual 256 colors in a terminal, or it can be a string representing RGB. So both of these are valid: `string.fg(219)` and `string.fg("4d22a0")`.
+
+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("dd32a9")`)
+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)
+clean_ansi     | Strip seemingly uncolored strings of ansi code (those that are enclosed in "\e[0m"
+shorten(n)     | Shorten the pure version of the string to 'n' characters, preserving any ANSI coding
+inject("chars",pos) | Inject "chars" at position 'pos' in the pure version of the string (if 'pos' is '-1', then append at end). Preserves any ANSI code
+
+PS: Blink does not work in conjunction with setting a background color in urxvt. It does work in gnome-terminal. But the overall performance in urxvt as orders of magnitude better than gnome-terminal.
+
+# Cleaning up upon exit
+End a program with `Rcurses.clear_screen` to clear the screen for any rcurses residues.
+
+# module Cursor
+To use this module, first do `include Rcurses::Cursor`. Create a new cursor object with `mycursor = Rcurses::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`)         
+set(c = 1, r = 1) | Set the position of the cursor to row/y,col/x (example: `mycursor.set(row,col)`) (default = top row, first column)
+col(c = 1)        | Cursor moves to the nth position horizontally in the current line (default = first column)
+row(r = 1)        | Cursor moves to the nth position vertically in the current column (default = first/top row)
+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)
+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
+hide              | Hide the cursor
+show              | Show cursor
+
+# The 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.
+The function getchr is automatically included in your arsenal when you first do `include Rcurses::Input`.
+
+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"
+`shift-up`      | "S-UP"
+`ctrl-up`       | "C-UP"
+`down`          | "DOWN"
+`shift-down`    | "S-DOWN"
+`ctrl-down`     | "C-DOWN"
+`right`         | "RIGHT"
+`shift-right`   | "S-RIGHT"
+`ctrl-right`    | "C-RIGHT"
+`left`          | "LEFT"
+`shifth-left`   | "S-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- `        | "C-SPACE"
+`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"
+`F1` - `F12`    | "F1" - "F12"
+
+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
+```
+You can also pass a timeout to `getchr` with `getchr(time)` to wait for `time` number of seconds and returning `nil` if the user does not press a key.
+
+
+# Example
+
+Try this in `irb`:
+```
+require 'rcurses'
+@max_h, @max_w = IO.console.winsize
+mypane = Pane.new(@max_w/2, 30, 30, 10, 19, 229)
+mypane.border = true
+mypane.text = "Hello".i + " World!".b.i + "\n \n" + "rcurses".r + " " + "is cool".c("16,212")
+mypane.refresh
+mypane.edit
+```
+... and then try to add some bold text by enclosing it in '*' and italics by enclosing text in '/'. Then press 'ctrl-s' to save your edited text - and then type `mypane.refresh` to see the result.
+
+And - try running the example file `rcurses_example.rb`.
+
+# 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.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcurses
 version: !ruby/object:Gem::Version
-  version: 4.9.3
+  version: 4.9.5
 platform: ruby
 authors:
 - Geir Isene
@@ -29,15 +29,23 @@ description: 'Create curses applications for the terminal easier than ever. Crea
   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. 4.9.3: Reverted to stable 4.8.3 codebase
-  after 4.9.0-4.9.2 color issues.'
+  in panes. Cursor movement around the terminal. 4.9.5: Emergency fix - properly built
+  gem with color handling restored.'
 email: g@isene.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
-- README.md
+- examples/basic_panes.rb
+- examples/focus_panes.rb
+- lib/rcurses.rb
+- lib/rcurses/cursor.rb
+- lib/rcurses/general.rb
+- lib/rcurses/input.rb
+- lib/rcurses/pane.rb
+- lib/string_extensions.rb
+- rcurses-README.md
 homepage: https://isene.com/
 licenses:
 - Unlicense