rcurses 2.0 → 2.1

data/lib/rcurses.rb

@@ -5,708 +5,14 @@
 # Web_site:   http://isene.com/
 # Github:     https://github.com/isene/rcurses
 # License:    Public domain
-# Version:    2.0: Complete code refactoring
+# Version:    2.1: New gem structure
 
 require 'io/console' # Basic gem for rcurses
 require 'io/wait'    # stdin handling
-begin
-  require 'clipboard'  # Ensure the 'clipboard' gem is installed
-rescue LoadError
-  # Define a fallback Clipboard module
-  module Clipboard
-    def self.copy(_text)
-      # Clipboard functionality is not available
-      puts "Clipboard functionality is not available. Please install the 'clipboard' gem to enable it."
-    end
-  end
-end
 
-class String
-  # Add coloring to strings (with escaping for Readline)
-  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
-  def color(text, sp, ep = "\e[0m"); "#{sp}#{text}#{ep}"; end
-
-  # Use format "TEST".c("204,45,bui") to print "TEST" in bold, underline italic, fg=204 and bg=45
-  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
-
-  def pure
-    self.gsub(/\e\[\d+(?:;\d+)*m/, '')
-  end
-end
-
-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 # Save current position
-      print(Gem.win_platform? ? CSI + 's' : ESC + '7')
-    end
-    def restore # Restore cursor position
-      print(Gem.win_platform? ? CSI + 'u' : ESC + '8')
-    end
-    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
-        end
-      end
-      m = res.match(/(?<row>\d+);(?<col>\d+)/)
-      return m[:row].to_i, m[:col].to_i
-    end
-    def rowget
-      row, _col = pos
-      row
-    end
-    def colget
-      _row, col = pos
-      col
-    end
-    def up(n = 1) # Move cursor up by n
-      print(CSI + "#{(n || 1)}A")
-    end
-    def down(n = 1) # Move the cursor down by n
-      print(CSI + "#{(n || 1)}B")
-    end
-    def left(n = 1) # Move the cursor backward by n
-      print(CSI + "#{n || 1}D")
-    end
-    def right(n = 1) # Move the cursor forward by n
-      print(CSI + "#{n || 1}C")
-    end
-    def col(n = 1) # Cursor moves to nth position horizontally in the current line
-      print(CSI + "#{n || 1}G")
-    end
-    def row(n = 1) # Cursor moves to the nth position vertically in the current column
-      print(CSI + "#{n || 1}d")
-    end
-    def next_line # Move cursor down to beginning of next line
-      print(CSI + 'E' + CSI + "1G")
-    end
-    def prev_line # Move cursor up to beginning of previous line
-      print(CSI + 'A' + CSI + "1G")
-    end
-    def clear_char(n = 1) # Erase n characters from the current cursor position
-      print(CSI + "#{n}X")
-    end
-    def clear_line # Erase the entire current line and return to beginning of the line
-      print(CSI + '2K' + CSI + "1G")
-    end
-    def clear_line_before # Erase from the beginning of the line up to and including the current cursor position.
-      print(CSI + '1K')
-    end
-    def clear_line_after # Erase from the current position (inclusive) to the end of the line
-      print(CSI + '0K')
-    end
-    def clear_screen_down # Clear screen down from current row
-      print(CSI + 'J')
-    end
-    def scroll_up # Scroll display up one line
-      print(ESC + 'M')
-    end
-    def scroll_down # Scroll display down one line
-      print(ESC + 'D')
-    end
-  end
-
-  module Rinput
-    def getchr
-      # Function to process key presses
-      c = $stdin.getch
-      case c
-      when "\e"    # ANSI escape sequences
-        return "ESC" if !$stdin.ready?
-        second_char = $stdin.getc
-        case second_char
-        when '['   # CSI
-          third_char = $stdin.getc
-          case third_char
-          when 'A' then chr = "UP"
-          when 'B' then chr = "DOWN"
-          when 'C' then chr = "RIGHT"
-          when 'D' then chr = "LEFT"
-          when 'Z' then chr = "S-TAB"
-          when '2'
-            fourth_char = $stdin.getc
-            chr = fourth_char == '~' ? "INS" : ""
-          when '3'
-            fourth_char = $stdin.getc
-            chr = fourth_char == '~' ? "DEL" : ""
-          when '5'
-            fourth_char = $stdin.getc
-            chr = fourth_char == '~' ? "PgUP" : ""
-          when '6'
-            fourth_char = $stdin.getc
-            chr = fourth_char == '~' ? "PgDOWN" : ""
-          when '1', '7'
-            fourth_char = $stdin.getc
-            chr = fourth_char == '~' ? "HOME" : ""
-          when '4', '8'
-            fourth_char = $stdin.getc
-            chr = fourth_char == '~' ? "END" : ""
-          else chr = ""
-          end
-        when 'O'   # Function keys
-          third_char = $stdin.getc
-          case third_char
-          when 'a' then chr = "C-UP"
-          when 'b' then chr = "C-DOWN"
-          when 'c' then chr = "C-RIGHT"
-          when 'd' then chr = "C-LEFT"
-          else chr = ""
-          end
-        else
-          chr = ""
-        end
-      when "\r" then chr = "ENTER"
-      when "\t" then chr = "TAB"
-      when "\u007F", "\b" then chr = "BACK"
-      when "\u0001" then chr = "C-A"
-      when "\u0002" then chr = "C-B"
-      when "\u0003" then chr = "C-C"
-      when "\u0004" then chr = "C-D"
-      when "\u0005" then chr = "C-E"
-      when "\u0006" then chr = "C-F"
-      when "\u0007" then chr = "C-G"
-      when "\u000B" then chr = "C-K"
-      when "\u000C" then chr = "C-L"
-      when "\u000D" then chr = "C-M"
-      when "\u000E" then chr = "C-N"
-      when "\u000F" then chr = "C-O"
-      when "\u0010" then chr = "C-P"
-      when "\u0011" then chr = "C-Q"
-      when "\u0012" then chr = "C-R"
-      when "\u0014" then chr = "C-T"
-      when "\u0015" then chr = "C-U"
-      when "\u0016" then chr = "C-V"
-      when "\u0018" then chr = "C-X"
-      when "\u0019" then chr = "C-Y"
-      when "\u001A" then chr = "C-Z"
-      when "\u0017" then chr = "WBACK"
-      when "\u0013" then chr = "C-S"
-      when /[[:print:]]/ then chr = c
-      else chr = ""
-      end
-      chr
-    end
-  end
-
-  class Pane
-    include Rcurses::Cursor
-    include Rcurses::Rinput
-    attr_accessor :startx, :starty, :width, :height, :fg, :bg
-    attr_accessor :x, :y, :w, :h
-    attr_accessor :border, :scroll, :text, :ix, :align, :prompt
-
-    def initialize(startx = 1, starty = 1, width = 1, height = 1, fg = nil, bg = nil)
-      # Using Procs or Lambdas instead of eval
-      @startx  = startx.is_a?(Proc) ? startx : -> { startx }
-      @starty  = starty.is_a?(Proc) ? starty : -> { starty }
-      @width   = width.is_a?(Proc)  ? width  : -> { width  }
-      @height  = height.is_a?(Proc) ? height : -> { height }
-      @fg, @bg = fg, bg
-      @text    = ""              # Initialize text variable
-      @align   = "l"             # Default alignment
-      @scroll  = true            # Initialize scroll indicators to true
-      @prompt  = ""              # Initialize prompt for editline
-      @ix      = 0               # Text index (starting text line in pane)
-      @max_h, @max_w = IO.console.winsize
-    end
-
-    def move(x, y)
-      @startx = -> { @x + x }
-      @starty = -> { @y + y }
-      refresh
-    end
-
-    def refresh(cont = @text)
-      @max_h, @max_w = IO.console.winsize
-
-      # Define the core of the ANSI escape sequence handling
-      def split_line_with_ansi(line, w)
-        # Define opening and closing sequences
-        open_sequences = {
-          "\e[1m" => "\e[22m",
-          "\e[3m" => "\e[23m",
-          "\e[4m" => "\e[24m",
-          "\e[5m" => "\e[25m",
-          "\e[7m" => "\e[27m" }
-        # All known closing sequences
-        close_sequences = open_sequences.values + ["\e[0m"]
-        # Regex to match ANSI escape sequences
-        ansi_regex = /\e\[[0-9;]*m/
-        result = []
-        # Tokenize the line into ANSI sequences and plain text
-        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)
-            # It's an ANSI sequence
-            current_line << token
-            if close_sequences.include?(token)
-              # It's a closing sequence
-              if token == "\e[0m"
-                # Reset all sequences
-                active_sequences.clear
-              else
-                # Remove the corresponding opening sequence
-                corresponding_open = open_sequences.key(token)
-                active_sequences.delete(corresponding_open)
-              end
-            else
-              # It's an opening sequence (or any other ANSI sequence)
-              active_sequences << token
-            end
-          else
-            # It's plain text, split into words and spaces
-            words = token.scan(/\S+\s*/)
-            words.each do |word|
-              word_length = word.gsub(ansi_regex, '').length
-              if current_line_length + word_length <= w
-                # Append word to current line
-                current_line << word
-                current_line_length += word_length
-              else
-                # Word doesn't fit in the current line
-                if current_line_length > 0
-                  # Finish the current line and start a new one
-                  result << current_line
-                  # Start new line with active ANSI sequences
-                  current_line = active_sequences.join
-                  current_line_length = 0
-                end
-                # Handle long words that might need splitting
-                while word_length > w
-                  # Split the word
-                  part = word[0, w]
-                  current_line << part
-                  result << current_line
-                  # Update word and lengths
-                  word = word[w..-1]
-                  word_length = word.gsub(ansi_regex, '').length
-                  # Start new line
-                  current_line = active_sequences.join
-                  current_line_length = 0
-                end
-                # Append any remaining part of the word
-                if word_length > 0
-                  current_line << word
-                  current_line_length += word_length
-                end
-              end
-            end
-          end
-        end
-        # Append any remaining text in the current line
-        result << current_line unless current_line.empty?
-        result
-      end
-
-      # Define the main textformat function
-      def textformat(cont)
-        # Split the content by '\n'
-        lines = cont.split("\n")
-        result = []
-        lines.each do |line|
-          split_lines = split_line_with_ansi(line, @w)
-          result.concat(split_lines)
-        end
-        result
-      end
-
-      # Start the actual refresh
-      o_row, o_col = pos
-      @x = @startx.call
-      @y = @starty.call
-      @w = @width.call
-      @h = @height.call
-
-      # Adjust pane dimensions and positions
-      if @border # Keep panes inside screen
-        @w = @max_w - 2 if @w > @max_w - 2
-        @h = @max_h - 2 if @h > @max_h - 2
-        @x = 2 if @x < 2; @x = @max_w - @w if @x + @w > @max_w
-        @y = 2 if @y < 2; @y = @max_h - @h if @y + @h > @max_h
-      else
-        @w = @max_w if @w > @max_w
-        @h = @max_h if @h > @max_h
-        @x = 1 if @x < 1; @x = @max_w - @w + 1 if @x + @w > @max_w + 1
-        @y = 1 if @y < 1; @y = @max_h - @h + 1 if @y + @h > @max_h + 1
-      end
-
-      col(@x); row(@y) # Cursor to start of pane
-      fmt = [@fg, @bg].compact.join(',') # Format for printing in pane (fg,bg)
-      @txt = cont.split("\n") # Split content into array
-      @txt = textformat(cont) if @txt.any? { |line| line.pure.length >= @w } # Reformat lines if necessary
-      @ix = @txt.length - 1 if @ix > @txt.length - 1; @ix = 0 if @ix < 0 # Ensure no out-of-bounds
-
-      @h.times do |i| # Print pane content
-        l = @ix + i # The current line to be printed
-        if @txt[l].to_s != "" # Print the text line
-          # Get padding width and half width
-          pl = @w - @txt[l].pure.length
-          pl = 0 if pl < 0
-          hl = pl / 2
-          case @align
-          when "l"
-            print @txt[l].c(fmt) + " ".c(fmt) * pl
-          when "r"
-            print " ".c(fmt) * pl + @txt[l].c(fmt)
-          when "c"
-            print " ".c(fmt) * hl + @txt[l].c(fmt) + " ".c(fmt) * (pl - hl)
-          end
-        else
-          print " ".c(fmt) * @w
-        end
-        col(@x) # Cursor to start of pane
-        row(@y + i + 1)
-      end
-
-      if @ix > 0 and @scroll # Print "more" marker at top
-        col(@x + @w - 1); row(@y)
-        print "▲".c(fmt)
-      end
-
-      if @txt.length - @ix > @h and @scroll # Print bottom "more" marker
-        col(@x + @w - 1); row(@y + @h - 1)
-        print "▼".c(fmt)
-      end
-
-      if @border # Print border if @border is set to true
-        row(@y - 1); col(@x - 1)
-        print ("┌" + "─" * @w + "┐").c(fmt)
-        @h.times do |i|
-          row(@y + i); col(@x - 1)
-          print "│".c(fmt)
-          col(@x + @w)
-          print "│".c(fmt)
-        end
-        row(@y + @h); col(@x - 1)
-        print ("└" + "─" * @w + "┘").c(fmt)
-      end
-
-      row(o_row)
-      col(o_col)
-      @txt
-    end
-
-    def textformat(cont)
-      # Split the content by '\n'
-      lines = cont.split("\n")
-      result = []
-      lines.each do |line|
-        split_lines = split_line_with_ansi(line, @w)
-        result.concat(split_lines)
-      end
-      result
-    end
-
-    def right
-      if @pos < @txt[@ix + @line].length
-        @pos += 1
-        if @pos == @w
-          @pos = 0
-          if @line == @h - 1
-            @ix += 1
-          else
-            @line += 1
-          end
-        end
-      else
-        if @line == @h - 1
-          @ix += 1 unless @ix >= @txt.length - @h
-          @pos = 0
-        elsif @line + @ix + 1 < @txt.length
-          @line += 1
-          @pos = 0
-        end
-      end
-    end
-    def left
-      if @pos == 0
-        if @line == 0
-          unless @ix == 0
-            @ix -= 1
-            @pos = @txt[@ix + @line].length
-          end
-        else
-          @line -= 1
-          @pos = @txt[@ix + @line].length
-        end
-      else
-        @pos -= 1
-      end
-    end
-    def up
-      if @line == 0
-        @ix -= 1 unless @ix == 0
-      else
-        @line -= 1
-      end
-      begin
-        @pos = [@pos, @txt[@ix + @line].length].min
-      rescue
-      end
-    end
-    def down
-      if @line == @h - 1
-        @ix += 1 unless @ix + @line >= @txt.length - 1
-      elsif @line + @ix + 1 < @txt.length
-        @line += 1
-      end
-      begin
-        @pos = [@pos, @txt[@ix + @line].length].min
-      rescue
-      end
-    end
-
-    def parse(cont)
-      cont.gsub!(/\*(.+?)\*/,           '\1'.b)
-      cont.gsub!(/\/(.+?)\//,           '\1'.i)
-      cont.gsub!(/_(.+?)_/,             '\1'.u)
-      cont.gsub!(/#(.+?)#/,             '\1'.r)
-      cont.gsub!(/<([^|]+)\|([^>]+)>/) do
-        text = $2; codes = $1
-        text.c(codes)
-      end
-      cont
-    end
-
-    def edit
-      begin
-        # Switch to raw mode without echoing input
-        STDIN.raw!
-        # Prepare content for editing, replacing newlines with a placeholder
-        content = @text.pure.gsub("\n", "¬\n")
-        # Initialize cursor position and indices
-        @ix        = 0   # Starting index of text lines displayed in the pane
-        @line      = 0   # Current line number relative to the pane's visible area
-        @pos       = 0   # Position within the current line (character index)
-        @txt       = refresh(content)
-        input_char = ''
-
-        while input_char != 'ESC'  # Continue until ESC is pressed
-          row(@y + @line)          # Move cursor to the correct row
-          col(@x + @pos)           # Move cursor to the correct column
-
-          input_char = getchr      # Read user input
-          case input_char
-          when 'C-L'    # Left justify
-            @align = 'l'
-          when 'C-R'    # Right justify
-            @align = 'r'
-          when 'C-C'    # Center justify
-            @align = 'c'
-          when 'C-Y'    # Copy pane content to clipboard
-            Clipboard.copy(@text.pure)
-          when 'C-S'    # Save edited text back to @text and exit
-            content = content.gsub('¬', "\n")
-            content = parse(content)
-            @text = content
-            input_char = 'ESC'
-          when 'DEL'    # Delete character at current position
-            posx = calculate_posx
-            content.slice!(posx)
-          when 'BACK'   # Backspace (delete character before current position)
-            if @pos > 0
-              left
-              posx = calculate_posx
-              content.slice!(posx)
-            end
-          when 'WBACK'  # Word backspace
-            while @pos > 0 && content[calculate_posx - 1] != ' '
-              left
-              posx = calculate_posx
-              content.slice!(posx)
-            end
-          when 'C-K'    # Kill line (delete from cursor to end of line)
-            line_start_pos = calculate_line_start_pos
-            line_length = @txt[@ix + @line]&.length || 0
-            content.slice!(line_start_pos + @pos, line_length - @pos)
-          when 'UP'     # Move cursor up one line
-            up
-          when 'DOWN'   # Move cursor down one line
-            down
-          when 'RIGHT'  # Move cursor right one character
-            right
-          when 'LEFT'   # Move cursor left one character
-            left
-          when 'HOME'   # Move to start of line
-            @pos = 0
-          when 'END'    # Move to end of line
-            current_line_length = @txt[@ix + @line]&.length || 0
-            @pos = current_line_length
-          when 'C-HOME' # Move to start of pane
-            @ix = 0
-            @line = 0
-            @pos = 0
-          when 'C-END'  # Move to end of pane
-            total_lines = @txt.length
-            @ix = [total_lines - @h, 0].max
-            @line = [@h - 1, total_lines - @ix - 1].min
-            current_line_length = @txt[@ix + @line]&.length || 0
-            @pos = current_line_length
-          when 'ENTER'  # Insert newline at current position
-            posx = calculate_posx
-            content.insert(posx, "¬\n")
-            right
-          when /^.$/    # Insert character at current position
-            posx = calculate_posx
-            content.insert(posx, input_char)
-            right
-          else
-            # Handle unrecognized input if necessary
-          end
-
-          # Handle pasted input (additional characters in the buffer)
-          while IO.select([$stdin], nil, nil, 0)
-            input_char = $stdin.read_nonblock(1) rescue nil
-            break unless input_char
-            posx = calculate_posx
-            content.insert(posx, input_char)
-            right
-          end
-
-          @txt = refresh(content)  # Refresh the pane with the current content
-        end
-      ensure
-        # Restore terminal mode
-        STDIN.cooked!
-      end
-    end
-
-    def editline
-      begin
-        # Switch to raw mode without echo
-        STDIN.raw!
-
-        # Initialize position and dimensions
-        @x = @startx.call
-        @y = @starty.call
-        @w = @width.call
-        @h = @height.call
-        # Ensure pane is within screen bounds
-        @x = [[@x, 1].max, @max_w - @w + 1].min
-        @y = [[@y, 1].max, @max_h - @h + 1].min
-
-        @scroll = false
-        row(@y)
-
-        fmt = [@fg, @bg].compact.join(',')
-        col(@x)
-        print @prompt.c(fmt)  # Print prompt at the pane's starting position
-
-        prompt_len = @prompt.pure.length
-        content_len = @w - prompt_len
-        cont = @text.pure.slice(0, content_len)
-        @pos = cont.length  # Set initial cursor position at the end of content
-        chr = ''
-
-        while chr != 'ESC'  # Continue until ESC is pressed
-          col(@x + prompt_len)  # Set cursor at start of content
-          cont = cont.slice(0, content_len)  # Trim content to max length
-          print cont.ljust(content_len).c(fmt)  # Print content, left-justified
-          col(@x + prompt_len + @pos)  # Set cursor to current position
-
-          chr = getchr  # Read user input
-          case chr
-          when 'LEFT'
-            @pos -= 1 if @pos > 0
-          when 'RIGHT'
-            @pos += 1 if @pos < cont.length
-          when 'HOME'
-            @pos = 0
-          when 'END'
-            @pos = cont.length
-          when 'DEL'
-            cont[@pos] = '' if @pos < cont.length
-          when 'BACK'
-            if @pos > 0
-              @pos -= 1
-              cont[@pos] = ''
-            end
-          when 'WBACK'
-            while @pos > 0 && cont[@pos - 1] != ' '
-              @pos -= 1
-              cont[@pos] = ''
-            end
-          when 'C-K'
-            cont = ''
-            @pos = 0
-          when 'ENTER'
-            @text = parse(cont)
-            chr = 'ESC'
-          when /^.$/
-            if @pos < content_len
-              cont.insert(@pos, chr)
-              @pos += 1
-            end
-          end
-
-          # Handle pasted input
-          while IO.select([$stdin], nil, nil, 0)
-            chr = $stdin.read_nonblock(1) rescue nil
-            break unless chr
-            if @pos < content_len
-              cont.insert(@pos, chr)
-              @pos += 1
-            end
-          end
-        end
-      ensure
-        # Restore terminal mode
-        STDIN.cooked!
-      end
-    end
-
-    private
-
-    # Calculates the position in the content string corresponding to the current cursor position
-    def calculate_posx
-      total_length = 0
-      (@ix + @line).times do |i|
-        total_length += @txt[i].pure.length + 1  # +1 for the newline character
-      end
-      total_length += @pos
-      total_length
-    end
-    # Calculates the starting position of the current line in the content string
-    def calculate_line_start_pos
-      total_length = 0
-      (@ix + @line).times do |i|
-        total_length += @txt[i].pure.length + 1  # +1 for the newline character
-      end
-      total_length
-    end
-  end
-end
+require_relative 'string_extensions'
+require_relative 'rcurses/cursor'
+require_relative 'rcurses/input'
+require_relative 'rcurses/pane'
 
 # vim: set sw=2 sts=2 et filetype=ruby fdm=syntax fdn=2 fcs=fold\:\ :