mini_readline 0.0.1

data/lib/mini_readline/raw_term/other/set_posn.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+#* windows/set_posn.rb - Set the column of the cursor.
+module MiniReadline
+
+  #* windows/set_posn.rb - Set the column of the cursor.
+  class RawTerm
+
+    #Move the cursor using terminal primitives.
+    def set_posn(new_posn)
+      if new_posn == 0
+        put_string(CARRIAGE_RETURN)
+      elsif new_posn > @cursor_posn
+        print("\e[#{new_posn - @cursor_posn}C")
+      elsif new_posn < @cursor_posn
+        print("\e[#{@cursor_posn - new_posn}D")
+      end
+
+      @cursor_posn = new_posn
+    end
+  end
+end

data/lib/mini_readline/raw_term/windows.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require_relative 'windows/win_32_api'
+require_relative 'windows/map'
+require_relative 'windows/set_posn'
+
+#* raw_term/windows.rb - Support for raw terminal access in windows systems.
+module MiniReadline
+
+  #The detected platform is windows.
+  PLATFORM = :windows
+
+  #The class used to manipulate console i/o on a low level.
+  class RawTerm
+
+    #The sleep interval waiting for a key to be pressed.
+    WAIT_SLEEP      = 0.02
+
+    #Carriage return
+    CARRIAGE_RETURN = "\x0D"
+
+    #The magic number for standard out.
+    STD_OUTPUT_HANDLE = -11
+
+    #Set up the Windows Raw Terminal.
+    def initialize
+      @_getch = Win32API.new("msvcrt", "_getch", [])
+      @_kbhit = Win32API.new("msvcrt", "_kbhit", [])
+      @_beep  = Win32API.new("user32", "MessageBeep", ['L'])
+
+      @_set_cursor_posn = Win32API.new("kernel32",
+                                       "SetConsoleCursorPosition",
+                                       ['L','L'])
+
+      @_get_screen_info = Win32API.new("kernel32",
+                                       "GetConsoleScreenBufferInfo",
+                                       ['L','P'])
+
+      @_get_handle = Win32API.new("kernel32", "GetStdHandle", ['L'])
+    end
+
+    #Output a string
+    def put_string(str)
+      scan_string(str) unless @_out_handle
+      print(str)
+    end
+
+    #Home the cursor and start at a known state.
+    def initialize_parms
+      @_out_handle = @_get_handle.call(STD_OUTPUT_HANDLE)
+      put_string CARRIAGE_RETURN
+    end
+
+    #Start on a new line.
+    def put_new_line
+      print("\n")
+    end
+
+    #Sound a beep
+    def beep
+      @_beep.call(0)
+    end
+
+    #Wait for a key to be pressed.
+    def wait_for_key
+      while (@_kbhit.call == 0)
+        sleep(WAIT_SLEEP)
+      end
+    end
+
+    #Get a uncooked character keystroke.
+    def get_raw_char
+      wait_for_key
+      @_getch.call.chr
+    end
+
+    #Determine the affect of a string on the cursor.
+    def scan_string(str)
+      str.chars.each do |char|
+        if char == CARRIAGE_RETURN
+          @cursor_posn = 0
+        else
+          @cursor_posn += 1
+        end
+      end
+    end
+  end
+end

data/lib/mini_readline/raw_term/windows/map.rb

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+#* windows/map.rb - Character mapping for windows systems.
+module MiniReadline
+
+  #* windows/map.rb - Character mapping for windows systems.
+  class RawTerm
+
+    #Create a hash with a default value.
+    MAP = Hash.new {|_hash, key| [:unmapped, key]}
+
+    #Map the printable characters.
+    (32..126).each do |code|
+      char = code.chr
+      MAP[char] = [:insert_text, char]
+    end
+
+    pfx = 0xE0.chr
+
+    #Map the non-terminal entries.
+    MAP["\x00"] = false
+    MAP[  pfx ] = false
+
+    #Map the non-printing characters.
+
+    #Left Arrows
+    MAP["\x00K"] = [:go_left]
+    MAP[pfx+"K"] = [:go_left]
+
+    #Right Arrows
+    MAP["\x00M"] = [:go_right]
+    MAP[pfx+"M"] = [:go_right]
+
+    #Up Arrows
+    MAP["\x00H"] = [:previous_history]
+    MAP[pfx+"H"] = [:previous_history]
+
+    #Down Arrows
+    MAP["\x00P"] = [:next_history]
+    MAP[pfx+"P"] = [:next_history]
+
+    #The Home keys
+    MAP["\x00G"] = [:go_home]
+    MAP[pfx+"G"] = [:go_home]
+
+    #The End keys
+    MAP["\x00O"] = [:go_end]
+    MAP[pfx+"O"] = [:go_end]
+
+    #The Backspace key
+    MAP["\x08"]  = [:delete_left]
+
+    #The Delete keys
+    MAP["\x7F"]  = [:delete_right]
+    MAP["\x00S"] = [:delete_right]
+    MAP[pfx+"S"] = [:delete_right]
+
+    #The Enter key
+    MAP["\x0D"]  = [:enter]
+
+    #The Escape key
+    MAP["\x1B"]  = [:cancel]
+
+    #Get a mapped sequence.
+    def get_mapped_keystroke
+      first_char = get_raw_char
+
+      MAP[first_char] || MAP[first_char + get_raw_char]
+    end
+  end
+end

data/lib/mini_readline/raw_term/windows/set_posn.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+#* windows/set_posn.rb - Set the column of the cursor.
+module MiniReadline
+
+  #* windows/set_posn.rb - Set the column of the cursor.
+  class RawTerm
+
+    #Set the position of the screen cursor within the line.
+    def set_posn(new_posn)
+      if @_out_handle
+        api_set_posn(new_posn)
+      else
+        term_set_posn(new_posn)
+      end
+    end
+
+    #Move the cursor using windows voodoo API.
+    def api_set_posn(new_posn)
+      raw_buffer = 0.chr * 24
+      @_get_screen_info.call(@_out_handle, raw_buffer)
+      y_posn = (raw_buffer[6,2].unpack('S'))[0]
+
+      @_set_cursor_posn.call(@_out_handle, y_posn * 65536 + new_posn)
+    end
+
+    #Move the cursor using terminal primitives.
+    def term_set_posn(new_posn)
+
+      if new_posn > @cursor_posn
+        print("\e#{new_posn - @cursor_posn}C")
+      elsif new_posn < @cursor_posn
+        print("\e#{@cursor_posn - new_posn}D")
+      end
+
+      @cursor_posn = new_posn
+    end
+
+  end
+end

data/lib/mini_readline/raw_term/windows/win_32_api.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+#* windows/win_32_api.rb - Support for selected low level Win32 API entry points.
+module MiniReadline
+
+  require 'fiddle'
+
+  #The classic \Win32API gem is deprecated, so we emulate it with fiddle.
+  class Win32API
+
+    #Use standard calling conventions
+    STDCALL = 1
+
+    #A hash of DLL files used for one or more API entry points.
+    DLL = {}
+
+    #Type mappings.
+    TYPES = {"0" => Fiddle::TYPE_VOID,
+             "S" => Fiddle::TYPE_VOIDP,
+             "I" => Fiddle::TYPE_LONG}
+
+    #Set up an API entry point.
+    def initialize(dllname, func, import)
+      @proto = import.join.tr("VPpNnLlIi", "0SSI").chomp('0').split('')
+
+      handle = DLL[dllname] ||= Fiddle.dlopen(dllname)
+
+      @func = Fiddle::Function.new(handle[func], TYPES.values_at(*@proto), STDCALL)
+    end
+
+    #Call the Win 32 API entry point with appropriate arguments.
+    #<br>Endemic Code Smells
+    #* :reek:FeatureEnvy
+    def call(*args)
+      args.each_with_index do |arg, index|
+        case @proto[index]
+          when "S"
+            args[index], = [arg == 0 ? nil : arg].pack("p").unpack("l!*")
+          when "I"
+            args[index], = [arg].pack("I").unpack("i")
+        end
+      end
+
+      @func.call(*args).to_i || 0
+    end
+  end
+end

data/lib/mini_readline/read_line.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+
+require_relative 'read_line/edit'
+
+#* read_line.rb - The ReadLine class that does the actual work.
+module MiniReadline
+
+  #The \Readline class that does the actual work of getting lines from the
+  #user. Note that each instance of this class maintains its own copy of
+  #the optional command history.
+  class Readline
+
+    #Setup the instance of the mini line editor.
+    #<br>Parameters:
+    #* buffer - An array of strings used to contain the history. Use an empty
+    #  array to have a history buffer with no initial entries. Use the
+    #  value nil (or false) to maintain no history at all.
+    def initialize(buffer=[])
+      @edit = Edit.new(buffer)
+    end
+
+    #Get the history buffer of this read line instance.
+    def history
+      @edit.history
+    end
+
+    #Read a line from the console with edit and history.
+    #<br>Parameters:
+    #* prompt - A string used to prompt the user. '>' is popular.
+    #* options - A hash of options; Typically :symbol => value
+    def readline(prompt, options = {})
+      initialize_parms(prompt, options)
+      result = @edit.edit_process
+      @term.put_new_line
+      result
+    end
+
+    #Initialize the read line process. This basically process the arguments
+    #of the readline method.
+    def initialize_parms(prompt, options)
+      @options = MiniReadline::BASE_OPTIONS.merge(options)
+      (@term = @options[:term]).initialize_parms
+
+      set_prompt(prompt)
+      @edit.initialize_edit_parms(@options)
+    end
+
+    #Set up the prompt options.
+    def set_prompt(prompt)
+      @options[:base_prompt]   = prompt
+      @options[:scroll_prompt] = @options[:alt_prompt] || prompt
+
+      verify_prompt(@options[:base_prompt])
+      verify_prompt(@options[:scroll_prompt])
+    end
+
+    #Verify that the prompt will fit!
+    def verify_prompt(str)
+      unless (@options[:window_width] - str.length) >
+             (@options[:scroll_step] * 2)
+        fail "Prompt too long: #{str.inspect}"
+      end
+    end
+  end
+end

data/lib/mini_readline/read_line/edit.rb

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+require_relative 'edit_window'
+require_relative 'history'
+
+require_relative 'edit/insert_text'
+require_relative 'edit/enter'
+
+require_relative 'edit/go_left'
+require_relative 'edit/go_right'
+
+require_relative 'edit/go_home'
+require_relative 'edit/go_end'
+
+require_relative 'edit/delete_left'
+require_relative 'edit/delete_right'
+require_relative 'edit/cancel'
+
+require_relative 'edit/previous_history'
+require_relative 'edit/next_history'
+
+require_relative 'edit/unmapped'
+
+#* read_line/edit.rb - The line editor.
+module MiniReadline
+
+  #* read_line/edit.rb - The line editor.
+  class Edit
+
+    #Set up the edit instance.
+    def initialize(buffer)
+      @history     = History.new(buffer)
+      @edit_window = EditWindow.new
+    end
+
+    #Set up the initial edit settings.
+    def initialize_edit_parms(options)
+      @options     = options
+      @term        = @options[:term]
+      @edit_posn   = 0
+      @edit_buffer = ""
+      @working     = true
+
+      @edit_window.initialize_parms(@options)
+      @history.initialize_parms(@options)
+    end
+
+    #The main edit buffer
+    attr_reader :edit_buffer
+
+    #The current edit position
+    attr_reader :edit_posn
+
+    #How long is the current string?
+    def length
+      edit_buffer.length
+    end
+
+    #Get the history array for this edit instance.
+    def history
+      @history.history
+    end
+
+    #Interact with the user
+    def edit_process
+      result = edit_loop
+      @history.append_history(result)
+      result
+    end
+
+    #The line editor processing loop.
+    def edit_loop
+      while @working
+        @edit_window.sync_window(edit_buffer, edit_posn)
+        @edit_window.sync_cursor(edit_posn)
+        process_keystroke(@term.get_mapped_keystroke)
+      end
+
+      edit_buffer
+    end
+
+    #Process a keystroke.
+    def process_keystroke(key_cmd)
+      send(key_cmd[0], key_cmd)
+    end
+  end
+end

data/lib/mini_readline/read_line/edit/cancel.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+#* read_line/window/edit/cancel.rb - Process :cancel
+module MiniReadline
+
+  #* read_line/window/edit/cancel.rb - Process :cancel
+  class Edit
+
+    #All right! Scrap all of this and start over!
+    def cancel(_keyboard_args)
+      @edit_buffer = ""
+      @edit_posn = 0
+    end
+  end
+end