tty2-reader 0.9.0.1

data/lib/tty2/reader/line.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module TTY2
+  class Reader
+    class Line
+      ANSI_MATCHER = /(\[)?\033(\[)?[;?\d]*[\dA-Za-z](\])?/
+
+      # The word break characters list used by shell
+      DEFAULT_WORD_BREAK_CHARACTERS = " \t\n\"\\'`@$><=|&{("
+
+      # Strip ANSI characters from the text
+      #
+      # @param [String] text
+      #
+      # @return [String]
+      #
+      # @api public
+      def self.sanitize(text)
+        text.dup.gsub(ANSI_MATCHER, "")
+      end
+
+      # The editable text
+      # @api public
+      attr_reader :text
+
+      # The current cursor position witin the text
+      # @api public
+      attr_reader :cursor
+
+      # The line mode
+      # @api public
+      attr_reader :mode
+
+      # The prompt displayed before input
+      # @api public
+      attr_reader :prompt
+
+      # The prompt size
+      # @api public
+      attr_reader :prompt_size
+
+      # The word separator pattern for splitting the text
+      #
+      # @return [Regexp]
+      #
+      # @api public
+      attr_reader :separator
+
+      # Create a Line instance
+      #
+      # @api private
+      def initialize(text = "", prompt: "", separator: nil)
+        @text   = text.dup
+        @prompt = prompt.dup
+        @prompt_size = prompt_display_width
+        break_chars = DEFAULT_WORD_BREAK_CHARACTERS.chars
+        @separator = separator || Regexp.union(break_chars)
+        @cursor = [0, @text.length].max
+        @mode   = :edit
+
+        yield self if block_given?
+      end
+
+      # Prompt display width
+      #
+      # @return [Integer]
+      #   the prompt size
+      #
+      # @api public
+      def prompt_display_width
+        lines = self.class.sanitize(@prompt).split(/\r?\n/)
+        return 0 if lines.empty?
+
+        # return the length of each line + screen width for every line
+        # past the first which accounts for multi-line prompts
+        lines.join.length + ((lines.length - 1) * TTY::Screen.width)
+      end
+
+      # Check if line is in edit mode
+      #
+      # @return [Boolean]
+      #
+      # @public
+      def editing?
+        @mode == :edit
+      end
+
+      # Enable edit mode
+      #
+      # @return [Boolean]
+      #
+      # @public
+      def edit_mode
+        @mode = :edit
+      end
+
+      # Check if line is in replace mode
+      #
+      # @return [Boolean]
+      #
+      # @public
+      def replacing?
+        @mode == :replace
+      end
+
+      # Enable replace mode
+      #
+      # @return [Boolean]
+      #
+      # @public
+      def replace_mode
+        @mode = :replace
+      end
+
+      # Check if cursor reached beginning of the line
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def start?
+        @cursor.zero?
+      end
+
+      # Check if cursor reached end of the line
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def end?
+        @cursor == @text.length
+      end
+
+      # Move line position to the left by n chars
+      #
+      # @api public
+      def left(n = 1)
+        @cursor = [0, @cursor - n].max
+      end
+
+      # Move line position to the right by n chars
+      #
+      # @api public
+      def right(n = 1)
+        @cursor = [@text.length, @cursor + n].min
+      end
+
+      # Move cursor to beginning position
+      #
+      # @api public
+      def move_to_start
+        @cursor = 0
+      end
+
+      # Move cursor to end position
+      #
+      # @api public
+      def move_to_end
+        @cursor = @text.length # put cursor outside of text
+      end
+
+      # Insert characters inside a line. When the lines exceeds
+      # maximum length, an extra space is added to accomodate index.
+      #
+      # @param [Integer] i
+      #   the index to insert at
+      #
+      # @param [String] chars
+      #   the characters to insert
+      #
+      # @example
+      #   text = "aaa"
+      #   line[5]= "b"
+      #   => "aaa  b"
+      #
+      # @api public
+      def []=(i, chars)
+        edit_mode
+
+        if i.is_a?(Range)
+          @text[i] = chars
+          @cursor += chars.length
+          return
+        end
+
+        if i <= 0
+          before_text = ""
+          after_text = @text.dup
+        elsif i > @text.length - 1 # insert outside of line input
+          before_text = @text.dup
+          after_text = ?\s * (i - @text.length)
+          @cursor += after_text.length
+        else
+          before_text = @text[0..i-1].dup
+          after_text  = @text[i..-1].dup
+        end
+
+        if i > @text.length - 1
+          @text = before_text + after_text + chars
+        else
+          @text = before_text + chars + after_text
+        end
+
+        @cursor = i + chars.length
+      end
+
+      # Read character
+      #
+      # @api public
+      def [](i)
+        @text[i]
+      end
+
+      # Find a word under the cursor based on a separator
+      #
+      # @param [Boolean] before
+      #   whether to start searching before or after a break character
+      #
+      # @return [String]
+      #
+      # @api public
+      def word(before: true)
+        start_pos = word_start_pos(before: before)
+        @text[start_pos..word_end_pos(from: start_pos)]
+      end
+
+      # Find a subtext under the cursor
+      #
+      # @param [Boolean] before
+      #   whether to return the subtext before or after the cursor position
+      #
+      # @return [String]
+      #
+      # @api public
+      def subtext(before: true)
+
+        before ? @text[0..@cursor] : @text[@cursor..-1]
+
+      end
+
+      # Find a word up to a cursor position
+      #
+      # @param [Boolean] before
+      #   whether to start searching before or after a break character
+      #
+      # @return [String]
+      #
+      # @api public
+      def word_to_complete(before: true)
+        @text[word_start_pos(before: before)...@cursor]
+      end
+
+      # Find word start position
+      #
+      # @param [Integer] from
+      #   the index to start searching from, defaults to cursor position
+      #
+      # @param [Symbol] before
+      #   whether to start search before or after break character
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def word_start_pos(from: @cursor, before: true)
+        # move back or forward by one character when at a word boundary
+        if word_boundary?
+          from = before ? from - 1 : from + 1
+        end
+
+        start_pos = @text.rindex(separator, from) || 0
+        start_pos += 1 unless start_pos.zero?
+        start_pos
+      end
+
+      # Find word end position
+      #
+      # @param [Integer] from
+      #   the index to start searching from, defaults to cursor position
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def word_end_pos(from: @cursor)
+        end_pos = @text.index(separator, from) || text_size
+        end_pos -= 1 unless @text.empty?
+        end_pos
+      end
+
+      # Check if cursor is at a word boundary
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def word_boundary?
+        @text[@cursor] =~ separator
+      end
+
+      # Replace current line with new text
+      #
+      # @param [String] text
+      #
+      # @api public
+      def replace(text)
+        @text = text
+        @cursor = @text.length # put cursor outside of text
+        replace_mode
+      end
+
+      # Insert char(s) at cursor position
+      #
+      # @api public
+      def insert(chars)
+        self[@cursor] = chars
+      end
+
+      # Add char and move cursor
+      #
+      # @api public
+      def <<(char)
+        @text << char
+        @cursor += 1
+      end
+
+      # Remove char from the line at current position
+      #
+      # @api public
+      def delete(n = 1)
+        @text.slice!(@cursor, n)
+      end
+
+      # Remove char from the line in front of the cursor
+      #
+      # @param [Integer] n
+      #   the number of chars to remove
+      #
+      # @api public
+      def remove(n = 1)
+        left(n)
+        @text.slice!(@cursor, n)
+      end
+
+      # Full line with prompt as string
+      #
+      # @api public
+      def to_s
+        "#{@prompt}#{@text}"
+      end
+      alias inspect to_s
+
+      # Text size
+      #
+      # @api public
+      def text_size
+        self.class.sanitize(@text).size
+      end
+
+      # Full line size with prompt
+      #
+      # @api public
+      def size
+        prompt_size + text_size
+      end
+      alias length size
+    end # Line
+  end # Reader
+end # TTY2

data/lib/tty2/reader/mode.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module TTY2
+  class Reader
+    class Mode
+      # Initialize a Terminal
+      #
+      # @api public
+      def initialize(input = $stdin)
+        @input = input
+      end
+
+      # Echo given block
+      #
+      # @param [Boolean] is_on
+      #
+      # @api public
+      def echo(is_on = true, &block)
+        if is_on || !@input.tty?
+          yield
+        else
+          @input.noecho(&block)
+        end
+      end
+
+      # Use raw mode in the given block
+      #
+      # @param [Boolean] is_on
+      #
+      # @api public
+      def raw(is_on = true, &block)
+        if is_on && @input.tty?
+          @input.raw(&block)
+        else
+          yield
+        end
+      end
+    end # Mode
+  end # Reader
+end # TTY2

data/lib/tty2/reader/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TTY2
+  class Reader
+    VERSION = "0.9.0.1"
+  end # Reader
+end # TTY2

data/lib/tty2/reader/win_api.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module TTY2
+  class Reader
+    module WinAPI
+      include Fiddle
+
+      CRT_HANDLE = Fiddle::Handle.new("msvcrt") rescue Fiddle::Handle.new("crtdll")
+
+      # Get a character from the console without echo.
+      #
+      # @return [String]
+      #   return the character read
+      #
+      # @api public
+      def getch
+        @@getch ||= Fiddle::Function.new(CRT_HANDLE["_getch"], [], TYPE_INT)
+        @@getch.call
+      end
+      module_function :getch
+
+      # Gets a character from the console with echo.
+      #
+      # @return [String]
+      #   return the character read
+      #
+      # @api public
+      def getche
+        @@getche ||= Fiddle::Function.new(CRT_HANDLE["_getche"], [], TYPE_INT)
+        @@getche.call
+      end
+      module_function :getche
+
+      # Check the console for recent keystroke. If the function
+      # returns a nonzero value, a keystroke is waiting in the buffer.
+      #
+      # @return [Integer]
+      #   return a nonzero value if a key has been pressed. Otherwirse,
+      #   it returns 0.
+      #
+      # @api public
+      def kbhit
+        @@kbhit ||= Fiddle::Function.new(CRT_HANDLE["_kbhit"], [], TYPE_INT)
+        @@kbhit.call
+      end
+      module_function :kbhit
+    end # WinAPI
+  end # Reader
+end # TTY2

data/lib/tty2/reader/win_console.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "keys"
+
+module TTY2
+  class Reader
+    class WinConsole
+      ESC     = "\e"
+      NUL_HEX = "\x00"
+      EXT_HEX = "\xE0"
+
+      # Key codes
+      #
+      # @return [Hash[Symbol]]
+      #
+      # @api public
+      attr_reader :keys
+
+      # Escape codes
+      #
+      # @return [Array[Integer]]
+      #
+      # @api public
+      attr_reader :escape_codes
+
+      def initialize(input)
+        require_relative "win_api"
+        @input = input
+        @keys = Keys.ctrl_keys.merge(Keys.win_keys)
+        @escape_codes = [[NUL_HEX.ord], [ESC.ord], EXT_HEX.bytes.to_a]
+      end
+
+      # Get a character from console blocking for input
+      #
+      # @param [Boolean] echo
+      #   whether to echo input back or not, defaults to true
+      # @param [Boolean] raw
+      #   whether to use raw mode or not, defaults to false
+      # @param [Boolean] nonblock
+      #   whether to wait for input or not, defaults to false
+      #
+      # @return [String]
+      #
+      # @api private
+      def get_char(echo: true, raw: false, nonblock: false)
+        if raw && echo
+          if nonblock
+            get_char_echo_non_blocking
+          else
+            get_char_echo_blocking
+          end
+        elsif raw && !echo
+          nonblock ? get_char_non_blocking : get_char_blocking
+        elsif !raw && !echo
+          nonblock ? get_char_non_blocking : get_char_blocking
+        else
+          @input.getc
+        end
+      end
+
+      # Get the char for last key pressed, or if no keypress return nil
+      #
+      # @api private
+      def get_char_non_blocking
+        input_ready? ? get_char_blocking : nil
+      end
+
+      def get_char_echo_non_blocking
+        input_ready? ? get_char_echo_blocking : nil
+      end
+
+      def get_char_blocking
+        WinAPI.getch.chr
+      end
+
+      def get_char_echo_blocking
+        WinAPI.getche.chr
+      end
+
+      # Check if IO has user input
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def input_ready?
+        !WinAPI.kbhit.zero?
+      end
+    end # Console
+  end # Reader
+end # TTY2