rcurses 4.8.3 → 4.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6368e4d70cf29ddd6652b9112bdff1ca4912c436e6a731fb40f8f2e088f9f11a
-  data.tar.gz: 05cb89f361374c80212eea238028e071e898060de1e3432f1a3a72cc5ded1821
+  metadata.gz: 998bc4ac36e7e3b51fc910a59bf1ffdf933870a8975ef205b572d4f3c1fe377a
+  data.tar.gz: 7bd9a0993fda8a06545969b7a4bea36f80e782e7dcefd477d11389f6764c0dff
 SHA512:
-  metadata.gz: c774f36556d7fe4abfd514a8c04ba1cb56b6e19cc0a00e1d460c24c2490ca1a005b58db330f03a1a3db9cf9d8994fe76a37f61369ee74b3a2ba70a8ca54c6c9f
-  data.tar.gz: 5f202003dd8e302b4c03b72fcf3366573d7f336418d8b4eec5516d83c88c6c44fb8e82b8c0f9267afb0deb3c843de2a74d7faac2f63139de6c509eb2bf77eb2f
+  metadata.gz: 99f1957fafce2eaaa495c7fa9230e5724643ec82e3f772420846ce1ead3d461d0682dc9df57066bc24286f32f63861a631e370d00a8ff805bac033e6ad81a94d
+  data.tar.gz: b4a41c371b9e8555b4f8f76fb6a45c5b50a43a7ada8e992aba9340f22ba6f84ee48513fce45294291eb0396b86b8540cc10eda37a9bd93aeb3fff1e3e79141cf

data/lib/rcurses/cursor.rb

@@ -8,15 +8,20 @@ module Rcurses
     def restore; print(Gem.win_platform? ? CSI + 'u' : ESC + '8'); end # Restore cursor position
     def pos # Query cursor current position
       res = ''
-      $stdin.raw do |stdin|
-        $stdout << CSI + '6n' # The actual ANSI get-position
-        $stdout.flush
-        while (c = stdin.getc) != 'R'
-          res << c if c
+      begin
+        $stdin.raw do |stdin|
+          $stdout << CSI + '6n' # The 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
+      rescue Errno::EIO, Errno::ENOTTY, IOError
+        # Return safe defaults if terminal state is compromised
+        return 1, 1
       end
-      m = res.match(/(?<row>\d+);(?<col>\d+)/)
-      return m[:row].to_i, m[:col].to_i
     end
     def rowget
       row, _col = pos

data/lib/rcurses/input.rb

@@ -7,6 +7,9 @@ module Rcurses
           c = t ? Timeout.timeout(t) { $stdin.getch } : $stdin.getch
         rescue Timeout::Error
           return nil
+        rescue Errno::EIO, Errno::ENOTTY, IOError => e
+          # Handle terminal focus loss or disconnection gracefully
+          return "ESC"
         end
 
         # 2) If it's ESC, grab any quick trailing bytes
@@ -15,7 +18,8 @@ module Rcurses
           if IO.select([$stdin], nil, nil, 0.05)
             begin
               seq << $stdin.read_nonblock(16)
-            rescue IO::WaitReadable, EOFError
+            rescue IO::WaitReadable, EOFError, Errno::EIO, Errno::ENOTTY
+              # Handle various terminal state errors gracefully
             end
           end
         end
@@ -115,7 +119,8 @@ module Rcurses
           while IO.select([$stdin], nil, nil, 0)
             begin
               $stdin.read_nonblock(4096)
-            rescue IO::WaitReadable, EOFError
+            rescue IO::WaitReadable, EOFError, Errno::EIO, Errno::ENOTTY
+              # Handle terminal state errors during flush
               break
             end
           end

data/lib/rcurses/pane.rb

@@ -1,25 +1,68 @@
 module Rcurses
-  # A simple display_width function that approximates how many columns a string occupies.
-  # This is a simplified version that may need adjustments for full Unicode support.
+  # Enhanced display_width function with better Unicode support
   def self.display_width(str)
     width = 0
     str.each_char do |char|
       cp = char.ord
+      
+      # Handle NUL and control characters
       if cp == 0
         # NUL – no width
+        next
       elsif cp < 32 || (cp >= 0x7F && cp < 0xA0)
         # Control characters: no width
-        width += 0
-      # Approximate common wide ranges:
-      elsif (cp >= 0x1100 && cp <= 0x115F) ||
-            cp == 0x2329 || cp == 0x232A ||
-            (cp >= 0x2E80 && cp <= 0xA4CF) ||
-            (cp >= 0xAC00 && cp <= 0xD7A3) ||
-            (cp >= 0xF900 && cp <= 0xFAFF) ||
-            (cp >= 0xFE10 && cp <= 0xFE19) ||
-            (cp >= 0xFE30 && cp <= 0xFE6F) ||
-            (cp >= 0xFF00 && cp <= 0xFF60) ||
-            (cp >= 0xFFE0 && cp <= 0xFFE6)
+        next
+      end
+      
+      # Handle combining characters (zero width)
+      if (cp >= 0x0300 && cp <= 0x036F) ||  # Combining Diacritical Marks
+         (cp >= 0x1AB0 && cp <= 0x1AFF) ||  # Combining Diacritical Marks Extended
+         (cp >= 0x1DC0 && cp <= 0x1DFF) ||  # Combining Diacritical Marks Supplement
+         (cp >= 0x20D0 && cp <= 0x20FF) ||  # Combining Diacritical Marks for Symbols
+         (cp >= 0xFE20 && cp <= 0xFE2F)     # Combining Half Marks
+        next
+      end
+      
+      # Handle wide characters (East Asian width)
+      if (cp >= 0x1100 && cp <= 0x115F) ||    # Hangul Jamo
+         (cp >= 0x2329 && cp <= 0x232A) ||    # Left/Right-Pointing Angle Bracket
+         (cp >= 0x2E80 && cp <= 0x2EFF) ||    # CJK Radicals Supplement
+         (cp >= 0x2F00 && cp <= 0x2FDF) ||    # Kangxi Radicals
+         (cp >= 0x2FF0 && cp <= 0x2FFF) ||    # Ideographic Description Characters
+         (cp >= 0x3000 && cp <= 0x303E) ||    # CJK Symbols and Punctuation
+         (cp >= 0x3041 && cp <= 0x3096) ||    # Hiragana
+         (cp >= 0x30A1 && cp <= 0x30FA) ||    # Katakana
+         (cp >= 0x3105 && cp <= 0x312D) ||    # Bopomofo
+         (cp >= 0x3131 && cp <= 0x318E) ||    # Hangul Compatibility Jamo
+         (cp >= 0x3190 && cp <= 0x31BA) ||    # Kanbun
+         (cp >= 0x31C0 && cp <= 0x31E3) ||    # CJK Strokes
+         (cp >= 0x31F0 && cp <= 0x31FF) ||    # Katakana Phonetic Extensions
+         (cp >= 0x3200 && cp <= 0x32FF) ||    # Enclosed CJK Letters and Months
+         (cp >= 0x3300 && cp <= 0x33FF) ||    # CJK Compatibility
+         (cp >= 0x3400 && cp <= 0x4DBF) ||    # CJK Unified Ideographs Extension A
+         (cp >= 0x4E00 && cp <= 0x9FFF) ||    # CJK Unified Ideographs
+         (cp >= 0xA960 && cp <= 0xA97F) ||    # Hangul Jamo Extended-A
+         (cp >= 0xAC00 && cp <= 0xD7A3) ||    # Hangul Syllables
+         (cp >= 0xD7B0 && cp <= 0xD7FF) ||    # Hangul Jamo Extended-B
+         (cp >= 0xF900 && cp <= 0xFAFF) ||    # CJK Compatibility Ideographs
+         (cp >= 0xFE10 && cp <= 0xFE19) ||    # Vertical Forms
+         (cp >= 0xFE30 && cp <= 0xFE6F) ||    # CJK Compatibility Forms
+         (cp >= 0xFF00 && cp <= 0xFF60) ||    # Fullwidth Forms
+         (cp >= 0xFFE0 && cp <= 0xFFE6) ||    # Fullwidth Forms
+         (cp >= 0x1F000 && cp <= 0x1F02F) ||  # Mahjong Tiles
+         (cp >= 0x1F030 && cp <= 0x1F09F) ||  # Domino Tiles
+         (cp >= 0x1F100 && cp <= 0x1F1FF) ||  # Enclosed Alphanumeric Supplement
+         (cp >= 0x1F200 && cp <= 0x1F2FF) ||  # Enclosed Ideographic Supplement
+         (cp >= 0x1F300 && cp <= 0x1F5FF) ||  # Miscellaneous Symbols and Pictographs
+         (cp >= 0x1F600 && cp <= 0x1F64F) ||  # Emoticons
+         (cp >= 0x1F650 && cp <= 0x1F67F) ||  # Ornamental Dingbats
+         (cp >= 0x1F680 && cp <= 0x1F6FF) ||  # Transport and Map Symbols
+         (cp >= 0x1F700 && cp <= 0x1F77F) ||  # Alchemical Symbols
+         (cp >= 0x1F780 && cp <= 0x1F7FF) ||  # Geometric Shapes Extended
+         (cp >= 0x1F800 && cp <= 0x1F8FF) ||  # Supplemental Arrows-C
+         (cp >= 0x1F900 && cp <= 0x1F9FF) ||  # Supplemental Symbols and Pictographs
+         (cp >= 0x20000 && cp <= 0x2FFFF) ||  # CJK Unified Ideographs Extension B-F
+         (cp >= 0x30000 && cp <= 0x3FFFF)     # CJK Unified Ideographs Extension G
         width += 2
       else
         width += 1
@@ -32,13 +75,19 @@ module Rcurses
     require 'clipboard'  # Ensure the 'clipboard' gem is installed
     include Cursor
     include Input
+    
+    # Compiled regex patterns for performance
+    ANSI_REGEX = /\e\[[0-9;]*m/.freeze
+    SGR_REGEX = /\e\[\d+(?:;\d+)*m/.freeze
     attr_accessor :x, :y, :w, :h, :fg, :bg
     attr_accessor :border, :scroll, :text, :ix, :index, :align, :prompt
     attr_accessor :moreup, :moredown
     attr_accessor :record, :history
+    attr_accessor :updates_suspended
 
     def initialize(x = 1, y = 1, w = 1, h = 1, fg = nil, bg = nil)
-      @max_h, @max_w = IO.console.winsize
+      @terminal_size_cache = nil
+      @terminal_size_time = nil
       @x          = x
       @y          = y
       @w          = w
@@ -54,6 +103,8 @@ module Rcurses
       @pos        = 0      # For cursor tracking during editing:
       @record     = false  # Don't record history unless explicitly set to true
       @history    = []     # History array
+      @updates_suspended = false
+      @lazy_cache_limit = 1000  # Limit for lazy text cache
     end
 
     def text=(new_text)
@@ -82,6 +133,24 @@ module Rcurses
       full_refresh 
     end
 
+    def suspend_updates
+      @updates_suspended = true
+    end
+
+    def resume_updates
+      @updates_suspended = false
+      refresh
+    end
+
+    def get_terminal_size
+      now = Time.now
+      if @terminal_size_cache.nil? || @terminal_size_time.nil? || (now - @terminal_size_time) > 0.5
+        @terminal_size_cache = IO.console.winsize
+        @terminal_size_time = now
+      end
+      @terminal_size_cache
+    end
+
     def move(dx, dy)
       @x += dx
       @y += dy
@@ -90,7 +159,8 @@ module Rcurses
 
     def linedown
       @ix += 1
-      @ix = @text.split("\n").length if @ix > @text.split("\n").length - 1
+      text_lines = @text.split("\n")
+      @ix = text_lines.length if @ix > text_lines.length - 1
       refresh
     end
 
@@ -102,7 +172,8 @@ module Rcurses
 
     def pagedown
       @ix = @ix + @h - 1
-      @ix = @text.split("\n").length - @h if @ix > @text.split("\n").length - @h
+      text_lines = @text.split("\n")
+      @ix = text_lines.length - @h if @ix > text_lines.length - @h
       refresh
     end
 
@@ -113,7 +184,8 @@ module Rcurses
     end
 
     def bottom
-      @ix = @text.split("\n").length - @h
+      text_lines = @text.split("\n")
+      @ix = text_lines.length - @h
       refresh
     end
 
@@ -160,7 +232,15 @@ module Rcurses
     # Diff-based refresh that minimizes flicker.
     # In this updated version we lazily process only the raw lines required to fill the pane.
     def refresh(cont = @text)
-      @max_h, @max_w = IO.console.winsize
+      return if @updates_suspended
+      
+      # Check if we're in batch mode and suspend updates accordingly
+      if Rcurses.batch_mode?
+        Rcurses.add_to_batch(self)
+        return
+      end
+      
+      @max_h, @max_w = get_terminal_size
 
       if @border
         @w = @max_w - 2 if @w > @max_w - 2
@@ -184,11 +264,17 @@ module Rcurses
 
       # Lazy evaluation: If the content or pane width has changed, reinitialize the lazy cache.
       if !defined?(@cached_text) || @cached_text != cont || @cached_w != @w
-        @raw_txt   = cont.split("\n").map { |line| line.chomp("\r") }
+        @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.dup
         @cached_w = @w
+        
+        # Clear cache if it gets too large to prevent memory leaks
+        if @lazy_txt.size > @lazy_cache_limit
+          @lazy_txt.clear
+          @lazy_index = 0
+        end
       end
 
       content_rows = @h
@@ -221,11 +307,11 @@ module Rcurses
           hl = pl / 2
           case @align
           when "l"
-            line_str = @txt[l].c(fmt) + " ".c(fmt) * pl
+            line_str = @txt[l].pure.c(fmt) + " ".c(fmt) * pl
           when "r"
-            line_str = " ".c(fmt) * pl + @txt[l].c(fmt)
+            line_str = " ".c(fmt) * pl + @txt[l].pure.c(fmt)
           when "c"
-            line_str = " ".c(fmt) * hl + @txt[l].c(fmt) + " ".c(fmt) * (pl - hl)
+            line_str = " ".c(fmt) * hl + @txt[l].pure.c(fmt) + " ".c(fmt) * (pl - hl)
           end
         else
           line_str = " ".c(fmt) * @w
@@ -605,14 +691,13 @@ module Rcurses
         "\e[7m" => "\e[27m"
       }
       close_sequences = open_sequences.values + ["\e[0m"]
-      ansi_regex = /\e\[[0-9;]*m/
       result = []
       tokens = line.scan(/(\e\[[0-9;]*m|[^\e]+)/).flatten.compact
       current_line = ''
       current_line_length = 0
       active_sequences = []
       tokens.each do |token|
-        if token.match?(ansi_regex)
+        if token.match?(ANSI_REGEX)
           current_line << token
           if close_sequences.include?(token)
             if token == "\e[0m"
@@ -627,7 +712,7 @@ module Rcurses
         else
           words = token.scan(/\s+|\S+/)
           words.each do |word|
-            word_length = Rcurses.display_width(word.gsub(ansi_regex, ''))
+            word_length = Rcurses.display_width(word.gsub(ANSI_REGEX, ''))
             if current_line_length + word_length <= w
               current_line << word
               current_line_length += word_length
@@ -638,11 +723,12 @@ module Rcurses
                 current_line_length = 0
               end
               while word_length > w
-                part = word[0, w]
+                # Split safely respecting UTF-8 boundaries and display width
+                part = safe_substring_by_width(word, w)
                 current_line << part
                 result << current_line
-                word = word[w..-1]
-                word_length = Rcurses.display_width(word.gsub(ansi_regex, ''))
+                word = word[part.length..-1]
+                word_length = Rcurses.display_width(word.gsub(ANSI_REGEX, ''))
                 current_line = active_sequences.join
                 current_line_length = 0
               end
@@ -657,6 +743,23 @@ module Rcurses
       result << current_line unless current_line.empty?
       result
     end
+
+    # Helper method to safely split strings by display width while respecting UTF-8 boundaries
+    def safe_substring_by_width(str, max_width)
+      return str if Rcurses.display_width(str) <= max_width
+      
+      result = ''
+      current_width = 0
+      
+      str.each_char do |char|
+        char_width = Rcurses.display_width(char)
+        break if current_width + char_width > max_width
+        result += char
+        current_width += char_width
+      end
+      
+      result
+    end
   end
 end
 

data/lib/rcurses.rb

@@ -5,7 +5,7 @@
 # Web_site:   http://isene.com/
 # Github:     https://github.com/isene/rcurses
 # License:    Public domain
-# Version:    4.8.3: Bugfix: Text carriege return corner case fix
+# Version:    4.9.0: Major performance improvements - memory leak fixes, terminal dimension caching, batch updates, better Unicode support, enhanced error handling
 
 require 'io/console' # Basic gem for rcurses
 require 'io/wait'    # stdin handling
@@ -52,6 +52,51 @@ module Rcurses
 
       @cleaned_up = true
     end
+
+    # Public: Batch multiple pane updates to prevent flickering
+    def batch_updates
+      @batched_panes = []
+      yield
+      @batched_panes.each(&:resume_updates)
+      @batched_panes = nil
+    end
+
+    # Internal: Track panes that need updating in batch mode
+    def add_to_batch(pane)
+      if @batched_panes
+        pane.suspend_updates unless @batched_panes.include?(pane)
+        @batched_panes << pane unless @batched_panes.include?(pane)
+      end
+    end
+
+    # Public: Check if we're in batch mode
+    def batch_mode?
+      !@batched_panes.nil?
+    end
+
+    # Content caching system for improved performance
+    def self.cache_get(key)
+      @content_cache ||= {}
+      @content_cache[key]
+    end
+
+    def self.cache_set(key, value)
+      @content_cache ||= {}
+      @content_cache_limit ||= 100
+      
+      # Simple LRU eviction when cache gets too large
+      if @content_cache.size >= @content_cache_limit
+        # Remove oldest entries (simplified LRU)
+        keys_to_remove = @content_cache.keys.first(@content_cache.size - @content_cache_limit + 10)
+        keys_to_remove.each { |k| @content_cache.delete(k) }
+      end
+      
+      @content_cache[key] = value
+    end
+
+    def self.cache_clear
+      @content_cache = {}
+    end
   end
 
   # Kick off initialization as soon as the library is required.

data/lib/string_extensions.rb

@@ -1,6 +1,9 @@
 # string_extensions.rb
 
 class String
+  # Compiled regex patterns for performance
+  ANSI_SGR_REGEX = /\e\[\d+(?:;\d+)*m/.freeze
+  ANSI_SEQUENCE_REGEX = /\e\[\d+(?:;\d+)*m/.freeze
   # 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/
@@ -93,12 +96,20 @@ class String
 
   # Strip all ANSI SGR sequences
   def pure
-    gsub(/\e\[\d+(?:;\d+)*m/, '')
+    gsub(ANSI_SGR_REGEX, '')
   end
 
   # Remove stray leading/trailing reset if the string has no other styling
   def clean_ansi
-    gsub(/\A(?:\e\[0m)+/, '').gsub(/\e\[0m\z/, '')
+    # If we have opening ANSI codes without proper closing, just use pure
+    # to avoid unbalanced sequences that can corrupt terminal display
+    temp = gsub(/\A(?:\e\[0m)+/, '').gsub(/\e\[0m\z/, '')
+    # Check if we have unbalanced ANSI sequences (opening codes without closing)
+    if temp =~ /\e\[[\d;]+m/ && temp !~ /\e\[0m\z/
+      pure
+    else
+      temp
+    end
   end
 
   # Truncate the *visible* length to n, but preserve embedded ANSI
@@ -108,7 +119,7 @@ class String
     i     = 0
 
     while i < length && count < n
-      if self[i] == "\e" && (m = self[i..-1].match(/\A(\e\[\d+(?:;\d+)*m)/))
+      if self[i] == "\e" && (m = self[i..-1].match(/\A(#{ANSI_SEQUENCE_REGEX.source})/))
         out << m[1]
         i   += m[1].length
       else
@@ -131,7 +142,7 @@ class String
     count, out, i, injected = 0, '', 0, false
 
     while i < length
-      if self[i] == "\e" && (m = self[i..-1].match(/\A(\e\[\d+(?:;\d+)*m)/))
+      if self[i] == "\e" && (m = self[i..-1].match(/\A(#{ANSI_SEQUENCE_REGEX.source})/))
         out << m[1]
         i   += m[1].length
       else
@@ -146,7 +157,7 @@ class String
     end
 
     unless injected
-      if out =~ /(\e\[\d+(?:;\d+)*m)\z/
+      if out =~ /(#{ANSI_SEQUENCE_REGEX.source})\z/
         trailing = $1
         out      = out[0...-trailing.length] + insertion + trailing
       else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rcurses
 version: !ruby/object:Gem::Version
-  version: 4.8.3
+  version: 4.9.0
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-17 00:00:00.000000000 Z
+date: 2025-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clipboard
@@ -29,9 +29,9 @@ 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. New in 3.8: Fixed border fragments
-  upon utf-8 characters. 4.8: Bugfix: Removed stray ansi codes. 4.8.3: Bugfix: Text
-  carriege return corner case fix.'
+  in panes. Cursor movement around the terminal. 4.9.0: Major performance improvements
+  - memory leak fixes, terminal dimension caching, batch updates, better Unicode support,
+  enhanced error handling.'
 email: g@isene.com
 executables: []
 extensions: []