parley 0.1.0 → 0.2.0

data/README.md

@@ -15,15 +15,116 @@ See http://www.nist.gov/el/msid/expect.cfm for references to the original Expect
 
 See http://search.cpan.org/~rgiersig/Expect-1.21/Expect.pod for information on Expect.pm
 
-Known Issues
-------------
+= Parley 
+An expect-like module for Ruby modled after Perl's Expect.pm
 
+Parley is a module that can be used with any class, like PTY, IO or
+StringIO that responds_to?() :eof?, and either :read_nonblock(maxread)
+or :getc.
+
+If the class also responds to :select, then Parley will be able to wait
+for additional input to arrive.
+
+== parley method arguments
+
+The parley() method is called with two arguments:
+
+* a timeout in seconds, which may be zero to indicate no timeout
+* an array of arrays, each array contains a pattern and an action.
+
+Each pattern is either:
+
+* a RegExp to match input data
+* the symbol :timeout to match the timeout condition from select()
+* the symbol :eof to match the eof?() condition
+
+If an action responds_to?(:call), such as a lambda{|m| code}
+then the action is called with MatchData as an argument.
+In the case of :timeout or :eof, MatchData is from matching:
+ input_buffer =~ /.*/
+
+== Examples of Usage
+
+=== Standard ruby expect vs. equivalent parley usage
+Standard Ruby expect:
+  require 'expect'
+
+  ...
+  input.expect(/pattern/, 10) {|matchdata| code}
+
+Parley:
+  require 'parley'
+
+  ...
+  input.parley(10, [[/pattern/, lambda{|matchdata| code}]])
+
+=== Telnet login using /usr/bin/telnet
+ require 'parley'
+ input, output, process_id = PTY.spawn("/usr/bin/telnet localhost")
+ output.puts '' # hit return to make sure we get some output
+ result = input.parley(30, [  # allow 30 seconds to login
+   [ /ogin:/, lambda{|m| output.puts 'username'; :continue} ],
+   [ /ssword:/, lambda{|m| output.puts 'my-secret-password'; :continue} ],
+   [ /refused/i, "connection refused" ],
+   [ :timeout, "timed out" ],
+   [ :eof, "command output closed" ],
+   [ /\$/, true ] # some string that only appears in the shell prompt
+   ])
+ if result == true
+   puts "Successful login"
+   output.puts "date" # This is the important command we had to run
+ else
+   puts "Login failed because: #{result}"
+ end
+ # We can keep running commands.
+ input.close
+ output.close
+ id, exit_status = Process.wait2(process_id)
+
+=== Run your telnet script against canned input
+ require 'parley'
+ class StringIO
+   include Parley
+ end
+ input = StringIO.new("login: password: prompt$\n", "r")
+ output = StringIO.new("", "w")
+ output.puts '' # Note: no effect in this example
+ result = input.parley(30, [  # Note: timeout has no effect for StringIO
+   # XXX check these example patterns against need for anchoring with ^ and/or $
+   [ /ogin:/, lambda{|m| output.puts 'username'; :continue} ],
+   [ /ssword:/, lambda{|m| output.puts 'my-secret-password'; :continue} ],
+   [ :timeout, "timed out" ],
+   [ :eof, "command output closed" ],
+   [ /\$/, true ] # some string that only appears in the shell prompt
+   ])
+ if result == true
+   puts "Successful login"
+   output.puts "exit"
+ else
+   puts "Login failed because: #{result}"
+ end
+ input.close
+ output.close
+ id, exit_status = Process.wait2(process_id)
+
+=== Handle a timeout condition
+ require 'parley'
+ read, write, pid = PTY.spawn("ruby -e 'sleep 20'")
+ result = read.parley(5, ["timeout, :timeout])
+ if result == :timeout
+  puts "Program timed-out as expected"
+ else
+  puts "Error, timeout did not happen!"
+ end
+
+== Known Issues
+
+* :reset_timeout from IO::parley() doesn't have the desired effect, it isn't re-establishing the timeout.
 * need to generatate adequte documentation. See test/test_parley.rb for now
-* :restart_timeout from IO::parley() doesn't have the desired effect, it isn't re-establishing the timeout.
+* line oriented reading option
+* Finer grain greediness control beyond read_nonblock(maxlen)
 
-Contributing to parley
-----------------------
- 
+== Contributing to parley
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
 * Fork the project.
@@ -32,8 +133,7 @@ Contributing to parley
 * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
-Copyright
----------
+== Copyright
 
 Copyright (c) 2013 Ben Stoltz.
-See LICENSE.txt for further details.
+See LICENSE.txt for further details.

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/parley.rb

@@ -1,130 +1,143 @@
-#!/usr/bin/ruby
-#
-# = parley.rb - An expect library for Ruby modled after Perl's Expect.pm
-#
+
 require 'pty'
 
-# TODO: line oriented reading option
-# Greediness control
 module Parley
-  # VERSION = '0.1.0'
-
+  # Internal: used to set input data that has been received, but not yet matched
+  #--
   # Initialize() is usually not called or doesn't call super(), so
   # do implicit instance variable initialization
+  #++
   def unused_buf= (v)
     @unused_buf = v
   end
 
+  # holds the remaining input read from +read_nonblock()+ or +getc()+ but not yet used
   def unused_buf
     @unused_buf = nil unless defined? @unused_buf
     @unused_buf
   end
 
-  def parley_verbose= (v)
-    @parley_verbose = (v ? true : false)
+  # Sets/clears verbose mode to aid debugging.
+  #
+  # Debug output is sent to +STDOUT+ unless overridden by +pvout+
+  def parley_verbose= (truth, pvout = STDOUT)
+    @pvout = pvout
+    @parley_verbose = (truth ? true : false)
   end
 
+  # returns +true+ if debug output is enabled, else +false+
   def parley_verbose
     @parley_verbose = false unless defined? @parley_verbose
     @parley_verbose
   end
 
-  def parley_maxread= (v)
-    @parley_maxread = (v > 0) ? v : 1
+  # sets the maximum number of characters to read from +read_nonblock()+
+  def parley_maxread= (max_characters = 1)
+    @parley_maxread = (max_characters > 0) ? max_characters : 1
   end
 
+  # return the maximum number of characters to read from +read_nonblock()+
   def parley_maxread
     @parley_maxread = 1 unless defined? @parley_maxread
     @parley_maxread
   end
 
-  def parley (t_out, *actions)
-    # t_out = nil; # wait forever for next data
-    # t_out = 0; # timeout immediately if no data available
-    # t_out > 0; # timeout after t_out seconds
-    # t_out < 0; # deadline is in the past, same as t_out = 0
-    STDOUT.print "\n------\nparley t_out=#{t_out}\n" if parley_verbose
-    if (t_out == nil)
+  # Match patterns and conditions and take corresponding actions until an action
+  # returns a value not equal to +:continue+ or +:reset_timeout+
+  #
+  # +timeout_seconds+ specifies the amount of time before the +:timeout+ condition
+  # is presented to the pattern/action list.
+  #
+  # If +timeout_seconds+ is less than or equal to zero, then +:timeout+
+  # immediately as soon as there is no more data available.
+  #
+  # XXX bad. output could spew forever and we want to stop by deadline.
+  #
+  # If +timeout_seconds+ is nil, then no +:timeout+ condition will be generated.
+  #
+  # A action returning the value +:reset_timeout+ will +:continue+ and reset
+  # the timeout deadline to a value of +Time.now+ + +timeout_seconds+
+  def parley (timeout_seconds, *actions)
+    @pvout.print "parley,#{__LINE__}: timeout_seconds=#{timeout_seconds}\n" if parley_verbose
+    if (timeout_seconds == nil)
       deadline = nil
     else
-      deadline = Time.now + t_out
+      deadline = Time.now + timeout_seconds
     end
     buf = ''
     unused_buf = '' if not unused_buf
 
-    loop_count = 0
-
-    # STDOUT.puts "class=#{self.class}"
-
-    # Compatible hack. There are changes coming w.r.t. respond_to? for
+    # XXX Compatible hack. There are changes coming w.r.t. respond_to? for
     # protected methods. Just do a simple poll, and see if it works.
     begin
       result = IO.select([self], [], [], 0)
       has_select = true;
     rescue Exception
       has_select = false;
-      # STDOUT.puts "Exception: #{Exception}"
     end
-    # STDOUT.puts "has_select=#{has_select}"
 
     begin
-      loop_count = loop_count + 1
       # If it is possible to wait for data, then wait for data
       t = (deadline ? (deadline - Time.now) : nil)
       t = (t.nil? || t >= 0) ? t : 0
+      # XXX If maxlen > unused_buf.length, then try to get more input?
+      #     Think about above. don't want to use up all of timeout.
       if unused_buf.length == 0 && has_select && !IO.select([self], nil, nil, t)
-        # Timeout condition returns nil
-        STDOUT.print "TIMEOUT=\"#{buf}\"\n" if parley_verbose
+        # Timeout condition from IO.select() returns nil
+        @pvout.print "parley,#{__LINE__}: TIMEOUT buf=\"#{buf}\"\n" if parley_verbose
         timeout_handled = nil
         result = nil
-        result = actions.each do|act|
-          case act[0]
-          when :timeout
+        result = actions.find do|pattern, action|
+          if pattern == :timeout
             timeout_handled = true
-            if act[1].respond_to?(:call)
-              /.*/.match(buf) # get the buffer contents into a Regexp.last_match
-              result = act[1].call(Regexp.last_match)
+            if action.respond_to?(:call)
+              r = action.call(/.*/.match(buf)) # call with entire buffer as a MatchData
             else
-              result = act[1]
+              r = action
             end
-            break result
+            @pvout.print "parley,#{__LINE__}: TIMEOUT Handled=\"#{r}\"\n" if parley_verbose
+            break r
+          else
+            nil
           end
         end
+        @pvout.print "parley,#{__LINE__}: TIMEOUT RESULT=\"#{result}\"\n" if parley_verbose
         if (!timeout_handled)
           # XXX need to prepend buf to @unusedbuf
           unused_buf = buf  # save data for next time
-          raise "timeout" # XXX use TimeoutException
+          raise "timeout"
         end
-        STDOUT.print "TIMEOUT RESULT=\"#{result}\"\n" if parley_verbose
         return result unless result == :reset_timeout
+        matched = true
       else
 
         # We've waited, if that was possible, check for data present
         if unused_buf.length == 0 && eof?
-          STDOUT.print "EOF Buffer=\"#{buf}\"\n" if parley_verbose
-          result = nil
+          @pvout.print "parley,#{__LINE__}: EOF Buffer=\"#{buf}\"\n" if parley_verbose
           eof_handled = false
-          actions.each do |act|
-            case act[0]
+          result = actions.find do |pattern, action|
+            case pattern
             when :eof
               eof_handled = true
-              if act[1].respond_to?(:call)
-                /.*/m.match(buf)  # Game end, match everything remaining
-                result = act[1].call(Regexp.last_match)
+              if action.respond_to?(:call)
+                result = action.call(/.*/m.match(buf))
               else
-                result = act[1]
+                result = action
               end
               break result
+            else
+              nil
             end
           end
-          if not eof_handled
+          unless eof_handled
             # XXX need to prepend buf to @unusedbuf
             unused_buf = buf  # save data for next time
-            raise :eof if not eof_handled
+            raise "End of file"
           end
           return result
         end
 
+        # No timeout and no EOF. There is some input data to look at
         # Greedy read:
         # buf << self.read_nonblock(maxlen)
         if (unused_buf.length > 0)
@@ -140,18 +153,18 @@ module Parley
         result = :continue
         matched = false
         result = actions.each_with_index do |act,i|
-          # STDOUT.print "buf=\"#{buf}\"\tact=#{act[0]}\n" if parley_verbose
+          # @pvout.print "parley,#{__LINE__}: buf=\"#{buf}\"\tact=#{act[0]}\n" if parley_verbose
           m = case act[0]
               when Regexp
-                act[0].match(buf) and Regexp.last_match
+                act[0].match(buf)
               when String
-                act[0] = Regexp.new(act[0]) # caching the regexp conversion, XXX any problem?
-                act[0].match(buf) and Regexp.last_match
+                act[0] = Regexp.new(act[0]) # caching the regexp conversion
+                act[0].match(buf)
               else
                 nil
               end
           if m
-            STDOUT.print "match[#{i}]=\"#{buf}\"\n" if parley_verbose
+            @pvout.print "parley,#{__LINE__}: match[#{i}]=\"#{buf}\"\n" if parley_verbose
             matched = true
             if act[1]
               if act[1].respond_to?(:call)
@@ -164,7 +177,7 @@ module Parley
             end
             buf = ''  # consume the buffer (XXX only the part that matched?)
             # XXX if the regex had post context, don't consume that.
-            STDOUT.puts "result=#{result}" if parley_verbose
+            @pvout.puts "parley,#{__LINE__}: result=#{result}" if parley_verbose
             break result
           end
           result
@@ -172,25 +185,28 @@ module Parley
       end
 
       if matched == true
+        @pvout.puts "parley,#{__LINE__}: MATCH, result=#{result}" if parley_verbose
         result = case result
                  when :continue
                    :continue
                  when nil  # explicit end
                    break nil
                  when :reset_timeout
-                   deadline = Time.now + t_out # XXX vs deadline in lambda closure?
-                   STDOUT.puts "deadline=#{deadline.to_s}, continue" if parley_verbose
+                   deadline = Time.now + timeout_seconds # XXX vs deadline in lambda closure?
+                   @pvout.puts "parley,#{__LINE__}: deadline=#{deadline.to_s}, continue" if parley_verbose
                    :continue
                  else  # return with result
                    break result
                  end
       else
+        @pvout.puts "parley,#{__LINE__}: no match, implicit :continue, buf=#{buf}" if parley_verbose
         result = :continue
       end
     end while result == :continue
   end
 end
 
+# Including the Parley module will monkey-patch the IO class
 class IO
   include Parley
 end

data/parley.gemspec

@@ -5,24 +5,22 @@
 
 Gem::Specification.new do |s|
   s.name = "parley"
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben Stoltz"]
-  s.date = "2013-02-15"
+  s.date = "2013-02-28"
   s.description = "An expect-like gem, modeled after Perl's Expect.pm"
   s.email = "stoltz@lzrd.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.md",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
     "Gemfile",
     "LICENSE.txt",
     "README.md",
-    "README.rdoc",
     "Rakefile",
     "VERSION",
     "lib/parley.rb",
@@ -33,7 +31,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/lzrd/parley"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
+  s.rubygems_version = "1.8.25"
   s.summary = "An expect-like gem, modeled after Perl's Expect.pm"
 
   if s.respond_to? :specification_version then

data/test/test_parley.rb

@@ -1,7 +1,12 @@
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}") if __FILE__ == $0
+
 require 'helper'
 require "test/unit"
 require 'parley'
 require 'stringio'
+require 'open3'
 
 #class TestParley < Test::Unit::TestCase
 #  should "probably rename this file and start testing for real" do
@@ -30,6 +35,16 @@ class TestIO < Test::Unit::TestCase
     assert(result == :timeout, "** ERROR result = #{result}")
   end
 
+  def test_single_match
+    sin = StringIO.new(@text)
+    result = sin.parley(0,
+                        [/apple/, "just apple"],
+                        [/white/, "1 too many matches"],
+                        [/dogs/, "2 too many matches"],
+                        [:eof, "very bad"])
+    assert(result == "just apple", "Invalid result(#{result})")
+  end
+
   def test_eof_constant
     io = File.new("/dev/null", "r")
     result = io.parley(20, [:eof, :eof])
@@ -52,8 +67,8 @@ class TestIO < Test::Unit::TestCase
                        ['three dogs', lambda{|m| count += 1; :continue }],
                        [:eof, lambda{|m| count}] # XXX need to verify unused portion of buffer
                       )
-    assert(count == 2, "** ERROR count = #{count}")
-    assert(result == 2, "** ERROR result = #{result.inspect}")
+                      assert(count == 2, "** ERROR count = #{count}")
+                      assert(result == 2, "** ERROR result = #{result.inspect}")
   end
 
   def test_strings_maxread
@@ -65,8 +80,8 @@ class TestIO < Test::Unit::TestCase
                        ['three dogs', lambda{|m| count += 1; :continue }],
                        [:eof, lambda{|m| count}] # XXX need to verify unused portion of buffer
                       )
-    assert(count == 2, "** ERROR count = #{count}")
-    assert(result == 2, "** ERROR result = #{result.inspect}")
+                      assert(count == 2, "** ERROR count = #{count}")
+                      assert(result == 2, "** ERROR result = #{result.inspect}")
   end
 
   def test_patterns
@@ -77,8 +92,8 @@ class TestIO < Test::Unit::TestCase
                        [Regexp.new(colors.join('|')), lambda{|m| count += 1; :continue}],
                        [:eof, lambda{|m| count}] # XXX need to verify unused portion of buffer
                       )
-    assert(count == 2, "** ERROR count = #{count}")
-    assert(result == 2, "** ERROR result = #{result.inspect}")
+                      assert(count == 2, "** ERROR count = #{count}")
+                      assert(result == 2, "** ERROR result = #{result.inspect}")
   end
 
   #
@@ -95,8 +110,8 @@ class TestIO < Test::Unit::TestCase
                        [Regexp.new(colors.join('|')), lambda{|m| count += 1; :continue}],
                        [:eof, lambda{|m| count}] # XXX need to verify unused portion of buffer
                       )
-    assert(count == 1, "** ERROR count = #{count}")
-    assert(result == 1, "** ERROR result = #{result.inspect}")
+                      assert(count == 1, "** ERROR count = #{count}")
+                      assert(result == 1, "** ERROR result = #{result.inspect}")
   end
 
   #
@@ -133,9 +148,9 @@ class TestIO < Test::Unit::TestCase
     }
     ] # XXX need to verify unused portion of buffer
                       )
-    assert(count == 3, "** ERROR count = #{count}")
-    assert(result == 3, "** ERROR result = #{result.inspect}")
-    # assert(buf_end.length > 0, "** Error buf_end.length=#{buf_end.length}, buf=#{buf_end}")
+                      assert(count == 3, "** ERROR count = #{count}")
+                      assert(result == 3, "** ERROR result = #{result.inspect}")
+                      # assert(buf_end.length > 0, "** Error buf_end.length=#{buf_end.length}, buf=#{buf_end}")
   end
 
   def test_empty_string
@@ -145,7 +160,7 @@ class TestIO < Test::Unit::TestCase
     result = io.parley(0,
                        [Regexp.new(colors.join('|')), lambda{|m| count += 1; :continue}],
                        [:eof, lambda{|m| count}])
-    assert(count == 0, "** ERROR count = #{result.inspect}")
+    assert(count == 0, "** ERROR count = #{count.inspect}")
     assert(result == 0, "** ERROR result = #{result.inspect}")
   end
 
@@ -176,25 +191,25 @@ class TestIO < Test::Unit::TestCase
                  [/> /, lambda {|m| w_f.puts("cd pub/ruby"); nil }]
                 )
 
-      # >
-      #  dir\n
-      r_f.parley(ftp_to, ["> ", lambda {|m| w_f.print "dir\r"}])
+                # >
+                #  dir\n
+                r_f.parley(ftp_to, ["> ", lambda {|m| w_f.print "dir\r"}])
 
-      # lrwxrwxrwx 1 1014 100 27 Feb 18 12:52 ruby-1.8.7-p334.tar.bz2 -> 1.8/ruby-1.8.7-p334.tar.bz2
-      r_f.parley(ftp_to,
-                 [/^ftp> /, lambda {|m|
-        for x in m.pre_match.split("\n")
-          if x =~ /(ruby.*?\.tar\.gz)/ then
-            fnames.push $1
-          end
-        end
-        begin
-          w_f.print "quit\n"
-        rescue
-        end
-        :nil
-      }],
-      [:eof, nil])
+                # lrwxrwxrwx 1 1014 100 27 Feb 18 12:52 ruby-1.8.7-p334.tar.bz2 -> 1.8/ruby-1.8.7-p334.tar.bz2
+                r_f.parley(ftp_to,
+                           [/^ftp> /, lambda {|m|
+                  for x in m.pre_match.split("\n")
+                    if x =~ /(ruby.*?\.tar\.gz)/ then
+                      fnames.push $1
+                    end
+                  end
+                  begin
+                    w_f.print "quit\n"
+                  rescue
+                  end
+                  :nil
+                }],
+                  [:eof, nil])
     end
     puts "The latest ruby interpreter is #{fnames.sort.pop}"
   end
@@ -203,11 +218,110 @@ class TestIO < Test::Unit::TestCase
     read, write, pid = PTY.spawn(
       # XXX fire off a ruby program, not bash, to get the test behavoir we want
       '/bin/bash -x -c "for x in wait done too_late; do sleep 3; echo $x; done"')
-    read.parley_verbose = true if @test_verbose
-    result = read.parley(5,
-                         [/wait/, :reset_timeout],
-                         [/done/, :pass ],
-                         [:timeout, :timeout])
-    assert(result == :pass, "** ERROR result = #{result}")
+      read.parley_verbose = true if @test_verbose
+      result = read.parley(5,
+                           [/wait/, :reset_timeout],
+                           [/done/, :pass ],
+                           [:timeout, :timeout])
+      assert(result == :pass, "** ERROR result = #{result}")
+  end
+
+  def test_guessing_game
+    @NGAMES = 2
+    @UPPER_LIMIT = 100
+    @UPPER_LIMIT_LOG2 = 8
+
+    game = <<-GUESSING_GAME_EOT
+      BEGIN {puts "0>"; @n = 0}
+      END { puts "Goodbye!"; }
+      @secret ||= rand 100
+      g = $F[0] ? $F[0].strip : ""
+      z = "?"
+      if g =~ /\\d+$/m
+        z = (g.to_i <=> @secret)
+        case g.to_i <=> @secret
+        when -1
+          puts "too low"
+        when 1
+          puts "too high"
+        when 0
+          puts "correct!"
+          @secret = rand 100
+          puts "Ready";
+        end
+      else
+        exit 0 if $F[0] == "exit"
+      end
+      @n += 1
+      puts "\#{@n}>"
+    GUESSING_GAME_EOT
+
+    # DRY: common code for sending a guess
+    def sendguess resend = false
+      @myguess = ((@min + @max) / 2).to_i
+      puts "Resending guess" if resend
+      puts "Guessing #{@myguess}"
+      @sin.puts @myguess
+      @guesses += 1 unless resend
+      if @guesses > @UPPER_LIMIT_LOG2
+        "I Lost"  # Bug in program if we haven't guessed it already
+      else
+        :continue
+      end
+    end
+
+    def newgame
+      @min = 0
+      @max = @UPPER_LIMIT
+      @guesses = 0
+    end
+
+    def winner
+      puts "I win!"
+      @wins += 1
+      newgame
+      (@games -= 1) > 0 ? sendguess : "finished" # :continue or "finished"
+    end
+
+    @games = @NGAMES
+    @wins = 0
+    # puts "Running: ruby -n -a -e #{game}"
+    result = nil
+    pty_return = PTY.spawn('ruby', '-n', '-a', '-e', game) do |sout, sin, pid|
+      @sin = sin
+      puts "Sending <CR>"
+      sin.puts '' # Elicit a prompt from the game
+      r = select([sout], [], [], 2)  # Wait up to 15 seconds for output from guessing game
+      puts "Wokeup from select with <<#{r.inspect}>>"
+
+      newgame
+      @n_to_reset = 0
+      sout.parley_maxread = 100
+      # sout.parley_verbose = true
+      result = sout.parley(
+        2,
+        [/too low/, lambda{|m| @min = @myguess + 1; sendguess}],
+        [/too high/, lambda{|m| @max = @myguess - 1; sendguess}],
+        [/correct/, lambda{|m| winner}],
+        [/>/, lambda{|m| sendguess true}],
+        [
+          :timeout,
+          lambda do |m|
+            sin.puts ""
+            @n_to_reset += 1
+            puts "Resetting timeout #{@n_to_reset}"
+            if @n_to_reset > 2 
+              sin.puts "exit"
+              "Timeout"
+            else
+              :reset_timeout
+            end
+          end
+      ])
+    end
+    puts "Script finished, pty_return=#{pty_return}"
+    assert(result == "finished", "didn't win last game")
+    # assert(ec == 0, "Bad exit from guessing game")
+    assert(@wins == @NGAMES, "Didn't win exactly #{@NGAMES} games")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parley
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-15 00:00:00.000000000 Z
+date: 2013-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -66,13 +66,11 @@ extensions: []
 extra_rdoc_files:
 - LICENSE.txt
 - README.md
-- README.rdoc
 files:
 - .document
 - Gemfile
 - LICENSE.txt
 - README.md
-- README.rdoc
 - Rakefile
 - VERSION
 - lib/parley.rb
@@ -94,7 +92,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1353724432284273081
+      hash: -3112653461861631076
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -103,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: An expect-like gem, modeled after Perl's Expect.pm

data/README.rdoc

@@ -1,35 +0,0 @@
-= parley
-
-An Expect-like gem for Ruby
-
-Parley is an implementation of an expect-like API.  It is designed to
-help port away from Perl Expect based applications.  The name "expect"
-is already well established in ruby.  Those of you who have wrestled
-with the interactive, text-mode, APIs of the world will appreciate the
-meaning of the word:
-
-From http://www.thefreedictionary.com/parley "A discussion or conference, especially one between enemies over terms of truce or other matters."
-
-See http://www.nist.gov/el/msid/expect.cfm for references to the original Expect language based on Tcl.
-
-See http://search.cpan.org/~rgiersig/Expect-1.21/Expect.pod for information on Expect.pm
-
-== Known Issues
-
-* need to generatate adequte documentation. See test/test_parley.rb for now
-* :restart_timeout from IO::parley() doesn't have the desired effect
-
-== Contributing to parley
- 
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
-* Fork the project.
-* Start a feature/bugfix branch.
-* Commit and push until you are happy with your contribution.
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
-
-== Copyright
-
-Copyright (c) 2013 Ben Stoltz.
-See LICENSE.txt for further details.