rcurses 4.0 → 4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64fede93e0d646b947c3cf6c3217a1aa7bf62f923b724a4dd55b02e3981b8593
-  data.tar.gz: 3dca4a698dbbc31356e50e322d3e52ba2c0d6a574b7b824e6d6fe7d5d5b49dd2
+  metadata.gz: 240aec267dd4c5e8377ffba6844848463a8d4a0c5291f159f354e9c600e6a264
+  data.tar.gz: 3d3534900f41903901758496d0ed0494c400c6ca45dfbd9eb3265b1b924fd108
 SHA512:
-  metadata.gz: e866db8fa1db394653b90a88c73632d024b7b565db7f984360004b6d4bb4b83c56650e2784669bf827f32585dbbbb9918f98016d5a6612ee39ff352e194b7f84
-  data.tar.gz: 67ceadf4ccb04fb5708e0faa33253099156cddedd9fe906d5d24a11d9ccfeac836a945ff7990f19df380f64061a986836a6432206e5f7a8cd09cb6f9e112e81b
+  metadata.gz: 92a3f431d49eb85bd4c2a25429acfe87acb2cb1a553c4ebad78614f3e34c3f9bcd23037b725b72a117404fa22397a8d5e8a6ba0d1b6193b227c126bcb4f87e80
+  data.tar.gz: 07e0d869aa2025be468a98d359ef2f1894751b301c5ec37965fe75b6bb97bec452b01bcd67c6ddb3fa6a08fe7f7289d85082eaf0153ac6b487d70d417759e1eb

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/pane.rb

@@ -186,7 +186,7 @@ module Rcurses
         @raw_txt   = cont.split("\n")
         @lazy_txt  = []   # This will hold the processed (wrapped) lines as needed.
         @lazy_index = 0   # Pointer to the next raw line to process.
-        @cached_text = cont
+        @cached_text = cont.dup
         @cached_w = @w
       end
 
@@ -365,15 +365,19 @@ module Rcurses
       begin
         STDIN.cooked!  rescue nil
         STDIN.echo = true rescue nil
-        Rcurses::Cursor.show
+        # Prepare content with visible newline markers
         content = @text.pure.gsub("\n", "¬\n")
-        @ix    = 0
-        @line  = 0
-        @pos   = 0
-        @txt   = refresh(content)
+        # Reset editing cursor state
+        @ix = 0
+        @line = 0
+        @pos = 0
+        # Initial render sets @txt internally for display and cursor math
+        refresh(content)
+        Rcurses::Cursor.show
         input_char = ''
 
         while input_char != 'ESC'
+          # Move the terminal cursor to the logical text cursor
           row(@y + @line)
           col(@x + @pos)
           input_char = getchr(flush: false)
@@ -424,9 +428,7 @@ module Rcurses
             current_line_length = @txt[@ix + @line]&.length || 0
             @pos = current_line_length
           when 'C-HOME'
-            @ix = 0
-            @line = 0
-            @pos = 0
+            @ix = 0; @line = 0; @pos = 0
           when 'C-END'
             total_lines = @txt.length
             @ix = [total_lines - @h, 0].max
@@ -443,6 +445,7 @@ module Rcurses
             right
           end
 
+          # Handle any buffered input
           while IO.select([$stdin], nil, nil, 0)
             input_char = $stdin.read_nonblock(1) rescue nil
             break unless input_char
@@ -451,7 +454,9 @@ module Rcurses
             right
           end
 
-          @txt = refresh(content)
+          # Re-render without overwriting the internal @txt
+          refresh(content)
+          Rcurses::Cursor.show
         end
       ensure
         STDIN.raw!         rescue nil  

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 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")
-    # 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
+
+  # Remove stray leading/trailing reset if the string has no other styling
+  def clean_ansi
+    gsub(/\A(?:\e\[0m)+/, '').gsub(/\e\[0m\z/, '')
   end
 
-  # Shortens the visible (pure) text to n characters, preserving any ANSI sequences.
+  # 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.6'
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-02 00:00:00.000000000 Z
+date: 2025-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clipboard
@@ -30,8 +30,8 @@ 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.6: Fixed a broken pane.edit. Fixed ANSI termination bug
+  in RGB support.'
 email: g@isene.com
 executables: []
 extensions: []