tty-reader 0.1.0

data/lib/tty/reader/codes.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module TTY
+  class Reader
+    module Codes
+      def ctrl_keys
+        {
+          ctrl_a: ?\C-a,
+          ctrl_b: ?\C-b,
+          ctrl_c: ?\C-c,
+          ctrl_d: ?\C-d,
+          ctrl_e: ?\C-e,
+          ctrl_f: ?\C-f,
+          ctrl_g: ?\C-g,
+          ctrl_h: ?\C-h,
+          ctrl_i: ?\C-i,
+          ctrl_j: ?\C-j,
+          ctrl_k: ?\C-k,
+          ctrl_l: ?\C-l,
+          ctrl_m: ?\C-m,
+          ctrl_n: ?\C-n,
+          ctrl_o: ?\C-o,
+          ctrl_p: ?\C-p,
+          ctrl_q: ?\C-q,
+          ctrl_r: ?\C-r,
+          ctrl_s: ?\C-s,
+          ctrl_t: ?\C-t,
+          ctrl_u: ?\C-u,
+          ctrl_v: ?\C-v,
+          ctrl_w: ?\C-w,
+          ctrl_x: ?\C-x,
+          ctrl_y: ?\C-y,
+          ctrl_z: ?\C-z
+        }
+      end
+      module_function :ctrl_keys
+
+      def keys
+        {
+          tab:       "\t",
+          enter:     "\n",
+          return:    "\r",
+          escape:    "\e",
+          space:     " ",
+          backspace: ?\C-?,
+          home:      "\e[1~",
+          insert:    "\e[2~",
+          delete:    "\e[3~",
+          end:       "\e[4~",
+          page_up:   "\e[5~",
+          page_down: "\e[6~",
+
+          up:     "\e[A",
+          down:   "\e[B",
+          right:  "\e[C",
+          left:   "\e[D",
+          clear:  "\e[E",
+
+          f1_xterm: "\eOP",
+          f2_xterm: "\eOQ",
+          f3_xterm: "\eOR",
+          f4_xterm: "\eOS",
+
+          f1:  "\e[11~",
+          f2:  "\e[12~",
+          f3:  "\e[13~",
+          f4:  "\e[14~",
+          f5:  "\e[15~",
+          f6:  "\e[17~",
+          f7:  "\e[18~",
+          f8:  "\e[19~",
+          f9:  "\e[20~",
+          f10: "\e[21~",
+          f11: "\e[23~",
+          f12: "\e[24~"
+        }.merge(ctrl_keys)
+      end
+      module_function :keys
+
+      def win_keys
+        {
+          tab:       "\t",
+          enter:     "\r",
+          return:    "\r",
+          escape:    "\e",
+          space:     " ",
+          backspace: "\b",
+          home:      [224, 71].pack('U*'),
+          end:       [224, 79].pack('U*'),
+          insert:    [224, 82].pack('U*'),
+          delete:    [224, 83].pack('U*'),
+          page_up:   [224, 73].pack('U*'),
+          page_down: [224, 81].pack('U*'),
+
+          up:     [224, 72].pack('U*'),
+          down:   [224, 80].pack('U*'),
+          right:  [224, 77].pack('U*'),
+          left:   [224, 75].pack('U*'),
+          clear:  [224, 83].pack('U*'),
+
+          f1:  "\x00;",
+          f2:  "\x00<",
+          f3:  "\x00",
+          f4:  "\x00=",
+          f5:  "\x00?",
+          f6:  "\x00@",
+          f7:  "\x00A",
+          f8:  "\x00B",
+          f9:  "\x00C",
+          f10: "\x00D",
+          f11: "\x00\x85",
+          f12: "\x00\x86"
+        }.merge(ctrl_keys)
+      end
+      module_function :win_keys
+
+    end # Codes
+  end # Reader
+end # TTY

data/lib/tty/reader/console.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'codes'
+require_relative 'mode'
+
+module TTY
+  class Reader
+    class Console
+      ESC = "\e".freeze
+      CSI = "\e[".freeze
+
+      # Key codes
+      #
+      # @return [Hash[Symbol]]
+      #
+      # @api public
+      attr_reader :keys
+
+      # Escape codes
+      #
+      # @return [Array[Integer]]
+      #
+      # @api public
+      attr_reader :escape_codes
+
+      def initialize(input)
+        @input = input
+        @mode  = Mode.new(input)
+        @keys  = Codes.keys
+        @escape_codes = [[ESC.ord], CSI.bytes.to_a]
+      end
+
+      # Get a character from console with echo
+      #
+      # @param [Hash[Symbol]] options
+      # @option options [Symbol] :echo
+      #   the echo toggle
+      #
+      # @return [String]
+      #
+      # @api private
+      def get_char(options)
+        mode.raw(options[:raw]) do
+          mode.echo(options[:echo]) { input.getc }
+        end
+      end
+
+      protected
+
+      attr_reader :mode
+
+      attr_reader :input
+    end # Console
+  end # Reader
+end # TTY

data/lib/tty/reader/history.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module TTY
+  class Reader
+    # A class responsible for storing a history of all lines entered by
+    # user when interacting with shell prompt.
+    #
+    # @api private
+    class History
+      include Enumerable
+      extend Forwardable
+
+      # Default maximum size
+      DEFAULT_SIZE = 32 << 4
+
+      def_delegators :@history, :size, :length, :to_s, :inspect
+
+      # Set and retrieve the maximum size of the buffer
+      attr_accessor :max_size
+
+      attr_reader :index
+
+      attr_accessor :cycle
+
+      attr_accessor :duplicates
+
+      attr_accessor :exclude
+
+      # Create a History buffer
+      #
+      # param [Integer] max_size
+      #   the maximum size for history buffer
+      #
+      # param [Hash[Symbol]] options
+      # @option options [Boolean] :duplicates
+      #   whether or not to store duplicates, true by default
+      #
+      # @api public
+      def initialize(max_size = DEFAULT_SIZE, options = {})
+        @max_size   = max_size
+        @index      = 0
+        @history    = []
+        @duplicates = options.fetch(:duplicates) { true }
+        @exclude    = options.fetch(:exclude) { proc {} }
+        @cycle      = options.fetch(:cycle) { false }
+        yield self if block_given?
+      end
+
+      # Iterates over history lines
+      #
+      # @api public
+      def each
+        if block_given?
+          @history.each { |line| yield line }
+        else
+          @history.to_enum
+        end
+      end
+
+      # Add the last typed line to history buffer
+      #
+      # @param [String] line
+      #
+      # @api public
+      def push(line)
+        @history.delete(line) unless @duplicates
+        return if line.to_s.empty? || @exclude[line]
+
+        @history.shift if size >= max_size
+        @history << line
+        @index = @history.size - 1
+
+        self
+      end
+      alias << push
+
+      # Move the pointer to the next line in the history
+      #
+      # @api public
+      def next
+        return if size.zero?
+        if @index == size - 1
+          @index = 0 if @cycle
+        else
+          @index += 1
+        end
+      end
+
+      def next?
+        size > 0 && !(@index == size - 1 && !@cycle)
+      end
+
+      # Move the pointer to the previous line in the history
+      def previous
+        return if size.zero?
+        if @index.zero?
+          @index = size - 1 if @cycle
+        else
+          @index -= 1
+        end
+      end
+
+      def previous?
+        size > 0 && !(@index < 0 && !@cycle)
+      end
+
+      # Return line at the specified index
+      #
+      # @raise [IndexError] index out of range
+      #
+      # @api public
+      def [](index)
+        if index < 0
+          index += @history.size if index < 0
+        end
+        line = @history[index]
+        if line.nil?
+          raise IndexError, 'invalid index'
+        end
+        line.dup
+      end
+
+      # Get current line
+      #
+      # @api public
+      def get
+        return if size.zero?
+
+        self[@index]
+      end
+
+      # Empty all history lines
+      #
+      # @api public
+      def clear
+        @history.clear
+        @index = 0
+      end
+    end # History
+  end # Reader
+end # TTY

data/lib/tty/reader/key_event.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module TTY
+  class Reader
+    # Responsible for meta-data information about key pressed
+    #
+    # @api private
+    class Key < Struct.new(:name, :ctrl, :meta, :shift)
+      def initialize(*)
+        super(nil, false, false, false)
+      end
+    end
+
+    # Represents key event emitted during keyboard press
+    #
+    # @api public
+    class KeyEvent < Struct.new(:value, :key)
+      # Create key event from read input codes
+      #
+      # @param [Hash[Symbol]] keys
+      #   the keys and codes mapping
+      # @param [Array[Integer]] codes
+      #
+      # @return [KeyEvent]
+      #
+      # @api public
+      def self.from(keys, char)
+        key = Key.new
+        ctrls = keys.keys.grep(/ctrl/)
+
+        case char
+        when keys[:return] then key.name = :return
+        when keys[:enter]  then key.name = :enter
+        when keys[:tab]    then key.name = :tab
+        when keys[:backspace] then key.name = :backspace
+        when keys[:delete] then key.name = :delete
+        when keys[:space]  then key.name = :space
+        when keys[:escape] then key.name = :escape
+        when proc { |c| c =~ /^[a-z]{1}$/ }
+          key.name = :alpha
+        when proc { |c| c =~ /^[A-Z]{1}$/ }
+          key.name = :alpha
+          key.shift = true
+        when proc { |c| c =~ /^\d+$/ }
+          key.name = :num
+        # arrows
+        when keys[:up]    then key.name = :up
+        when keys[:down]  then key.name = :down
+        when keys[:left]  then key.name = :left
+        when keys[:right] then key.name = :right
+        # editing
+        when keys[:clear] then key.name = :clear
+        when keys[:end]   then key.name = :end
+        when keys[:home]  then key.name = :home
+        when keys[:insert]    then key.name = :insert
+        when keys[:page_up]   then key.name = :page_up
+        when keys[:page_down] then key.name = :page_down
+        when proc { |cs| ctrls.any? { |name| keys[name] == cs } }
+          key.name = keys.key(char)
+          key.ctrl = true
+        # f1 - f12
+        when keys[:f1], keys[:f1_xterm] then key.name = :f1
+        when keys[:f2], keys[:f2_xterm] then key.name = :f2
+        when keys[:f3], keys[:f3_xterm] then key.name = :f3
+        when keys[:f4], keys[:f4_xterm] then key.name = :f4
+        when keys[:f5] then key.name = :f5
+        when keys[:f6] then key.name = :f6
+        when keys[:f7] then key.name = :f7
+        when keys[:f8] then key.name = :f8
+        when keys[:f9] then key.name = :f9
+        when keys[:f10] then key.name = :f10
+        when keys[:f11] then key.name = :f11
+        when keys[:f12] then key.name = :f12
+        end
+
+        new(char, key)
+      end
+
+      # Check if key event can be triggered
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def trigger?
+        !key.nil? && !key.name.nil?
+      end
+    end # KeyEvent
+  end # Reader
+end # TTY

data/lib/tty/reader/line.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module TTY
+  class Reader
+    class Line
+      extend Forwardable
+
+      def_delegators :@text, :size, :length, :to_s, :inspect,
+                      :slice!, :empty?
+
+      attr_accessor :text
+
+      attr_accessor :cursor
+
+      def initialize(text = "")
+        @text = text
+        @cursor = [0, @text.length].max
+        yield self if block_given?
+      end
+
+      # Check if cursor reached beginning of the line
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def start?
+        @cursor == 0
+      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
+      #
+      # @example
+      #   text = 'aaa'
+      #   line[5]= 'b'
+      #   => 'aaa  b'
+      #
+      # @api public
+      def []=(i, chars)
+        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
+          before_text = @text.dup
+          after_text = ''
+        elsif i > @text.length - 1
+          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
+
+      # Replace current line with new text
+      #
+      # @param [String] text
+      #
+      # @api public
+      def replace(text)
+        @text = text
+        @cursor = @text.length # put cursor outside of text
+      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
+        @text.slice!(@cursor, 1)
+      end
+
+      # Remove char from the line in front of the cursor
+      #
+      # @api public
+      def remove
+        left
+        @text.slice!(@cursor, 1)
+      end
+    end # Line
+  end # Reader
+end # TTY