inline 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+== Version 0.1.0
+
+First preview release of InLine, implementing some of the functionality provided by the ReadLine library such as basic line editing, history and word completion. 

data/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2008, Fabio Cevasco
+All rights reserved.
+
+- Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+Neither the name of the organization nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+

data/README

@@ -0,0 +1,43 @@
+= InLine
+
+InLine was created to provide a 100% Ruby alternative to the ReadLine library, providing some of its most popular features such as:
+
+* Basic line editing operations
+* Word completion
+* History Management 
+* Custom key/key sequences bindings
+
+== Installation
+
+The simplest method to install InLine is to install the gem:
+
+	gem install -r inline
+
+== Usage
+
+Editor initialization:
+
+	require 'inline'
+	editor = InLine::Editor.new
+
+Key binding:
+
+	editor.bind(:ctrl_z) { editor.undo }
+	editor.bind(:up_arrow) { editor.history_back }
+	editor.bind(:ctrl_x) { puts "Exiting..."; exit }
+
+Setup word completion
+
+	editor.completion_proc = lambda do |word|
+		if word
+			['select', 'update', 'delete', 'debug', 'destroy'].find_all	{ |e| e.match(/^#{Regexp.escape(word)}/) }
+		end
+	end
+	editor.completion_append_string = " "
+
+Read input:
+
+	editor.read("=> ")
+
+
+ 

data/lib/inline.rb

@@ -0,0 +1,26 @@
+#!/usr/local/bin/ruby -w
+
+#
+#	inline.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+
+module InLine
+	HOME = File.dirname(File.expand_path(__FILE__))
+	class BindingException < Exception; end
+end
+
+require "rubygems"
+require "highline"
+require "#{InLine::HOME}/inline/terminal"
+require "#{InLine::HOME}/inline/terminal/windows_terminal"
+require "#{InLine::HOME}/inline/terminal/vt220_terminal"
+require "#{InLine::HOME}/inline/history_buffer"
+require "#{InLine::HOME}/inline/line"
+require "#{InLine::HOME}/inline/editor"
+
+

data/lib/inline/editor.rb

@@ -0,0 +1,594 @@
+#!/usr/local/bin/ruby -w
+
+#
+#	editor.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+
+module InLine
+
+	# 
+	# The Editor class defines methods to:
+	#
+	# * Read characters from STDIN or any type of input
+	# * Write characters to STDOUT or any type of output
+	# * Bind keys to specific actions
+	# * Perform line-related operations like moving, navigating through history, etc.
+	# 
+	# Note that the following default key bindings are provided:
+	#
+	# * TAB: word completion defined via completion_proc
+	# * LEFT/RIGHT ARROWS: cursor movement (left/right)
+	# * UP/DOWN ARROWS: history navigation
+	# * DEL: Delete character under cursor
+	# * BACKSPACE: Delete character before cursor
+	# * INSERT: Toggle insert/replace mode (default: insert)
+	# * CTRL+K: Clear the whole line
+	# * CTRL+Z: undo (unless already registered by the OS)
+	# * CTRL+Y: redo (unless already registered by the OS)
+	#
+	class Editor
+
+		include HighLine::SystemExtensions
+
+		attr_accessor :char, :history_size, :line_history_size, :terminal, :keys, :word_separator, :mode, :completion_proc, :line, :history, :completion_append_string
+
+		# 
+		# Create an instance of InLine::Editor which can be used 
+		# to read from input and perform line-editing operations.
+		# This method takes an optional block used to override the 
+		# following instance attributes:
+		# * <tt>@history_size</tt> - the size of the editor history buffer (30).
+		# * <tt>@line_history_size</tt> - the size of the editor line history 
+		# buffer (50).
+		# * <tt>@keys</tt> - the keys (arrays of character codes) 
+		# bound to specific actions.
+		# * <tt>@word_separator</tt> - a string used as word separator (' ').
+		# * <tt>@mode</tt> - The editor's character insertion mode (:insert).
+		# * <tt>@completion_proc</tt> - a Proc object used to perform word completion.
+		# * <tt>@completion_append_string</tt> - a string to append to completed words.
+		# * <tt>@terminal</tt> -  an InLine::Terminal containing character key codes.
+		#
+		def initialize(input=STDIN, output=STDOUT)
+			@input = input
+			@output = output
+			case PLATFORM
+			when /win32/i then
+				@terminal = WindowsTerminal.new
+			else
+				@terminal = VT220Terminal.new
+			end
+			@history_size = 30
+			@line_history_size = 50
+			@keys = {}
+			@word_separator = ' '
+			@mode = :insert
+			@completion_proc = []
+			@completion_append_string = ' '
+			@completion_matches = HistoryBuffer.new(0) { |h| h.duplicates = false; h.cycle = true }
+			set_default_keys
+			yield self if block_given?
+			@history = HistoryBuffer.new(@history_size) do |h| 
+				h.duplicates = false; 
+				h.exclude = lambda { |item| item.strip == "" }
+			end
+			@char = nil
+			@newline = true
+		end
+		
+		# 
+		# Read characters from <tt>@input</tt> until the user presses ENTER 
+		# (use it in the same way as you'd use IO#gets)
+		# An optional prompt can be specified to be printed at the beginning of the line.
+		#
+		def read(prompt="")
+			@newline = true
+			@line = Line.new(@line_history_size) do |l| 
+				l.prompt = prompt
+				l.word_separator = @word_separator
+			end
+			add_to_line_history
+			loop do
+				print prompt if @newline
+				@newline = false
+				read_character
+				process_character
+				break if @char == @terminal.keys[:enter] || !@char
+			end
+			puts
+			"#{@line.text}\n"
+		end
+
+		# 
+		# Read and parse a character from <tt>@input</tt>.
+		# This method is called automatically by <tt>read</tt>
+		#
+		def read_character
+			c = get_character(@input)
+			@char = parse_key_code(c) || c
+		end
+
+		#
+		#	Parse a key or key sequence into the corresponding codes.
+		# This method is called automatically by <tt>read_character</tt>
+		#
+		def parse_key_code(code)
+			if @terminal.escape_codes.include? code then
+				sequence = [code]
+				seqs = []
+				loop do
+					c = get_character(@input)
+					sequence << c
+					seqs = @terminal.escape_sequences.select { |e| e[0..sequence.length-1] == sequence }
+					break if seqs.empty?
+					return sequence if [sequence] == seqs
+				end
+			else
+				return (@terminal.keys.has_value? [code]) ? [code] : nil
+			end
+		end
+
+		# 
+		# Write a string to <tt>@output</tt> starting from the cursor position. 
+		# Characters at the right of the cursor are shifted to the right if 
+		# <tt>@mode == :insert</tt>, deleted otherwise.
+		#
+		def write(string)
+			string.each_byte { |c| print_character c, true }
+			add_to_line_history
+		end
+
+		#
+		# Process a character. If the key corresponding to the inputted character
+		# is bound to an action, call <tt>press_key</tt>, otherwise call <tt>default_action</tt>.
+		# This method is called automatically by <tt>read</tt>
+		#
+		def process_character
+			case @char.class.to_s
+			when 'Fixnum' then
+				default_action
+			when 'Array'
+				press_key if key_bound?
+			end
+		end
+
+		#
+		# Bind a key to an action specified via <tt>block</tt>.
+		# <tt>key</tt> can be:
+		#
+		# * A Symbol identifying a character or character sequence defined for the current terminal
+		# * A Fixnum identifying a character defined for the current terminal
+		# * An Array identifying a character or character sequence defined for the current terminal
+		# * A String identifying a character or character sequence defined for the current terminal
+		# * An Hash identifying a character or character sequence, even if it is not defined for the current terminal
+		#
+		# If <tt>key</tt> is a has, then:
+		#
+		# * It must contain only one key/value pair
+		# * The key identifies the name of the character or character sequence
+		# * The value identifies the code(s) corresponding to the character or character sequence
+		# * The value can be a Fixnum, a String or an Array.
+		# 
+		def bind(key, &block)
+			case key.class.to_s
+			when 'Symbol' then
+				raise BindingException, "Unknown key or key sequence '#{key.to_s}' (#{key.class.to_s})" unless @terminal.keys[key]
+				@keys[@terminal.keys[key]] = block
+			when 'Array' then
+				raise BindingException, "Unknown key or key sequence '#{key.join(", ")}' (#{key.class.to_s})" unless @terminal.keys.has_value? key
+				@keys[key] = block
+			when 'Fixnum' then
+				raise BindingException, "Unknown key or key sequence '#{key.to_s}' (#{key.class.to_s})" unless @terminal.keys.has_value? [key]
+				@keys[[key]] = block
+			when 'String' then
+				raise BindingException, "Unknown key or key sequence '#{key.to_s}' (#{key.class.to_s})" unless @terminal.keys.has_value? key_array
+				key_array = []
+				key.each_byte { |b| key_array << b }
+				@keys[key_array] = block
+			when 'Hash' then
+				raise BindingException, "Cannot bind more than one key or key sequence at once" unless key.values.length == 1
+				key.each_pair do |j,k|
+					raise BindingException, "'#{k[0].chr}' is not a legal escape code for '#{@terminal.class.to_s}'." unless k.length > 1 && @terminal.escape_codes.include?(k[0])
+					code = []
+					case k.class.to_s
+					when 'Fixnum' then
+						code = [k]
+					when 'String' then
+						k.each_byte { |b| code << b }
+					when 'Array' then
+						code = k
+					else
+						raise BindingException, "Unable to bind '#{k.to_s}' (#{k.class.to_s})"
+					end
+					@terminal.keys[j] = code
+					@keys[code] = block
+				end
+			else
+				raise BindingException, "Unable to bind '#{key.to_s}' (#{key.class.to_s})"
+			end
+			@terminal.update
+		end
+
+		# 
+		# Return true if the last character read via <tt>read</tt> is bound to an action.
+		#
+		def key_bound?
+			@keys[@char] ? true : false
+		end
+
+		# 
+		# Call the action bound to the last character read via <tt>read</tt>.
+		# This method is called automatically by <tt>process_character</tt>.
+		#
+		def press_key
+			@keys[@char].call
+		end
+
+		# 
+		# Execute the default action for the last character read via <tt>read</tt>. 
+		# By default it prints the character to the screen via <tt>print_character</tt>.
+		# This method is called automatically by <tt>process_character</tt>.
+		#
+		def default_action
+			print_character
+		end
+
+		#
+		# Write a character to <tt>@output</tt> at cursor position, 
+		# shifting characters as appropriate.
+		# If <tt>no_line_history</tt> is set to <tt>true</tt>, the updated
+		# won't be saved in the history of the current line.
+		#
+		def print_character(char=@char, no_line_history = false)
+			unless @line.length >= @line.max_length-2
+				case
+				when @line.position < @line.length then
+					chars = select_characters_from_cursor if @mode == :insert
+					@output.putc char
+					@line.text[@line.position] = (@mode == :insert) ? "#{char.chr}#{@line.text[@line.position].chr}" : "#{char.chr}"
+					@line.right
+					if @mode == :insert then
+						raw_print chars
+						chars.length.times { putc ?\b } # move cursor back
+					end
+				else
+					@output.putc char
+					@line.right
+					@line << char 
+				end
+				add_to_line_history unless no_line_history
+			end
+		end
+		
+		# 
+		# Complete the current word according to what returned by
+		# <tt>@completion_proc</tt>. Characters can be appended to the 
+		# completed word via <tt>@completion_append_character</tt> and word
+		# separators can be defined via <tt>@word_separator</tt>.
+		#
+		# This action is bound to the tab key by default, so the first
+		# match is displayed the first time the user presses tab, and all
+		# the possible messages will be displayed (cyclically) when tab is
+		# pressed again. 
+		# 
+		def complete
+			completion_char = @char
+			@completion_matches.empty
+			word_start = @line.word[:start]
+			sub_word = @line.text[@line.word[:start]..@line.position-1] || ""
+			matches  = @completion_proc.call(sub_word)
+			matches = (matches.is_a?(Array)) ? matches.sort.reverse : []
+			complete_word = lambda do |match|
+				unless @line.word[:text].length == 0
+					# If not in a word, print the match, otherwise continue existing word
+					move_to_position(@line.word[:end]+@completion_append_string.length+1)
+				end
+				(@line.position-word_start).times { delete_left_character(true) }
+				write match+@completion_append_string
+			end
+			unless matches.empty? then
+				@completion_matches.resize(matches.length) 
+				matches.each { |w| @completion_matches << w }
+				# Get first match
+				@completion_matches.back
+				match = @completion_matches.get
+				complete_word.call(match)
+				read_character
+				while @char == completion_char do
+					move_to_position(word_start)
+					@completion_matches.back
+					match = @completion_matches.get
+					complete_word.call(match)
+					read_character
+				end
+				process_character
+			end
+		end
+
+		# 
+		# Adds <tt>@line.text</tt> to the editor history. This action is 
+		# bound to the enter key by default.
+		#
+		def newline
+			add_to_history
+		end
+
+		# 
+		# Move the cursor left (if possible) by printing a 
+		# backspace, updating <tt>@line.position</tt> accordingly.
+		# This action is bound to the left arrow key by default. 
+		#
+		def move_left
+			unless @line.bol?:
+				@output.putc ?\b
+				@line.left
+				return true
+			end
+			false
+		end
+		
+		# 
+		# Move the cursor right (if possible) by re-printing the
+		# character at the right of the cursor, if any, and updating
+		# <tt>@line.position</tt> accordingly. 
+		# This action is bound to the right arrow key by default.
+		#
+		def move_right
+			unless @line.position > @line.eol:
+				@line.right
+				@output.putc @line.text[@line.position-1]
+				return true
+			end
+			false
+		end
+
+		#
+		# Print debug information about the current line. Note that after
+		# the message is displayed, the line text and position will be restored.
+		#
+		def debug_line
+			pos = @line.position
+			text = @line.text
+			word = @line.word
+			@output.puts 
+			@output.puts "Text: [#{text}]"
+			@output.puts "Length: #{@line.length}"
+			@output.puts "Position: #{pos}"
+			@output.puts "Character at Position: [#{text[pos].chr}] (#{text[pos]})" unless pos >= @line.length
+			@output.puts "Current Word: [#{word[:text]}] (#{word[:start]} -- #{word[:end]})"
+			clear_line
+			raw_print text
+			overwrite_line(text, pos)
+		end
+
+		#
+		# Print the content of the editor history. Note that after
+		# the message is displayed, the line text and position will be restored.
+		#
+		def show_history
+			pos = @line.position
+			text = @line.text
+			@output.puts
+			@output.puts "History:"
+			@history.each {|l| puts "- [#{l}]"}
+			overwrite_line(text, pos)
+		end
+
+		# 
+		# Clear the editor history.
+		#
+		def clear_history
+			@history.empty
+		end
+
+		# 
+		# Delete the character at the left of the cursor. 
+		# If <tt>no_line_hisytory</tt> is set to true, the deletion won't be
+		# recorded in the line history.
+		# This action is bound to the backspace key by default.
+		#
+		def delete_left_character(no_line_history=false)
+			if move_left then
+				delete_character(no_line_history)
+			end
+		end
+
+		# 
+		# Delete the character under the cursor. 
+		# If <tt>no_line_hisytory</tt> is set to true, the deletion won't be
+		# recorded in the line history.
+		# This action is bound to the delete key by default.
+		#
+		def delete_character(no_line_history=false)
+			unless @line.position > @line.eol
+				# save characters to shift
+				chars = (@line.eol?) ? ' ' : select_characters_from_cursor(1)
+				# remove character from console and shift characters
+				raw_print chars
+				putc ?\s
+				(chars.length+1).times { putc ?\b }
+				#remove character from line
+				@line[@line.position] = ''
+				add_to_line_history unless no_line_history
+			end
+		end
+
+		# 
+		# Clear the current line, i.e. 
+		# <tt>@line.text</tt> and <tt>@line.position</tt>.
+		# This action is bound to ctrl+k by default.
+		#
+		def clear_line
+			@output.putc ?\r
+			raw_print @line.prompt
+			@line.length.times { putc ?\s }
+			@line.length.times { putc ?\b }
+			add_to_line_history
+			@line.text = ""
+			@line.position = 0
+		end
+
+		# 
+		# Undo the last modification to the current line (<tt>@line.text</tt>).
+		# This action is bound to ctrl+z by default.
+		#
+		def undo
+			generic_history_back(@line.history) if @line.history.position == nil
+			generic_history_back(@line.history)
+		end
+
+		# 
+		# Redo a previously-undone modification to the 
+		# current line (<tt>@line.text</tt>).
+		# This action is bound to ctrl+y by default.
+		#
+		def redo
+			generic_history_forward(@line.history)
+		end
+
+		# 
+		# Load the previous entry of the editor in place of the 
+		# current line (<tt>@line.text</tt>).
+		# This action is bound to the up arrow key by default.
+		#
+		def history_back
+			unless @history.position
+				current_line = @line.text.dup
+				# Temporarily override exclusion rules
+				exclude = @history.exclude.dup
+				@history.exclude = lambda { nil }
+				# Add current line
+				@history << current_line
+				@history.exclude = exclude
+				@history.back
+			end
+			generic_history_back(@history)
+			add_to_line_history
+		end
+
+		# 
+		# Load the next entry of the editor history in place of the 
+		# current line (<tt>@line.text</tt>).
+		# This action is bound to down arrow key by default.
+		#
+		def history_forward
+			generic_history_forward(@history)
+			add_to_line_history
+		end
+
+		# 
+		# Add the current line (<tt>@line.text</tt>) to the 
+		# line history, to allow undo/redo 
+		# operations.
+		#
+		def add_to_line_history
+			@line.history << @line.text.dup unless @line.text == ""
+		end
+
+		#
+		# Add the current line (<tt>@line.text</tt>) to the editor history.
+		#
+		def add_to_history
+			@history << @line.text.dup unless @line.text == ""
+		end
+
+		# 
+		# Toggle the editor <tt>@mode</tt> to :replace or :insert (default).
+		#
+		def toggle_mode
+			case @mode
+			when :insert then @mode = :replace
+			when :replace then @mode = :insert
+			end
+		end
+
+		#
+		# Overwrite the current line (<tt>@line.text</tt>) 
+		# with <tt>new_line</tt>, and optionally reset the cursor position to
+		# <tt>position</tt>.
+		#
+		def overwrite_line(new_line, position=nil)
+			pos = position || new_line.length
+			text = @line.text
+			putc ?\r
+			raw_print @line.prompt
+			raw_print new_line
+			n = text.length-new_line.length+1
+			if n > 0
+				n.times { putc ?\s } 
+				n.times { putc ?\b }
+			end
+			@line.position = new_line.length
+			move_to_position(pos)		
+			@line.text = new_line
+		end
+
+		# 
+		# Move the cursor to <tt>pos</tt>.
+		#
+		def move_to_position(pos)
+			n = pos-@line.position
+			case
+			when n > 0 then
+				n.times { move_right }
+			when n < 0 then
+				n.abs.times {move_left}
+			when n == 0 then
+			end	
+		end
+
+		private
+
+		def select_characters_from_cursor(offset=0)
+			select_characters(:right, @line.length-@line.position, offset)
+		end
+
+		def raw_print(string)
+			string.each_byte { |c| @output.putc c }
+		end
+
+		def generic_history_back(history)
+			unless history.empty?
+				history.back
+				line = history.get
+				overwrite_line(line)
+			end
+		end
+
+		def generic_history_forward(history)
+			if history.forward then
+				overwrite_line(history.get)
+			end
+		end		
+
+		def select_characters(direction, n, offset=0)
+			if direction == :right then
+				@line.text[@line.position+offset..@line.position+offset+n]
+			elsif direction == :left then
+				@line.text[@line.position-offset-n..@line.position-offset]
+			end
+		end
+
+		def set_default_keys		
+			bind(:return) { newline }
+			bind(:tab) { complete }
+			bind(:backspace) { delete_left_character }
+			bind(:ctrl_k) { clear_line }
+			bind(:ctrl_z) { undo }
+			bind(:ctrl_y) { self.redo }
+			bind(:left_arrow) { move_left }
+			bind(:right_arrow) { move_right }
+			bind(:up_arrow) { history_back }
+			bind(:down_arrow) { history_forward }
+			bind(:delete) { delete_character }
+			bind(:insert) { toggle_mode }
+		end
+
+	end
+end
+
+

data/lib/inline/history_buffer.rb

@@ -0,0 +1,130 @@
+#!/usr/local/bin/ruby -w
+
+#
+#	history_buffer.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+#
+#
+module InLine
+
+	# 
+	# The HistoryBuffer class is used to hold the editor and line histories, as well
+	# as word completion matches.
+	#
+	class HistoryBuffer < Array
+
+		attr_reader :position, :size
+		attr_accessor :duplicates, :exclude, :cycle
+
+		undef <<
+
+		#
+		# Create an instance of InLine::HistoryBuffer. 
+		# This method takes an optional block used to override the 
+		# following instance attributes:
+		# * <tt>@duplicates</tt> - whether or not duplicate items will be stored in the
+		# buffer.
+		# * <tt>@exclude</tt> - a Proc object defining exclusion rules to prevent items
+		# from being added to the buffer.
+		# * <tt>@cycle</tt> - Whether or not the buffer is cyclic.
+		#
+		def initialize(size)
+			@duplicates = true
+			@exclude = lambda { nil }
+			@cycle = false
+			yield self if block_given?
+			@size = size
+			@position = nil
+		end
+
+		#
+		# Resize the buffer, resetting <tt>@position</tt> to nil.
+		#
+		def resize(new_size)
+			if new_size < @size
+				@size-new_size.times { pop }
+			end
+			@size = new_size
+			@position = nil 
+		end
+		
+		# 
+		# Clear the content of the buffer and reset <tt>@position</tt> to nil.
+		#
+		def empty
+			@position = nil 
+			clear
+		end
+
+		# 
+		# Retrieve the element at <tt>@position</tt>.
+		#
+		def get
+			return nil unless length > 0
+			@position = length-1 unless @position
+			at @position
+		end
+
+		# 
+		# Return true if <tt>@position</tt> is at the end of the buffer.
+		#
+		def end?
+			@position == length-1
+		end
+
+		# 
+		# Return true if <tt>@position</tt> is at the start of the buffer.
+		#
+		def start?
+			@position == 0
+		end
+
+		#
+		# Decrement <tt>@position</tt>.
+		#
+		def back
+			return nil unless length > 0
+			case @position
+			when nil: @position = length-1
+			when 0: @position = length-1 if @cycle
+			else @position -= 1
+			end
+		end
+
+		#
+		# Increment <tt>@position</tt>.
+		#
+		def forward
+			return nil unless length > 0
+			case @position
+			when nil: @position = length-1
+			when length-1: @position = 0 if @cycle
+			else @position += 1
+			end
+		end
+
+		# 
+		# Add a new item to the buffer.
+		#
+		def <<(item)
+			delete(item) unless @duplicates
+			unless @exclude.call(item)
+				# Remove the oldest element if size is exceeded
+				if @size <= length
+					reverse!.pop 
+					reverse!
+				end
+				# Add the new item and reset the position
+				push(item)
+				@position = nil 
+			end
+		end
+
+	end
+
+end

data/lib/inline/line.rb

@@ -0,0 +1,158 @@
+#!/usr/local/bin/ruby -w
+
+#
+#	line.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+
+module InLine
+	
+	# 
+	# The Line class is used to represent the current line being processed and edited
+	# by InLine::Editor. It keeps track of the characters typed, the cursor position, 
+	# the current word and maintains an internal history to allow undos and redos.
+	#
+	class Line
+
+		attr_accessor :text, :position, :history, :prompt, :history_size, :word_separator
+		attr_reader :offset
+
+		include HighLine::SystemExtensions
+
+		# 
+		# Create an instance of InLine::Line.
+		# This method takes an optional block used to override the 
+		# following instance attributes:
+		# * <tt>@text</tt> - the line text.
+		# * <tt>@history_size</tt> - the size of the line history buffer.
+		# * <tt>@position</tt> - the current cursor position within the line.
+		# * <tt>@prompt</tt> - a prompt to prepend to the line text.
+		#
+		def initialize(history_size)
+			@text = ""
+			@history_size = history_size
+			@position = 0
+			@prompt = ""
+			@word_separator = ' '
+			yield self if block_given?
+			@words = []
+			@history = InLine::HistoryBuffer.new(@history_size)
+			@history << "" # Add empty line for complete undo...
+			@offset = @prompt.length
+		end
+
+		# 
+		# Return the maximum line length. By default, it corresponds to the terminal's 
+		# width minus the length of the line prompt.
+		#
+		def max_length
+			terminal_size[0]-@offset
+		end
+
+		# 
+		# Return information about the current word, as a Hash composed by the following
+		# elements:
+		# * <tt>:start</tt>: The position in the line corresponding to the word start
+		# * <tt>:end</tt>: The position in the line corresponding to the word end
+		# * <tt>:text</tt>: The word text.
+		def word
+			last = @text.index(@word_separator, @position)
+			first = @text.rindex(@word_separator, @position)
+			# Trim word separators and handle EOL and BOL
+			if first: first +=1 
+			else first = bol
+			end
+			if last: last -=1 
+			else last = eol+1 unless last
+			end
+			# Swap if overlapping
+			last, first = first, last if last < first
+			text = @text[first..last]
+			# Repeat the search if within word separator
+			if text.match @word_separator then
+				last = first
+				first = @text.rindex(@word_separator, first)
+			 	if first then first+=1
+				else first =	bol 
+				end
+				text = @text[first..last]
+			end
+			{:start => first, :end => last, :text => text}
+		end
+
+		# 
+		# Return the position corresponding to the beginning of the line.
+		#
+		def bol
+		 0	
+		end
+
+		# 
+		# Return true if the cursor is at the beginning of the line.
+		#
+		def bol?
+			@position<=bol
+		end
+		
+		# 
+		# Return the position corresponding to the end of the line.
+		#
+		def eol
+			@text.length-1
+		end
+
+		# 
+		# Return true if the cursor is at the end of the line.
+		#
+		def eol?
+			@position>=eol
+		end
+
+		# 
+		# Decrement the line position by <tt>offset</tt>
+		#
+		def left(offset=1)
+			@position = (@position-offset <= 0) ? 0 : @position-offset
+		end
+
+		# 
+		# Increment the line position by <tt>offset</tt>
+		#
+		def right(offset=1)
+			@position = (@position+offset >= max_length) ? max_length : @position+offset
+		end
+
+		# 
+		# Add a character (expressed as a character code) to the line text.
+		#
+		def <<(char)
+			@text << char.chr
+		end
+
+		#
+		# Access the line text at <tt>@index</tt>
+		#
+		def [](index)
+			@text[index]
+		end
+
+		#
+		#  Modify the character(s) in the line text at <tt>@index</tt>
+		#
+		def []=(index, chars)
+			@text[index] = chars
+		end
+
+		#
+		# Return the length of the line text.
+		#
+		def length
+			@text.length
+		end
+
+	end
+end

data/lib/inline/terminal.rb

@@ -0,0 +1,87 @@
+#!/usr/local/bin/ruby -w
+
+#
+#	terminal.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+#
+#
+module InLine
+	
+	# 
+	# The Terminal class defines character codes and code sequences which can be
+	# bound to actions by editors.
+	# An OS-dependent subclass of InLine::Terminal is automatically instantiated by
+	# InLine::Editor.
+	#
+	class Terminal
+
+		include HighLine::SystemExtensions
+
+		attr_accessor :escape_codes
+		attr_reader :keys, :escape_sequences
+
+		# 
+		# Create an instance of InLine::Terminal.
+		#
+		def initialize
+			@keys = 
+				{
+				:tab => [?\t],
+				:return => [?\r],
+				:newline => [?\n],
+				:escape => [?\e],
+
+				: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]
+				}
+			@escape_codes = []
+			@escape_sequences = []
+			update
+		end
+
+		#
+		# Update the terminal escape sequences. This method is called automatically
+		# by InLine::Editor#bind().
+		#
+		def update
+			@keys.each_value do |k|
+				l = k.length
+				if  l > 1 then
+					@escape_sequences << k unless @escape_sequences.include? k
+				end
+			end
+		end
+
+	end
+
+
+end

data/lib/inline/terminal/vt220_terminal.rb

@@ -0,0 +1,66 @@
+#!/usr/local/bin/ruby -w
+
+#
+#	vt220_terminal.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+
+module InLine
+	
+	# 
+	# This class is used to define all the most common character codes and
+	# escape sequences used on *nix systems.
+	#
+	class VT220Terminal < Terminal
+
+		def initialize
+			super
+			@escape_codes = [?\e]
+			@keys.merge!(
+				{
+					:up_arrow => [?\e, ?[, ?A],
+					:down_arrow => [?\e, ?[, ?B],
+					:right_arrow => [?\e, ?[, ?C],
+					:left_arrow => [?\e, ?[, ?D],
+					:insert => [?\e, ?[, ?2, ?~],
+					:delete => [?\e, ?[, ?3, ?~],
+					:backspace => [?\C-?],
+					:enter => [?\n],
+
+					:ctrl_alt_a => [?\e, ?\C-a],
+					:ctrl_alt_b => [?\e, ?\C-b],
+					:ctrl_alt_c => [?\e, ?\C-c],
+					:ctrl_alt_d => [?\e, ?\C-d],
+					:ctrl_alt_e => [?\e, ?\C-e],
+					:ctrl_alt_f => [?\e, ?\C-f],
+					:ctrl_alt_g => [?\e, ?\C-g],
+					:ctrl_alt_h => [?\e, ?\C-h],
+					:ctrl_alt_i => [?\e, ?\C-i],
+					:ctrl_alt_j => [?\e, ?\C-j],
+					:ctrl_alt_k => [?\e, ?\C-k],
+					:ctrl_alt_l => [?\e, ?\C-l],
+					:ctrl_alt_m => [?\e, ?\C-m],
+					:ctrl_alt_n => [?\e, ?\C-n],
+					:ctrl_alt_o => [?\e, ?\C-o],
+					:ctrl_alt_p => [?\e, ?\C-p],
+					:ctrl_alt_q => [?\e, ?\C-q],
+					:ctrl_alt_r => [?\e, ?\C-r],
+					:ctrl_alt_s => [?\e, ?\C-s],
+					:ctrl_alt_t => [?\e, ?\C-t],
+					:ctrl_alt_u => [?\e, ?\C-u],
+					:ctrl_alt_v => [?\e, ?\C-v],
+					:ctrl_alt_w => [?\e, ?\C-w],
+					:ctrl_alt_x => [?\e, ?\C-x],
+					:ctrl_alt_y => [?\e, ?\C-y],
+					:ctrl_alt_z => [?\e, ?\C-z]			
+				})
+		end
+
+	end
+
+
+end

data/lib/inline/terminal/windows_terminal.rb

@@ -0,0 +1,66 @@
+#!/usr/local/bin/ruby -w
+
+#
+#	windows_terminal.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+
+module InLine
+	
+	# 
+	# This class is used to define all the most common character codes and
+	# escape sequences used on Windows systems.
+	#
+	class WindowsTerminal < Terminal
+
+		def initialize
+			super
+			@escape_codes = [0, 224]
+			@keys.merge!(
+				{
+					:left_arrow => [224, 75],
+					:right_arrow => [224, 77],
+					:up_arrow => [224, 72],
+					:down_arrow => [224, 80],
+					:insert => [224, 82],
+					:delete => [224, 83],
+					:backspace => [8],
+					:enter => [13],
+					
+					:ctrl_alt_a => [0, 30],
+					:ctrl_alt_b => [0, 48],
+					:ctrl_alt_c => [0, 46],
+					:ctrl_alt_d => [0, 32],
+					:ctrl_alt_e => [0, 63],
+					:ctrl_alt_f => [0, 33],
+					:ctrl_alt_g => [0, 34],
+					:ctrl_alt_h => [0, 35],
+					:ctrl_alt_i => [0, 23],
+					:ctrl_alt_j => [0, 36],
+					:ctrl_alt_k => [0, 37],
+					:ctrl_alt_l => [0, 26],
+					:ctrl_alt_m => [0, 32],
+					:ctrl_alt_n => [0, 31],
+					:ctrl_alt_o => [0, 24],
+					:ctrl_alt_p => [0, 25],
+					:ctrl_alt_q => [0, 16],
+					:ctrl_alt_r => [0, 19],
+					:ctrl_alt_s => [0, 31],
+					:ctrl_alt_t => [0, 20],
+					:ctrl_alt_u => [0, 22],
+					:ctrl_alt_v => [0, 47],
+					:ctrl_alt_w => [0, 17],
+					:ctrl_alt_x => [0, 45],
+					:ctrl_alt_y => [0, 21],
+					:ctrl_alt_z => [0, 44]
+				})
+		end
+
+	end
+
+
+end

data/test/test_all.rb

@@ -0,0 +1,9 @@
+#!/usr/local/bin/ruby -w
+
+module InLine
+	TEST_HOME = File.dirname(File.expand_path(__FILE__))+'/..' unless const_defined?(:TEST_HOME)
+end
+
+require "test_history_buffer"
+require "test_line"
+require "test_editor"

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: inline
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2008-03-15 00:00:00 +01:00
+summary: A library for definign custom key bindings and perform line editing operations
+require_paths: 
+- lib
+email: h3rald@h3rald.com
+homepage: http://rubyforge.org/projects/inline
+rubyforge_project: inline
+description: InLine can be used to define custom key bindings, perform common line editing operations, manage command history and define custom command completion rules.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Fabio Cevasco
+files: 
+- lib/inline
+- lib/inline/editor.rb
+- lib/inline/history_buffer.rb
+- lib/inline/line.rb
+- lib/inline/terminal
+- lib/inline/terminal/vt220_terminal.rb
+- lib/inline/terminal/windows_terminal.rb
+- lib/inline/terminal.rb
+- lib/inline.rb
+- README
+- LICENSE
+- CHANGELOG
+test_files: 
+- test/test_all.rb
+rdoc_options: 
+- --main
+- README
+- --exclude
+- test
+extra_rdoc_files: 
+- README
+- LICENSE
+- CHANGELOG
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: highline
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: