rcurses 4.9.0 → 4.9.1

data/lib/rcurses.rb

@@ -1,106 +0,0 @@
-# INFORMATION
-# Name:       rcurses - Ruby CURSES
-# Language:   Pure Ruby
-# Author:     Geir Isene <g@isene.com>
-# Web_site:   http://isene.com/
-# Github:     https://github.com/isene/rcurses
-# License:    Public domain
-# 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
-require 'timeout'
-
-require_relative 'string_extensions'
-require_relative 'rcurses/general'
-require_relative 'rcurses/cursor'
-require_relative 'rcurses/input'
-require_relative 'rcurses/pane'
-
-module Rcurses
-  class << self
-    # Public: Initialize Rcurses. Switches terminal into raw/no-echo
-    # and registers cleanup handlers. Idempotent.
-    def init!
-      return if @initialized
-      return unless $stdin.tty?
-
-      # enter raw mode, disable echo
-      $stdin.raw!
-      $stdin.echo = false
-
-      # ensure cleanup on normal exit
-      at_exit { cleanup! }
-
-      # ensure cleanup on signals
-      %w[INT TERM].each do |sig|
-        trap(sig) { cleanup!; exit }
-      end
-
-      @initialized = true
-    end
-
-    # Public: Restore terminal to normal mode, clear screen, show cursor.
-    # Idempotent: subsequent calls do nothing.
-    def cleanup!
-      return if @cleaned_up
-
-      $stdin.cooked!
-      $stdin.echo = true
-      Rcurses.clear_screen
-      Cursor.show
-
-      @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.
-  init!
-end
-
-# vim: set sw=2 sts=2 et filetype=ruby fdn=2 fcs=fold\:\ :

data/lib/string_extensions.rb

@@ -1,171 +0,0 @@
-# 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/
-      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(ANSI_SGR_REGEX, '')
-  end
-
-  # Remove stray leading/trailing reset if the string has no other styling
-  def clean_ansi
-    # 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
-  def shorten(n)
-    count = 0
-    out   = ''
-    i     = 0
-
-    while i < length && count < n
-      if self[i] == "\e" && (m = self[i..-1].match(/\A(#{ANSI_SEQUENCE_REGEX.source})/))
-        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(#{ANSI_SEQUENCE_REGEX.source})/))
-        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 =~ /(#{ANSI_SEQUENCE_REGEX.source})\z/
-        trailing = $1
-        out      = out[0...-trailing.length] + insertion + trailing
-      else
-        out << insertion
-      end
-    end
-
-    out
-  end
-end
-