rcurses 4.0 → 4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64fede93e0d646b947c3cf6c3217a1aa7bf62f923b724a4dd55b02e3981b8593
-  data.tar.gz: 3dca4a698dbbc31356e50e322d3e52ba2c0d6a574b7b824e6d6fe7d5d5b49dd2
+  metadata.gz: 494b705528b9bb3e5040c9ecf8c1ff31c7cf0db13e04736140f35298d49b48b0
+  data.tar.gz: 6f74dc4880397c55461c6ff0f5a6371edec67edfdfb3eb3d65d7dafdc5ac6295
 SHA512:
-  metadata.gz: e866db8fa1db394653b90a88c73632d024b7b565db7f984360004b6d4bb4b83c56650e2784669bf827f32585dbbbb9918f98016d5a6612ee39ff352e194b7f84
-  data.tar.gz: 67ceadf4ccb04fb5708e0faa33253099156cddedd9fe906d5d24a11d9ccfeac836a945ff7990f19df380f64061a986836a6432206e5f7a8cd09cb6f9e112e81b
+  metadata.gz: 0cbed1ef8307fd124d035dce74501d58f648668884ae50190d82460d33b3825557ccd1f07b4c0a64d7b69c81a0c1ef240cf1828adc769e96ffd9bfb47d3e7f08
+  data.tar.gz: 0f7747ce65c0f8103759b8df5e64bceee0bf7593d137380a08b6002ec6cbaeb3540236f9ebc65b1f28f293ed009b76565fe4e0fd63cdcb2bf597dd32430107cc

data/README.md

@@ -10,6 +10,9 @@ Here's a somewhat simple example of a TUI program using rcurses: The [T-REX](htt
 
 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.
 
@@ -83,6 +86,7 @@ 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
@@ -97,12 +101,14 @@ 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:
+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(196)`)
+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`)

data/lib/rcurses.rb

@@ -5,7 +5,7 @@
 # Web_site:   http://isene.com/
 # Github:     https://github.com/isene/rcurses
 # License:    Public domain
-# Version:    4.0: Added border_refresh to refresh only the border of a pane
+# Version:    4.5: Full RGB support in addition to 256-colors
 
 require 'io/console' # Basic gem for rcurses
 require 'io/wait'    # stdin handling

data/lib/string_extensions.rb

@@ -1,124 +1,160 @@
+# string_extensions.rb
+
 class String
-  # Existing methods...
-  def fg(fg)    ; color(self, "\e[38;5;#{fg}m", "\e[0m")  ; end
-  def bg(bg)    ; color(self, "\e[48;5;#{bg}m", "\e[0m")  ; end
-  def fb(fg, bg); color(self, "\e[38;5;#{fg};48;5;#{bg}m"); end
-  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 function
+  # 256-color or truecolor RGB foreground
+  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[0m"]
+             else
+               ["\e[38;5;#{color}m", "\e[0m"]
+             end
+    color(self, sp, ep)
+  end
+
+  # 256-color or truecolor RGB background
+  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[0m"]
+             else
+               ["\e[48;5;#{color}m", "\e[0m"]
+             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[0m")
+  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")
-    # Replace every newline with a newline followed by the start sequence,
-    # so that formatting is reestablished on each new line.
-    text = text.gsub("\n", "#{ep}\n#{sp}")
-    "#{sp}#{text}#{ep}"
+    t = text.gsub("\n", "#{ep}\n#{sp}")
+    "#{sp}#{t}#{ep}"
   end
 
-  # Use format "TEST".c("204,45,bui") to print "TEST" in bold, underline, italic, fg=204 and bg=45
+  # 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)
-    prop = "\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.include?('b')
-    prop += "3;" if code.include?('i')
-    prop += "4;" if code.include?('u')
-    prop += "5;" if code.include?('l')
-    prop += "7;" if code.include?('r')
-    prop.chop! if prop[-1] == ";"
-    prop += "m"
-    prop += self
-    prop += "\e[0m"
-    prop
-  end
+    parts = code.split(',')
+    seq   = []
 
-  def clean_ansi
-    dup
-      # 1) kill any “\e[0m” that follows another ANSI‐code (so “\e[7m\e[0mtest” → “\e[7mtest”)
-      .gsub(/\e\[[\d;]+m\e\[0m/, '\0'.sub("\e[0m", ''))
-      # 2) kill any “\e[0m” that immediately precedes non‐ESC output (so stray resets just before text)
-      .gsub(/\e\[0m(?=[^\e])/, '')
-      # 3) kill leading or trailing reset codes
-      .gsub(/\A\e\[0m/, '')
-      .gsub(/\e\[0m\z/, '')
+    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
-    self.gsub(/\e\[\d+(?:;\d+)*m/, '')
+    gsub(/\e\[\d+(?:;\d+)*m/, '')
   end
 
-  # Shortens the visible (pure) text to n characters, preserving any ANSI sequences.
+  # 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
-    result = ""
-    i = 0
-    while i < self.length && count < n
-      if self[i] == "\e" # start of an ANSI escape sequence
-        if m = self[i..-1].match(/\A(\e\[\d+(?:;\d+)*m)/)
-          result << m[1]
-          i += m[1].length
-        else
-          # Fallback if pattern doesn’t match: treat as a normal character.
-          result << self[i]
-          i += 1
-          count += 1
-        end
+    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
-        result << self[i]
+        out << self[i]
+        i   += 1
         count += 1
-        i += 1
       end
     end
-    result
+
+    out
   end
 
-  # Inserts the given substring at the provided visible character position.
-  # A negative position means insertion at the end.
-  # When inserting at the end and the string ends with an ANSI escape sequence,
-  # the insertion is placed before that trailing ANSI sequence.
+  # Insert +insertion+ at visible position +pos+ (negative → end),
+  # respecting and re-inserting existing ANSI sequences.
   def inject(insertion, pos)
-    pure_text = self.pure
-    visible_length = pure_text.length
-    pos = visible_length if pos < 0
+    pure_txt      = pure
+    visible_len   = pure_txt.length
+    pos           = visible_len if pos < 0
 
-    count = 0
-    result = ""
-    i = 0
-    injected = false
-
-    while i < self.length
-      if self[i] == "\e"  # Start of an ANSI sequence.
-        if m = self[i..-1].match(/\A(\e\[\d+(?:;\d+)*m)/)
-          result << m[1]
-          i += m[1].length
-        else
-          result << self[i]
-          i += 1
-        end
+    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
-          result << insertion
+          out << insertion
           injected = true
         end
-        result << self[i]
-        count += 1
-        i += 1
+        out << self[i]
+        count  += 1
+        i      += 1
       end
     end
 
-    # If we haven't injected (i.e. pos equals visible_length),
-    # check for a trailing ANSI sequence and insert before it.
     unless injected
-      if result =~ /(\e\[\d+(?:;\d+)*m)\z/
+      if out =~ /(\e\[\d+(?:;\d+)*m)\z/
         trailing = $1
-        result = result[0...-trailing.length] + insertion + trailing
+        out      = out[0...-trailing.length] + insertion + trailing
       else
-        result << insertion
+        out << insertion
       end
     end
 
-    result
+    out
   end
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rcurses
 version: !ruby/object:Gem::Version
-  version: '4.0'
+  version: '4.5'
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-02 00:00:00.000000000 Z
+date: 2025-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clipboard
@@ -30,8 +30,7 @@ description: 'Create curses applications for the terminal easier than ever. Crea
   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. New in 3.8: Fixed border fragments
-  upon utf-8 characters. 4.0: Added border_refresh to refresh only the border of a
-  pane.'
+  upon utf-8 characters. 4.5: Full RGB support in addition to 256-colors.'
 email: g@isene.com
 executables: []
 extensions: []