rcommand 0.1.1 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,8 @@
+== RCommand 0.2.0
+ * RCommand now uses several different methods of dealing with i/o.
+ * Added readline support.
+ * Redesigned the API.
+ * Fixed readchar method so that it no longer constantly makes system calls.
 == RCommand 0.1.1
  * Fixed gets method so that it correctly returns "\n" on the end of strings.
 == RCommand 0.1.0

data/README

@@ -1,42 +1,15 @@
 RCommand is a generic way for ruby scripts to present a full-featured
 command interface to users, complete with command history and tab completion.
 
-== Example
-  require 'rcommand'
+RCommand can use several different methods of input and output.  If standard
+input and output are used, RCommand will attempt to use the readline library.
+The i/o method to be used can be manually overridden if necessary.
 
-  command_line = RCommand.new(STDIN, STDOUT)
-  command_line.for_prompt do
-    command_line.io_write.print("#{command_line.history.size}:> ")
-  end
-  
-  # Default events shown here in full, for demonstration purposes.  Omitting
-  # them will give the same behavior.
-  command_line.on_single_tab do |partial|
-    matches = RCommand.matches(partial, command_line.history)
-    common_prefix = RCommand.common_prefix(matches)
-    common_prefix.nil? ? partial : common_prefix
-  end
-  command_line.on_double_tab do |partial|
-    matches = RCommand.matches(partial, command_line.history)
-    if matches.size > 1
-      command_line.io_write.puts()
-      for match in matches.uniq
-        command_line.io_write.puts(match)
-      end
-      command_line.prompt()
-      command_line.io_write.print(partial)
-    end
-    partial
-  end
-  command_line.on_key_up do |partial|
-    command_line.prev()
-  end
-  command_line.on_key_down do |partial|
-    command_line.next()
-  end
+== Example
+  command_line = RCommand.new($stdin, $stdout)
 
   loop do
-    command_line.prompt()
-    result = command_line.gets()
+    command_line.prompt = "#{command_line.history.size}:> "
+    result = command_line.readline()
     command_line.io_write.print("Example command: #{result}")
   end

data/lib/rcommand.rb

@@ -21,10 +21,11 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-RCOMMAND_VERSION = "0.1.1"
-
 $:.unshift(File.dirname(__FILE__))
 
+require 'rcommand/version'
+require 'rcommand/io_methods'
+
 # RCommand is a generic way for ruby scripts to present a full-featured
 # command interface to users with command history and tab completion.
 class RCommand
@@ -72,19 +73,27 @@ class RCommand
     unless io_write.kind_of? IO
       raise "Expecting object of type IO, got #{io_write.class.name}."
     end
+    
     @io_read = io_read
     @io_write = io_write
+    @io_method = nil
+    
     @history = []
     @history_index = nil
-    @tab_count = 0
-    @prompt_proc = nil
-    @single_tab_proc = lambda do |partial|
-      matches = RCommand.matches(partial, self.history)
+    
+    @procs = {}
+    @procs[:completion] = lambda do |partial|
+      RCommand.matches(partial, (self.history.collect do |line|
+        line.split(' ')
+      end).flatten.uniq)
+    end
+    @procs[:single_tab] = lambda do |partial|
+      matches = self.completions_for(partial)
       common_prefix = RCommand.common_prefix(matches)
       common_prefix.nil? ? partial : common_prefix
     end
-    @double_tab_proc = lambda do |partial|
-      matches = RCommand.matches(partial, self.history)
+    @procs[:double_tab] = lambda do |partial|
+      matches = self.completions_for(partial)
       if matches.size > 1
         self.io_write.puts()
         for match in matches.uniq
@@ -95,38 +104,51 @@ class RCommand
       end
       partial
     end
-    @key_up_proc = lambda do |partial|
+    @procs[:key_up] = lambda do |partial|
       self.prev()
     end
-    @key_down_proc = lambda do |partial|
+    @procs[:key_down] = lambda do |partial|
       self.next()
     end
-    @key_left_proc = nil
-    @key_right_proc = nil
-    @interupt_proc = lambda do
+    @procs[:key_left] = nil
+    @procs[:key_left] = nil
+    @procs[:interupt] = lambda do
       self.io_write.print("\n")
       system("stty sane")
       exit
     end
+    
+    initialize_io_method()
   end
   
   attr_reader :io_read
   attr_reader :io_write
+  attr_accessor :io_method
+  
+  attr_reader :procs
+  
   attr_reader :history
   attr_accessor :history_index
-
-  def for_prompt(&block); @prompt_proc = block; end
-  def on_single_tab(&block); @single_tab_proc = block; end
-  def on_double_tab(&block); @double_tab_proc = block; end
-  def on_key_up(&block); @key_up_proc = block; end
-  def on_key_down(&block); @key_down_proc = block; end
-  def on_key_left(&block); @key_left_proc = block; end
-  def on_key_right(&block); @key_right_proc = block; end
-  def on_interupt(&block); @interupt_proc = block; end
   
-  # Displays the prompt, if any.
-  def prompt()
-    @prompt_proc.call() unless @prompt_proc.nil?
+  attr_accessor :prompt
+
+  def on_completion(&block); @procs[:completion] = block; end
+  def on_single_tab(&block); @procs[:single_tab] = block; end
+  def on_double_tab(&block); @procs[:double_tab] = block; end
+  def on_key_up(&block); @procs[:key_up] = block; end
+  def on_key_down(&block); @procs[:key_down] = block; end
+  def on_key_left(&block); @procs[:key_left] = block; end
+  def on_key_right(&block); @procs[:key_right] = block; end
+  def on_interupt(&block); @procs[:interupt] = block; end
+    
+  # Returns an array of completions for the given partial command.  This
+  # method tries to use the <tt>on_completion</tt> block if available.
+  def completions_for(partial)
+    if @procs[:completion] != nil
+      return @procs[:completion].call(partial)
+    else
+      return RCommand.matches(partial, self.history)
+    end
   end
   
   # Sets the command line to the previous command.
@@ -159,129 +181,39 @@ class RCommand
   def <<(command)
     command = command[0..-1] if command[-1] == "\n"
     command = command[0..-1] if command[-1] == "\r"
-    if @history[-1] == ""
-      @history.pop()
+    unless command.empty?
+      self.history.pop() if self.history[-1] == ""
+      self.history << command
     end
-    @history << command if command != ""
-    @history_index = nil
+    self.history_index = nil
   end
   
   # Returns the command string entered by the user.
-  def gets()
-    command = ""
-    char = nil
-    loop do
-      char = getc()
-      next if char.nil?
-      next if char == 0
-      if char != 9
-        @tab_count = 0
-      end
-      if char == 3
-        @interupt_proc.call() unless @interupt_proc.nil?
-      elsif char == 10
-        @io_write.print("\n")
-        self << command
-        break
-      elsif char == 9
-        @tab_count += 1
-        replacement = nil
-        if @tab_count == 1
-          unless @single_tab_proc.nil?
-            replacement =
-              @single_tab_proc.call(command)
-          end
-        elsif @tab_count > 1
-          unless @double_tab_proc.nil?
-            replacement =
-              @double_tab_proc.call(command)
-          end
-        end
-        if replacement != nil && replacement.size > command.size
-          @io_write.print(
-            8.chr * command.size +
-            " " * command.size +
-            8.chr * command.size)
-          @io_write.print(replacement)
-          command = replacement
-        end
-      elsif char == 8 || char == 127
-        if command.size > 0
-          command = command[0..-2]
-          @io_write.print(8.chr + " " + 8.chr)
-        end
-      else
-        command << char.chr
-        replacement = nil
-        if command.index("\e[A") != nil
-          command.gsub!("\e[A", "")
-          unless @key_up_proc.nil?
-            replacement =
-              @key_up_proc.call(command)
-          end
-        elsif command.index("\e[B") != nil
-          command.gsub!("\e[B", "")
-          unless @key_down_proc.nil?
-            replacement =
-              @key_down_proc.call(command)
-          end
-        elsif command.index("\e[C") != nil
-          command.gsub!("\e[C", "")
-          unless @key_right_proc.nil?
-            replacement =
-              @key_right_proc.call(command)
-          end
-        elsif command.index("\e[D") != nil
-          command.gsub!("\e[D", "")
-          unless @key_left_proc.nil?
-            replacement =
-              @key_left_proc.call(command)
-          end
-        else
-          if (char == "["[0] && command[-2] != "\e"[0]) ||
-              (char != "\e"[0] && char != "["[0])
-            @io_write.print(char.chr)
-          end
-        end
-        if replacement != nil
-          @io_write.print(
-            8.chr * command.size +
-            " " * command.size +
-            8.chr * command.size)
-          @io_write.print(replacement)
-          command = replacement
-        end
-      end
-    end
-    return command + "\n"
+  def readline()
+    line = self.io_method.readline()
+    line = line[0..-1] if line[-1] == "\n"
+    line = line[0..-1] if line[-1] == "\r"
+    self << line
+    return line + "\n"
   end
-  
+
 private
-  # Returns a single character without waiting for the enter key to be
-  # pressed.
-  def getc()
-    char = nil
-    begin
-      if @io_read == STDIN
-        if RUBY_PLATFORM =~ /mswin/
-          require "Win32API"
-          char = Win32API.new("crtdll", "_getch", [], "L").Call
-        else
-          begin
-            system("stty cbreak -echo")
-            char = @io_read.readchar()
-          ensure
-            system("stty -cbreak -echo")
-          end
-        end
+  # Selects the appropriate input/output method.
+  def initialize_io_method()
+    self.io_method = nil
+    if self.io_read.object_id == $stdin.object_id &&
+        self.io_write.object_id == $stdout.object_id
+      if defined?(RCommand::ReadlineIOMethod)
+        self.io_method = RCommand::ReadlineIOMethod.new(self)
       else
-        char = @io_read.readchar()
+        self.io_method = RCommand::StandardIOMethod.new(self)
       end
-    rescue Interrupt
-      return 3
-    rescue Exception
-      return nil
+    elsif defined?(TCPSocket) && self.io_read.kind_of?(TCPSocket)
+      self.io_method = RCommand::RawIOMethod.new(self)
+    elsif defined?(File) && self.io_read.kind_of?(File)
+      self.io_method = RCommand::RawIOMethod.new(self)
+    else
+      self.io_method = RCommand::StandardIOMethod.new(self)
     end
-    return char
   end
 end

data/lib/rcommand/io_methods.rb

@@ -0,0 +1,252 @@
+#--
+# Copyright (c) 2005 Robert Aman
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+class RCommand
+  class IOMethod
+    def initialize(command_line)
+      @command_line = command_line
+    end
+    
+    def readline
+      raise NotImplementedError,
+        "readline not implemented in #{self.class.name}."
+    end
+
+    def eof?
+      raise NotImplementedError,
+        "eof? not implemented in #{self.class.name}."
+    end
+  end
+  
+  class RawIOMethod < IOMethod
+    def initialize(command_line)
+      super(command_line)
+    end
+        
+    def readline
+      if @command_line.prompt != nil && @command_line.io_write != nil
+        @command_line.io_write.print(@command_line.prompt)
+      end
+
+      line = @command_line.io_read.gets()
+      line = line[0..-1] if line[-1] == "\n"
+      line = line[0..-1] if line[-1] == "\r"
+      return line + "\n"
+    end
+    
+    def eof?
+      begin
+        require 'timeout'
+        Timeout.timeout(0.01) do
+          return $stdin.eof?
+        end
+      rescue LoadError
+        return $stdin.eof?
+      rescue Timeout::Error
+        return true
+      end
+    end
+  end
+  
+  class StandardIOMethod < IOMethod
+    def initialize(command_line)
+      super(command_line)
+      @stty_set = false
+      @tab_count = 0
+    end
+    
+    def readline
+      if @command_line.prompt != nil && @command_line.io_write != nil
+        @command_line.io_write.print(@command_line.prompt)
+      end
+      
+      # RESTORE THIS CODE!
+      command = ""
+      char = nil
+      loop do
+        char = self.readchar()
+        next if char.nil?
+        next if char == 0
+        if char != 9
+          @tab_count = 0
+        end
+        if char == 3
+          raise Interrupt
+        elsif char == 10
+          @command_line.io_write.print("\n")
+          self << command
+          break
+        elsif char == 9
+          @tab_count += 1
+          replacement = nil
+          if @tab_count == 1
+            unless @command_line.procs[:single_tab].nil?
+              replacement = @command_line.procs[:single_tab].call(command)
+            end
+          elsif @tab_count > 1
+            unless @command_line.procs[:double_tab].nil?
+              replacement = @command_line.procs[:double_tab].call(command)
+            end
+          end
+          if replacement != nil && replacement.size > command.size
+            @command_line.io_write.print(
+              8.chr * command.size +
+              " " * command.size +
+              8.chr * command.size)
+            @command_line.io_write.print(replacement)
+            command = replacement
+          end
+        elsif char == 8 || char == 127
+          if command.size > 0
+            command = command[0..-2]
+            @command_line.io_write.print(8.chr + " " + 8.chr)
+          end
+        else
+          command << char.chr
+          replacement = nil
+          if command.index("\e[A") != nil
+            command.gsub!("\e[A", "")
+            unless @command_line.procs[:key_up].nil?
+              replacement = @command_line.procs[:key_up].call(command)
+            end
+          elsif command.index("\e[B") != nil
+            command.gsub!("\e[B", "")
+            unless @command_line.procs[:key_down].nil?
+              replacement = @command_line.procs[:key_down].call(command)
+            end
+          elsif command.index("\e[C") != nil
+            command.gsub!("\e[C", "")
+            unless @command_line.procs[:key_right].nil?
+              replacement = @command_line.procs[:key_right].call(command)
+            end
+          elsif command.index("\e[D") != nil
+            command.gsub!("\e[D", "")
+            unless @command_line.procs[:key_left].nil?
+              replacement = @command_line.procs[:key_left].call(command)
+            end
+          else
+            if (char == "["[0] && command[-2] != "\e"[0]) ||
+                (char != "\e"[0] && char != "["[0])
+              @command_line.io_write.print(char.chr)
+            end
+          end
+          if replacement != nil
+            @command_line.io_write.print(
+              8.chr * command.size +
+              " " * command.size +
+              8.chr * command.size)
+            @command_line.io_write.print(replacement)
+            command = replacement
+          end
+        end
+      end
+      return command + "\n"
+    end
+    
+    def readchar
+      char = nil
+      begin
+        if @command_line.io_read.object_id == $stdin.object_id
+          if RUBY_PLATFORM =~ /mswin/
+            require "Win32API"
+            char = Win32API.new("crtdll", "_getch", [], "L").Call
+          else
+            begin
+              if @stty_set != true
+                system("stty cbreak -echo")
+                @stty_set = true
+              end
+              char = @command_line.io_read.readchar()
+            ensure
+              if @stty_set != true
+                system("stty -cbreak -echo")
+                @stty_set = true
+              end
+            end
+          end
+        else
+          char = @command_line.io_read.readchar()
+        end
+      rescue Interrupt
+        return 3
+      rescue Exception
+        return nil
+      end
+      return char
+    end
+    private :getc
+    
+    def eof?
+      begin
+        require 'timeout'
+        Timeout.timeout(0.01) do
+          return $stdin.eof?
+        end
+      rescue LoadError
+        return $stdin.eof?
+      rescue Timeout::Error
+        return true
+      end
+    end
+  end
+  
+  begin
+    require "readline"
+  
+    class ReadlineIOMethod < IOMethod
+      def initialize(command_line)
+        super(command_line)
+      
+        # Initialize Readline here somehow.
+        if Readline.respond_to?("basic_word_break_characters=")
+          Readline.basic_word_break_characters = " \t\n\"\\'`><=;|&{("
+        end
+        Readline.completion_append_character = nil
+        Readline.completion_proc = lambda do |partial|
+          command_line.completions_for(partial)
+        end
+        Readline::HISTORY.push("") if self.history.empty?
+      
+        @eof = false
+      end
+    
+      def history
+        return Readline::HISTORY.to_a
+      end
+    
+      def readline
+        if line = Readline.readline(@command_line.prompt)
+          Readline::HISTORY.push(line) unless line.empty?
+        else
+          @eof = true
+        end
+        return line
+      end
+    
+      def eof?
+        return @eof
+      end
+    end
+  rescue LoadError
+  end
+end

data/lib/rcommand/version.rb

@@ -0,0 +1,9 @@
+class RCommand
+  module RCOMMAND_VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/rakefile

@@ -6,8 +6,10 @@ require 'rake/packagetask'
 require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
 
+require File.join(File.dirname(__FILE__), 'lib/rcommand', 'version')
+
 PKG_NAME      = 'rcommand'
-PKG_VERSION   = '0.1.1'
+PKG_VERSION   = RCommand::RCOMMAND_VERSION::STRING
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: rcommand
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2006-04-02 00:00:00 -05:00
+  version: 0.2.0
+date: 2006-04-24 00:00:00 -04:00
 summary: Command handler.
 require_paths: 
   - lib
@@ -33,7 +33,10 @@ files:
   - install.rb
   - README
   - CHANGELOG
+  - lib/rcommand
   - lib/rcommand.rb
+  - lib/rcommand/io_methods.rb
+  - lib/rcommand/version.rb
   - test/command_test.rb
 test_files: []
 rdoc_options: