austb-tty-prompt 0.13.0

data/lib/tty/prompt/reader/codes.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    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 # Prompt
+end # TTY

data/lib/tty/prompt/reader/console.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require_relative 'codes'
+require_relative 'mode'
+
+module TTY
+  class Prompt
+    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 # Prompt
+end # TTY

data/lib/tty/prompt/reader/history.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require 'forwardable'
+
+module TTY
+  class Prompt
+    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 # Prompt
+end # TTY

data/lib/tty/prompt/reader/key_event.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    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 # Prompt
+end # TTY

data/lib/tty/prompt/reader/line.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+
+require 'forwardable'
+
+module TTY
+  class Prompt
+    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 # Prompt
+end # TTY