rcurses 4.9.0 → 4.9.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcurses
 version: !ruby/object:Gem::Version
-  version: 4.9.0
+  version: 4.9.1
 platform: ruby
 authors:
 - Geir Isene
@@ -29,9 +29,8 @@ 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.0: Major performance improvements
-  - memory leak fixes, terminal dimension caching, batch updates, better Unicode support,
-  enhanced error handling.'
+  in panes. Cursor movement around the terminal. 4.9.1: Critical fix - preserve existing
+  ANSI codes in Pane text rendering.'
 email: g@isene.com
 executables: []
 extensions: []
@@ -39,14 +38,6 @@ 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
 homepage: https://isene.com/
 licenses:
 - Unlicense

data/examples/basic_panes.rb

@@ -1,43 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rcurses'
-
-@max_h, @max_w = IO.console.winsize
-
-# Start by creating the panes; Format:
-# pane      = Rcurses::Pane.new(      startx, starty,        width,     height,  fg,  bg)
-pane_top    = Rcurses::Pane.new(           1,      1,       @max_w,          1, 255, 236)
-pane_bottom = Rcurses::Pane.new(           1, @max_h,       @max_w,          1, 236, 254)
-pane_left   = Rcurses::Pane.new(           2,      3, @max_w/2 - 2, @max_h - 4,  52, nil)
-pane_right  = Rcurses::Pane.new(@max_w/2 + 1,      2,     @max_w/2, @max_h - 2, 255,  52)
-
-pane_left.border     = true # Adding a border to the left pane
-
-# Add content to the panes
-pane_top.text        = Time.now.to_s[0..15].b + "   Welcome to the rcurses example program"
-pane_left.text       = `ls --color`
-pane_right.text      = "Output of free:\n\n" + `free`
-pane_bottom.prompt   = "Enter any text and press ENTER: ".b # The prompt text before the user starts writing content
-
-pane_top.refresh     # This is the order of drawing/refreshing the panes
-pane_left.refresh    # ...then the left pane
-pane_right.refresh   # ...and the right pane
-pane_bottom.editline # Do not use a refresh before editline
-
-# Then create a "pop-up" pane in the middle of the screen
-pane_mid             = Rcurses::Pane.new(@max_w/2 - 10, @max_h/2 - 5, 20, 10, 18,  254)
-pane_mid.border      = true
-pane_mid.text        = "You wrote:" + "\n" + pane_bottom.text.i
-pane_mid.align       = "c"
-pane_mid.refresh
-
-# Then ask the user to hit ENTER before exiting the program
-pane_bottom.prompt   = "Now hit ENTER again "
-pane_bottom.text     = ""
-pane_bottom.editline
-
-# Reset terminal
-$stdin.cooked!
-$stdin.echo = true
-Rcurses::clear_screen
-Rcurses::Cursor.show

data/examples/focus_panes.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rcurses'
-include Rcurses::Input
-include Rcurses::Cursor
-
-@max_h, @max_w = IO.console.winsize
-@pane    = []
-@focused = 3 # Start with pane 3 so that the first keypress focuses back to Pane 0
-Rcurses::Cursor.hide
-
-# Start by creating the panes; Format:
-# pane    = Rcurses::Pane.new( startx, starty,  width, height,  fg,  bg)
-pane_back = Rcurses::Pane.new(      1,      1, @max_w, @max_h, nil, 236)
-@pane[0]  = Rcurses::Pane.new(      4,      4,     20,     10, 236, 254)
-@pane[1]  = Rcurses::Pane.new(     30,     10,     16,     12, 232, 132)
-@pane[2]  = Rcurses::Pane.new(      8,     20,     30,     20, 136,  54)
-@pane[3]  = Rcurses::Pane.new(     50,     30,     24,     10, 206,  24)
-
-pane_back.text = "PRESS ANY KEY TO SHIFT FOCUS. PRESS 'ESC' TO QUIT."
-@pane.each_index { |i| @pane[i].text = "This is pane " + i.to_s }
-pane_back.full_refresh
-@pane.each_index { |i| @pane[i].refresh }
-
-input = ''
-while input != 'ESC'
-  input = getchr
-  pane_back.full_refresh
-  @focused += 1
-  @focused  = 0 if @focused == @pane.size
-  @pane.each_index {|i| @pane[i].border = false}
-  @pane.each_index {|i| @pane[i].full_refresh}
-  @pane[@focused].border = true
-  @pane[@focused].full_refresh
-end
-
-# Always end an application with these lines:
-$stdin.cooked!
-$stdin.echo = true
-Rcurses.clear_screen
-Rcurses::Cursor.show
-

data/lib/rcurses/cursor.rb

@@ -1,53 +0,0 @@
-module Rcurses
-  module Cursor
-    # Terminal cursor movement ANSI codes (inspired by https://github.com/piotrmurach/tty-cursor)
-    module_function
-    ESC = "\e".freeze
-    CSI = "\e[".freeze
-    def save;    print(Gem.win_platform? ? CSI + 's' : ESC + '7'); end # Save current position
-    def restore; print(Gem.win_platform? ? CSI + 'u' : ESC + '8'); end # Restore cursor position
-    def pos # Query cursor current position
-      res = ''
-      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
-    end
-    def rowget
-      row, _col = pos
-      row
-    end
-    def colget
-      _row, col = pos
-      col
-    end
-    def set(r = 1, c = 1); print(CSI + "#{r}d"); print(CSI + "#{c}G");  end # Set cursor position to Row, Col (y,x)
-    def up(n = 1);         print(CSI + "#{(n)}A");                      end # Move cursor up by n
-    def down(n = 1);       print(CSI + "#{(n)}B");                      end # Move the cursor down by n
-    def left(n = 1);       print(CSI + "#{n}D");                        end # Move the cursor backward by n
-    def right(n = 1);      print(CSI + "#{n}C");                        end # Move the cursor forward by n
-    def col(c = 1);        print(CSI + "#{c}G");                        end # Cursor moves to nth position horizontally in the current line
-    def row(r = 1);        print(CSI + "#{r}d");                        end # Cursor moves to the nth position vertically in the current column
-    def next_line;         print(CSI + 'E' + CSI + "1G");               end # Move cursor down to beginning of next line
-    def prev_line;         print(CSI + 'A' + CSI + "1G");               end # Move cursor up to beginning of previous line
-    def clear_char(n = 1); print(CSI + "#{n}X");                        end # Erase n characters from the current cursor position
-    def clear_line;        print(CSI + '2K' + CSI + "1G");              end # Erase the entire current line and return to beginning of the line
-    def clear_line_before; print(CSI + '1K');                           end # Erase from the beginning of the line up to and including the current cursor position.
-    def clear_line_after;  print(CSI + '0K');                           end # Erase from the current position (inclusive) to the end of the line
-    def clear_screen_down; print(CSI + 'J');                            end # Clear screen down from current row
-    def scroll_up;         print(ESC + 'M');                            end # Scroll display up one line
-    def scroll_down;       print(ESC + 'D');                            end # Scroll display down one line
-    def hide;              print(CSI + '?25l');                         end # Scroll display down one line
-    def show;              print(CSI + '?25h');                         end # Scroll display down one line
-  end
-end

data/lib/rcurses/general.rb

@@ -1,6 +0,0 @@
-module Rcurses
-  def self.clear_screen
-    # ANSI code \e[2J clears the screen, and \e[H moves the cursor to the top left.
-    print "\e[2J\e[H"
-  end
-end

data/lib/rcurses/input.rb

@@ -1,132 +0,0 @@
-module Rcurses
-  module Input
-    def getchr(t = nil, flush: true)
-      begin
-        # 1) Read a byte (with optional timeout)
-        begin
-          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
-        seq = c
-        if c == "\e"
-          if IO.select([$stdin], nil, nil, 0.05)
-            begin
-              seq << $stdin.read_nonblock(16)
-            rescue IO::WaitReadable, EOFError, Errno::EIO, Errno::ENOTTY
-              # Handle various terminal state errors gracefully
-            end
-          end
-        end
-
-        # 3) Single ESC alone
-        return "ESC" if seq == "\e"
-
-        # 4) Shift‑TAB
-        return "S-TAB" if seq == "\e[Z"
-
-        # 5) Legacy single‑char shift‑arrows (your old working ones)
-        case seq
-        when "\e[a" then return "S-UP"
-        when "\e[b" then return "S-DOWN"
-        when "\e[c" then return "S-RIGHT"
-        when "\e[d" then return "S-LEFT"
-        end
-
-        # 6) CSI style shift‑arrows (e.g. ESC [1;2A )
-        if m = seq.match(/\A\e\[\d+;2([ABCD])\z/)
-          return { 'A' => "S-UP", 'B' => "S-DOWN", 'C' => "S-RIGHT", 'D' => "S-LEFT" }[m[1]]
-        end
-
-        # 7) Plain arrows
-        if m = seq.match(/\A\e\[([ABCD])\z/)
-          return { 'A' => "UP", 'B' => "DOWN", 'C' => "RIGHT", 'D' => "LEFT" }[m[1]]
-        end
-
-        # 8) CSI + '~' sequences (Ins, Del, Home, End, PgUp, PgDn, F5-F12)
-        if seq.start_with?("\e[") && seq.end_with?("~")
-          num = seq[/\d+(?=~)/].to_i
-          return case num
-                when 1, 7   then "HOME"
-                when 2       then "INS"
-                when 3       then "DEL"
-                when 4, 8    then "END"
-                when 5       then "PgUP"
-                when 6       then "PgDOWN"
-                when 15      then "F5"
-                when 17      then "F6"
-                when 18      then "F7"
-                when 19      then "F8"
-                when 20      then "F9"
-                when 21      then "F10"
-                when 23      then "F11"
-                when 24      then "F12"
-                else ""
-                end
-        end
-
-        # 9) SS3 function keys F1-F4
-        if seq.start_with?("\eO") && seq.length == 3
-          return case seq[2]
-                when 'P' then "F1"
-                when 'Q' then "F2"
-                when 'R' then "F3"
-                when 'S' then "F4"
-                else ""
-                end
-        end
-
-        # 10) Single / Ctrl-char mappings
-        return case seq
-              when "\r", "\n"     then "ENTER"
-              when "\t"           then "TAB"
-              when "\u007F", "\b" then "BACK"
-              when "\u0000"       then "C-SPACE"
-              when "\u0001"       then "C-A"
-              when "\u0002"       then "C-B"
-              when "\u0003"       then "C-C"
-              when "\u0004"       then "C-D"
-              when "\u0005"       then "C-E"
-              when "\u0006"       then "C-F"
-              when "\u0007"       then "C-G"
-              when "\u0008"       then "C-H"
-              when "\u000B"       then "C-K"
-              when "\u000C"       then "C-L"
-              when "\u000D"       then "C-M"
-              when "\u000E"       then "C-N"
-              when "\u000F"       then "C-O"
-              when "\u0010"       then "C-P"
-              when "\u0011"       then "C-Q"
-              when "\u0012"       then "C-R"
-              when "\u0013"       then "C-S"
-              when "\u0014"       then "C-T"
-              when "\u0015"       then "C-U"
-              when "\u0016"       then "C-V"
-              when "\u0018"       then "C-X"
-              when "\u0019"       then "C-Y"
-              when "\u001A"       then "C-Z"
-              when "\u0017"       then "WBACK"
-              when /\A[[:print:]]\z/ then seq
-              else ""
-              end
-      ensure
-        if flush
-          while IO.select([$stdin], nil, nil, 0)
-            begin
-              $stdin.read_nonblock(4096)
-            rescue IO::WaitReadable, EOFError, Errno::EIO, Errno::ENOTTY
-              # Handle terminal state errors during flush
-              break
-            end
-          end
-        end
-      end
-    end
-  end
-end
-