ProcessPilot 0.0.1.20120118

data/AUTHORS

@@ -0,0 +1 @@
+= Muriel Salvan (murielsalvan@users.sourceforge.net)

data/ChangeLog

@@ -0,0 +1,5 @@
+= Process Pilot Release History
+
+== 0.0.1.20120118 (Beta)
+
+* Initial public release.

data/Credits

@@ -0,0 +1,18 @@
+= Projects used by Process Pilot
+
+== ChildProcess
+* Jari Bakken (http://github.com/jarib)
+* http://github.com/jarib/childprocess
+* Used to internally pilot stdin in real time
+
+== Ruby
+* Yukihiro « matz » Matsumoto (http://www.rubyist.net/~matz/)
+* http://www.ruby-lang.org/
+* Thanks a lot Matz for this truly wonderful language !
+
+== rUtilAnts
+* Muriel Salvan (http://murielsalvan.users.sourceforge.net)
+* http://rutilants.sourceforge.net
+* Used for logging.
+
+= People that helped a lot in developing Process Pilot

data/LICENSE

@@ -0,0 +1,31 @@
+
+The license stated herein is a copy of the BSD License (modified on July 1999).
+The AUTHOR mentionned below refers to the list of people involved in the
+creation and modification of any file included in the delivered package.
+This list is found in the file named AUTHORS.
+The AUTHORS and LICENSE files have to be included in any release of software
+embedding source code of this package, or using it as a derivative software.
+
+Copyright (c) 2010 - 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+   2. 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.
+   3. The name of the author may not be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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,18 @@
+-- This file is best viewed when processed by rdoc.
+++
+
+= Process Pilot
+
+Ruby library to pilot interactive command line processes in real time.
+
+== Where is the documentation ?
+
+Check the website at http://processpilot.sourceforge.net
+
+== Who wrote it ?
+
+Check the AUTHORS[link:files/AUTHORS.html] file.
+
+== What is the license ?
+
+You can find out in the LICENSE[link:files/LICENSE.html] file.

data/ReleaseInfo

@@ -0,0 +1,8 @@
+
+# This file has been generated by RubyPackager during a delivery.
+# More info about RubyPackager: http://rubypackager.sourceforge.net
+{
+  :Version => '0.0.1.20120118',
+  :Tags => [ 'Beta' ],
+  :DevStatus => 'Beta'
+}

data/lib/processpilot/processpilot.rb

@@ -0,0 +1,197 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require 'childprocess'
+require 'tempfile'
+
+module ProcessPilot
+
+  # Pilot a process.
+  # This will create a new thread for the process to be run.
+  # If the process is a Ruby process, you can force STDOUT sync by specifying it in options. In this case the command line should begin with the Ruby file name to be executed (don't use ruby executable, and specifiy ruby options in iOptions[:RubyCmdLine]).
+  #
+  # Parameters:
+  # * *iCmdLine* (<em>list<String></em>): The process' command line
+  # * *iOptions* (<em>map<Symbol,Object></em>): Optional arguments [optional = nil]:
+  # ** *:ForceRubyProcessSync* (_Boolean_): If the command line is a Ruby process, force setting STDOUT to be synced. [optional = false]
+  # ** *:RubyCmdLine* (<em>list<String></em>): Command line of Ruby interpreter with options (used only if :ForceRubyProcessSync is true) [optional = ['ruby']]
+  # ** *:Debug* (_Boolean_): Do we activate some debugging traces ? (need rUtilAnts gem if activated) [optional = false]
+  # * _CodeBlock_: The code called for process piloting:
+  # ** Parameters:
+  # ** *oStdIN* (_IO_): The process' STDIN
+  # ** *iStdOUT* (_IO_): The process' STDOUT
+  # ** *iStdERR* (_IO_): The process' STDERR
+  # ** *iChildProcess* (_ChildProcess_): The corresponding child process. Don't use it to pilot std* IO objects.
+  # ** Return:
+  # ** _Boolean_: Do we have to wait until the process' completion ?
+  def self.pilot(*iArgs)
+    iCmdLine = iArgs
+    iOptions = (iArgs[-1].is_a?(Hash)) ? iArgs.pop : {}
+    iForceRubyProcessSync = (iOptions[:ForceRubyProcessSync] || false)
+    iRubyCmdLine = (iOptions[:RubyCmdLine] || ['ruby'])
+    iDebug = (iOptions[:Debug] || false)
+
+    if ((iDebug) and (require 'rUtilAnts/Logging'))
+      # First time it was required: set it up
+      RUtilAnts::Logging::initializeLogging('', '')
+      activateLogDebug(true)
+    end
+
+    # Wrap eventually Ruby command line
+    lRealCmdLine = (iForceRubyProcessSync) ? iRubyCmdLine + [ "#{File.dirname(__FILE__)}/wrapper.rb" ] + iCmdLine : iCmdLine
+
+    logDebug "[ProcessPilot] Command line: #{lRealCmdLine.inspect}" if iDebug
+    lProcess = ChildProcess.build(*lRealCmdLine)
+
+    # Indication of stdin usage
+    lProcess.duplex = true
+
+    # Specify files for stdout/stderr
+    # ! Use w+ mode to make it possible for our monitoring thread to reopen the file in r mode
+    Tempfile.open('processpilot.stdout') do |oStdOUT|
+      logDebug "[ProcessPilot] STDOUT file: #{oStdOUT.path}" if iDebug
+      lProcess.io.stdout = oStdOUT
+      Tempfile.open('processpilot.stderr') do |oStdERR|
+        logDebug "[ProcessPilot] STDERR file: #{oStdERR.path}" if iDebug
+        lProcess.io.stderr = oStdERR
+
+        # Start the process: this creates the background thread running our command
+        lProcess.start
+
+        # In our main thread: open the STDOUT/ERR files
+        lStdOUT = File.open(oStdOUT.path, 'r')
+        lStdERR = File.open(oStdERR.path, 'r')
+        lStdIN = lProcess.io.stdin
+
+        # Call client code
+        lWaitUntilCompletion = yield(lStdIN, lStdOUT, lStdERR, lProcess)
+
+        # Wait for the process termination in case it is late
+        if (lWaitUntilCompletion)
+          while (!lProcess.exited?)
+            sleep 1
+          end
+        end
+      end
+    end
+
+  end
+
+end
+
+# Define some helpers that can be handy in case of process piloting from IO
+class IO
+
+  # Exception thrown when timeout has been reached
+  class TimeOutError < RuntimeError
+  end
+
+  # Implement a blocking read of a new string ending with newline.
+  # Make sure we wait for the end of a string before returning.
+  # This is done to ensure we will get the new string we are expecting.
+  # If the timeout is reached, an exception is thrown.
+  #
+  # Parameters:
+  # * *iOptions* (<em>map<Symbol,Object></em>): Optional arguments [optional = {}]:
+  # ** *:TimeOutSecs* (_Integer_): Time out in seconds (nil = no timeout) [optional = nil]
+  # ** *:PollingIntervalSecs* (_Float_): Polling interval in seconds [optional = 0.1]
+  # ** *:ChildProcess* (_ChildProcess_): Corresponding child process linked to this IO. Can be used to detect the end of IO. [optional = nil]
+  # Return:
+  # * _String_: The next string from IO (separator is $/). Can be empty if the corresponding child process has exited already.
+  def gets_blocking(iOptions = {})
+    return get_data_blocking(
+      Proc.new { |iStr| iStr[-1..-1] == $/ },
+      iOptions
+    ) do |iStr|
+      next self.gets
+    end
+  end
+
+  # Implement a blocking read of a given size.
+  # Make sure we wait for the end of a string before returning.
+  # This is done to ensure we will get the new string we are expecting.
+  # If the timeout is reached, an exception is thrown.
+  #
+  # Parameters:
+  # * *iSize* (_Integer_): Size of the data to read
+  # * *iOptions* (<em>map<Symbol,Object></em>): Optional arguments [optional = {}]:
+  # ** *:TimeOutSecs* (_Integer_): Time out in seconds (nil = no timeout) [optional = nil]
+  # ** *:PollingIntervalSecs* (_Float_): Polling interval in seconds [optional = 0.1]
+  # ** *:ChildProcess* (_ChildProcess_): Corresponding child process linked to this IO. Can be used to detect the end of IO. [optional = nil]
+  # Return:
+  # * _String_: The next string from IO (separator is $/). Can be empty if the corresponding child process has exited already.
+  def read_blocking(iSize, iOptions = {})
+    return get_data_blocking(
+      Proc.new { |iStr| iStr.size == iSize },
+      iOptions
+    ) do |iStr|
+      next self.read(iSize-iStr.size)
+    end
+  end
+
+  # Send a synchronized input to an IO.
+  # Make sure it will be flushed.
+  #
+  # Parameters:
+  # * *iStr* (_String_): The string to send
+  def write_flushed(iStr)
+    self.write iStr
+    self.flush
+  end
+
+  private
+
+  # Implement a blocking read of a data unless the data read conforms to a given validation code.
+  # Take a validation proc to know if the data was read correctly, and yields code to read effectively data.
+  # Proper implementation should have a more efficient algo.
+  # If the timeout is reached, an exception is thrown.
+  #
+  # Parameters:
+  # * *iProcValidation* (_Proc_): The validation proc:
+  # ** Parameters:
+  # ** *iData* (_String_): The data to validate
+  # ** Return:
+  # ** _Boolean_: Is the data valid ?
+  # * *iOptions* (<em>map<Symbol,Object></em>): Optional arguments [optional = {}]:
+  # ** *:TimeOutSecs* (_Integer_): Time out in seconds (nil = no timeout) [optional = nil]
+  # ** *:PollingIntervalSecs* (_Float_): Polling interval in seconds [optional = 0.1]
+  # ** *:ChildProcess* (_ChildProcess_): Corresponding child process linked to this IO. Can be used to detect the end of IO. [optional = nil]
+  # * _CodeBlock_: Code called to read data effectively:
+  # ** Parameters:
+  # ** *iStr* (_String_): The data already read
+  # ** Return:
+  # ** _String_: String of data read (can be nil if no data was read)
+  # Return:
+  # * _String_: The next string from IO (separator is $/). Can be empty if the corresponding child process has exited already.
+  def get_data_blocking(iProcValidation, iOptions = {})
+    rStr = ''
+    iPollingInterval = (iOptions[:PollingIntervalSecs] || 0.1)
+    iTimeOutSecs = iOptions[:TimeOutSecs]
+    iChildProcess = iOptions[:ChildProcess]
+
+    require 'time' if (iTimeOutSecs != nil)
+
+    # Concatenate chunks unless we have the separator.
+    # As we deal with stdin flow, it is possible to have a line without ending already written in the file and already flushed by the IO.
+    lTimeOut = (iTimeOutSecs == nil) ? nil : Time.now + iTimeOutSecs
+    while (!iProcValidation.call(rStr))
+      lNewChunk = nil
+      while (lNewChunk == nil)
+        lNewChunk = yield(rStr)
+        #$stdout.puts "===== Read #{lNewChunk.inspect}"
+        break if ((iChildProcess != nil) and (iChildProcess.exited?))
+        if (lNewChunk == nil)
+          sleep iPollingInterval
+          raise TimeOutError.new("Timeout of #{iTimeOutSecs} secs reached while waiting for data.") if ((lTimeOut != nil) and (Time.now > lTimeOut))
+        end
+      end
+      rStr.concat(lNewChunk) if (lNewChunk != nil)
+      break if ((iChildProcess != nil) and (iChildProcess.exited?))
+    end
+
+    return rStr
+  end
+
+end

data/lib/processpilot/wrapper.rb

@@ -0,0 +1,16 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+# Disable STDOUT caching
+$stdout.sync = true
+
+# Get the rb file to execute
+iRBFileName = ARGV[0]
+
+# Adapt ARGV for this rb file to get its arguments correctly
+# TODO: Maybe adapt other variables ...
+ARGV.replace(ARGV[1..-1])
+
+load iRBFileName

data/test/ProcessPilotTest/Common.rb

@@ -0,0 +1,241 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module ProcessPilotTest
+
+  module Common
+
+    # Get the OS dependant command line for testing non interactive processes
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getNotInteractiveCmdLine
+      rCmdLine = nil
+
+      case $rUtilAnts_Platform_Info.os
+      when RUtilAnts::Platform::OS_WINDOWS
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Windows/NotInteractive.bat"]
+      when RUtilAnts::Platform::OS_LINUX
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/NotInteractive.sh"]
+      when RUtilAnts::Platform::OS_CYGWIN
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/NotInteractive.sh"]
+      else
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/NotInteractive.sh"]
+      end
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the OS dependant command line for testing non interactive processes on STDERR
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getNotInteractiveCmdLineSTDERR
+      rCmdLine = nil
+
+      case $rUtilAnts_Platform_Info.os
+      when RUtilAnts::Platform::OS_WINDOWS
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Windows/NotInteractiveSTDERR.bat"]
+      when RUtilAnts::Platform::OS_LINUX
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/NotInteractiveSTDERR.sh"]
+      when RUtilAnts::Platform::OS_CYGWIN
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/NotInteractiveSTDERR.sh"]
+      else
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/NotInteractiveSTDERR.sh"]
+      end
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the OS dependant command line for testing interactive processes
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getInteractiveCmdLine
+      rCmdLine = nil
+
+      case $rUtilAnts_Platform_Info.os
+      when RUtilAnts::Platform::OS_WINDOWS
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Windows/Interactive.bat"]
+      when RUtilAnts::Platform::OS_LINUX
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/Interactive.sh"]
+      when RUtilAnts::Platform::OS_CYGWIN
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/Interactive.sh"]
+      else
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/Interactive.sh"]
+      end
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the OS dependant command line for testing interactive processes on STDERR
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getInteractiveCmdLineSTDERR
+      rCmdLine = nil
+
+      case $rUtilAnts_Platform_Info.os
+      when RUtilAnts::Platform::OS_WINDOWS
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Windows/InteractiveSTDERR.bat"]
+      when RUtilAnts::Platform::OS_LINUX
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractiveSTDERR.sh"]
+      when RUtilAnts::Platform::OS_CYGWIN
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractiveSTDERR.sh"]
+      else
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractiveSTDERR.sh"]
+      end
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the OS dependant command line for testing interactive processes with a prompt
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getInteractivePromptCmdLine
+      rCmdLine = nil
+
+      case $rUtilAnts_Platform_Info.os
+      when RUtilAnts::Platform::OS_WINDOWS
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Windows/InteractivePrompt.bat"]
+      when RUtilAnts::Platform::OS_LINUX
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractivePrompt.sh"]
+      when RUtilAnts::Platform::OS_CYGWIN
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractivePrompt.sh"]
+      else
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractivePrompt.sh"]
+      end
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the OS dependant command line for testing interactive processes with a prompt on STDERR
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getInteractivePromptCmdLineSTDERR
+      rCmdLine = nil
+
+      case $rUtilAnts_Platform_Info.os
+      when RUtilAnts::Platform::OS_WINDOWS
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Windows/InteractivePromptSTDERR.bat"]
+      when RUtilAnts::Platform::OS_LINUX
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractivePromptSTDERR.sh"]
+      when RUtilAnts::Platform::OS_CYGWIN
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractivePromptSTDERR.sh"]
+      else
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractivePromptSTDERR.sh"]
+      end
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the OS dependant command line for testing interactive processes with several prompts
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getInteractiveSeveralPrompts
+      rCmdLine = nil
+
+      case $rUtilAnts_Platform_Info.os
+      when RUtilAnts::Platform::OS_WINDOWS
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Windows/InteractiveSeveralPrompts.bat"]
+      when RUtilAnts::Platform::OS_LINUX
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractiveSeveralPrompts.sh"]
+      when RUtilAnts::Platform::OS_CYGWIN
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractiveSeveralPrompts.sh"]
+      else
+        rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Bash/InteractiveSeveralPrompts.sh"]
+      end
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the command line for testing synced Ruby programs
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getSyncedRubyCmdLine
+      rCmdLine = ['ruby', "#{$ProcessPilotTest_RootPath}/test/Programs/Ruby/SyncedSTDOUT.rb"]
+
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the command line for testing normal Ruby programs
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getNormalRubyCmdLine
+      rCmdLine = ['ruby', "#{$ProcessPilotTest_RootPath}/test/Programs/Ruby/NormalSTDOUT.rb"]
+
+      rCmdLine << { :Debug => true } if ($ProcessPilotTest_Debug)
+
+      return rCmdLine
+    end
+
+    # Get the command line for testing normal Ruby programs and forcing them to sync
+    #
+    # Return:
+    # * <em>list<String></em>: Command line
+    def getNormalRubyWithSyncCmdLine
+      rCmdLine = ["#{$ProcessPilotTest_RootPath}/test/Programs/Ruby/NormalSTDOUT.rb"]
+
+      lOptions = {
+        :ForceRubyProcessSync => true
+      }
+      lOptions[:Debug] = true if ($ProcessPilotTest_Debug)
+      rCmdLine << lOptions
+
+      return rCmdLine
+    end
+
+    # Assert a common given scenario.
+    # This has been put in such a method as the same scenario is used in different scripts.
+    #
+    # Parameters:
+    # * *oStdIN* (_IO_): STDIN
+    # * *iStdOUT* (_IO_): STDOUT
+    # * *iStdERR* (_IO_): STDERR
+    # * *iChildProcess* (_ChildProcess_): Corresponding ChildProcess
+    def assert_testing_scenario(oStdIN, iStdOUT, iStdERR, iChildProcess)
+      assert_equal "STDOUT Line 1\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_equal 'Enter string 1 from STDOUT: ', iStdOUT.read_blocking(28, :ChildProcess => iChildProcess)
+      assert_raise IO::TimeOutError do
+        iStdERR.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      end
+      assert_raise IO::TimeOutError do
+        iStdOUT.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      end
+      oStdIN.write_flushed "Test String 1\n"
+      assert_equal "STDOUT Line 2 Test String 1\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_equal "STDERR Line 1\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_equal 'Enter string 2 from STDERR: ', iStdERR.read_blocking(28, :ChildProcess => iChildProcess)
+      assert_raise IO::TimeOutError do
+        iStdERR.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      end
+      assert_raise IO::TimeOutError do
+        iStdOUT.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      end
+      oStdIN.write_flushed "Test String 2\n"
+      assert_equal "STDOUT Line 3 Test String 2\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_equal "STDERR Line 2\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+      assert iChildProcess.exited?
+    end
+
+  end
+
+end

data/test/ProcessPilotTest/NonRuby.rb

@@ -0,0 +1,114 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module ProcessPilotTest
+
+  class NonRuby < ::Test::Unit::TestCase
+
+    include ProcessPilotTest::Common
+
+    def testNotInteractiveSTDOUT
+      ProcessPilot::pilot(*getNotInteractiveCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_equal "Hello World\n", iStdOUT.gets_blocking(:TimeOutSecs => 1)
+        assert_raise IO::TimeOutError do
+          iStdERR.gets_blocking(:TimeOutSecs => 1)
+        end
+        assert iChildProcess.exited?
+        next true
+      end
+    end
+
+    def testNotInteractiveSTDOUTEndOfProcess
+      ProcessPilot::pilot(*getNotInteractiveCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_equal "Hello World\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert iChildProcess.exited?
+        next true
+      end
+    end
+
+    def testNotInteractiveSTDERR
+      ProcessPilot::pilot(*getNotInteractiveCmdLineSTDERR) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal "Hello World\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert iChildProcess.exited?
+        next true
+      end
+    end
+
+    def testInteractiveSTDOUT
+      ProcessPilot::pilot(*getInteractiveCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_equal "Hello World\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_raise IO::TimeOutError do
+          iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        end
+        oStdIN.write_flushed "Test String\n"
+        assert_equal "Hello Test String\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert iChildProcess.exited?
+        next true
+      end
+    end
+
+    def testInteractiveSTDERR
+      ProcessPilot::pilot(*getInteractiveCmdLineSTDERR) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_raise IO::TimeOutError do
+          iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        end
+        assert_equal "Hello World\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_raise IO::TimeOutError do
+          iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        end
+        oStdIN.write_flushed "Test String\n"
+        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal "Hello Test String\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert iChildProcess.exited?
+        next true
+      end
+    end
+
+    def testInteractiveWithPromptSTDOUT
+      ProcessPilot::pilot(*getInteractivePromptCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_equal "Hello World\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal 'Enter string: ', iStdOUT.read_blocking(14, :ChildProcess => iChildProcess)
+        assert_raise IO::TimeOutError do
+          iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        end
+        oStdIN.write_flushed "Test String\n"
+        assert_equal "Hello Test String\n", iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal '', iStdOUT.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert iChildProcess.exited?
+        next true
+      end
+    end
+
+    def testInteractiveWithPromptSTDERR
+      ProcessPilot::pilot(*getInteractivePromptCmdLineSTDERR) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_equal "Hello World\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal 'Enter string: ', iStdERR.read_blocking(14, :ChildProcess => iChildProcess)
+        assert_raise IO::TimeOutError do
+          iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        end
+        oStdIN.write_flushed "Test String\n"
+        assert_equal "Hello Test String\n", iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert_equal '', iStdERR.gets_blocking(:TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        assert iChildProcess.exited?
+        next true
+      end
+    end
+
+    def testSeveralPrompts
+      ProcessPilot::pilot(*getInteractiveSeveralPrompts) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_testing_scenario(oStdIN, iStdOUT, iStdERR, iChildProcess)
+        next true
+      end
+    end
+
+  end
+
+end

data/test/ProcessPilotTest/Ruby.rb

@@ -0,0 +1,38 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module ProcessPilotTest
+
+  class Ruby < ::Test::Unit::TestCase
+
+    include ProcessPilotTest::Common
+
+    def testSyncedSTDOUT
+      ProcessPilot::pilot(*getSyncedRubyCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_testing_scenario(oStdIN, iStdOUT, iStdERR, iChildProcess)
+        next true
+      end
+    end
+
+    def testNormalSTDOUT
+      ProcessPilot::pilot(*getNormalRubyCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_raise IO::TimeOutError do
+          iStdOUT.read_blocking(1, :TimeOutSecs => 1, :ChildProcess => iChildProcess)
+        end
+        iChildProcess.stop
+        next true
+      end
+    end
+
+    def testNormalSTDOUTWithForceSync
+      ProcessPilot::pilot(*getNormalRubyWithSyncCmdLine) do |oStdIN, iStdOUT, iStdERR, iChildProcess|
+        assert_testing_scenario(oStdIN, iStdOUT, iStdERR, iChildProcess)
+        next true
+      end
+    end
+
+  end
+
+end

data/test/Programs/Bash/Interactive.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+echo "Hello World"
+read VAR
+echo "Hello ${VAR}"

data/test/Programs/Bash/InteractivePrompt.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+echo "Hello World"
+echo -n "Enter string: "
+read VAR
+echo "Hello ${VAR}"

data/test/Programs/Bash/InteractivePromptSTDERR.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+echo "Hello World" >&2
+echo -n "Enter string: " >&2
+read VAR
+echo "Hello ${VAR}" >&2

data/test/Programs/Bash/InteractiveSTDERR.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+echo "Hello World" >&2
+read VAR
+echo "Hello ${VAR}" >&2

data/test/Programs/Bash/InteractiveSeveralPrompts.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+echo "STDOUT Line 1"
+echo -n "Enter string 1 from STDOUT: "
+read VAR
+echo "STDOUT Line 2 ${VAR}"
+echo "STDERR Line 1" >&2
+echo -n "Enter string 2 from STDERR: " >&2
+read VAR
+echo "STDOUT Line 3 ${VAR}"
+echo "STDERR Line 2" >&2

data/test/Programs/Bash/NotInteractive.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+echo "Hello World"

data/test/Programs/Bash/NotInteractiveSTDERR.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+echo "Hello World" >&2

data/test/Programs/Ruby/NormalSTDOUT.rb

@@ -0,0 +1,8 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require "#{File.dirname(__FILE__)}/Scenario.rb"
+
+ProcessPilotTest::Scenario::run

data/test/Programs/Ruby/Scenario.rb

@@ -0,0 +1,25 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module ProcessPilotTest
+
+  module Scenario
+
+    # Execute the testing scenario
+    def self.run
+      $stdout.puts 'STDOUT Line 1'
+      $stdout.write 'Enter string 1 from STDOUT: '
+      lVar = $stdin.gets
+      $stdout.puts "STDOUT Line 2 #{lVar}"
+      $stderr.puts 'STDERR Line 1'
+      $stderr.write 'Enter string 2 from STDERR: '
+      lVar = $stdin.gets
+      $stdout.puts "STDOUT Line 3 #{lVar}"
+      $stderr.puts 'STDERR Line 2'
+    end
+
+  end
+
+end

data/test/Programs/Ruby/SyncedSTDOUT.rb

@@ -0,0 +1,10 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+$stdout.sync = true
+
+require "#{File.dirname(__FILE__)}/Scenario.rb"
+
+ProcessPilotTest::Scenario::run

data/test/Programs/Windows/Interactive.bat

@@ -0,0 +1,4 @@
+@echo off
+echo Hello World
+set /p var="" %=%
+echo Hello %var%

data/test/Programs/Windows/InteractivePrompt.bat

@@ -0,0 +1,4 @@
+@echo off
+echo Hello World
+set /p var="Enter string: " %=%
+echo Hello %var%

data/test/Programs/Windows/InteractivePromptSTDERR.bat

@@ -0,0 +1,5 @@
+@echo off
+echo Hello World>&2
+echo/|set /p ="Enter string: " >&2
+set /p var= %=%
+echo Hello %var%>&2

data/test/Programs/Windows/InteractiveSTDERR.bat

@@ -0,0 +1,4 @@
+@echo off
+echo Hello World >&2
+set /p var="" %=%
+echo Hello %var% >&2

data/test/Programs/Windows/InteractiveSeveralPrompts.bat

@@ -0,0 +1,9 @@
+@echo off
+echo STDOUT Line 1
+set /p var="Enter string 1 from STDOUT: " %=%
+echo STDOUT Line 2 %var%
+echo "STDERR Line 1">&2
+echo/|set /p ="Enter string 2 from STDERR: " >&2
+set /p var= %=%
+echo STDOUT Line 3 %var%
+echo "STDERR Line 2">&2

data/test/Programs/Windows/NotInteractive.bat

@@ -0,0 +1,2 @@
+@echo off
+echo Hello World

data/test/Programs/Windows/NotInteractiveSTDERR.bat

@@ -0,0 +1,2 @@
+@echo off
+echo Hello World>&2

data/test/run.rb

@@ -0,0 +1,30 @@
+#--
+# Copyright (c) 2012 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+$ProcessPilotTest_Debug = true
+
+require 'test/unit'
+require 'rUtilAnts/Logging'
+RUtilAnts::Logging::initializeLogging('', '')
+activateLogDebug($ProcessPilotTest_Debug)
+require 'rUtilAnts/Misc'
+RUtilAnts::Misc::initializeMisc
+require 'rUtilAnts/Platform'
+RUtilAnts::Platform::initializePlatform
+
+$ProcessPilotTest_RootPath = File.expand_path("#{File.dirname(__FILE__)}/..")
+
+# Add the test directory to the current load path
+$: << "#{$ProcessPilotTest_RootPath}/test"
+# And the lib one too
+$: << "#{$ProcessPilotTest_RootPath}/lib"
+
+# Require the main library
+require 'processpilot/processpilot'
+
+# Load test files to execute
+require 'ProcessPilotTest/Common'
+require 'ProcessPilotTest/NonRuby'
+require 'ProcessPilotTest/Ruby'

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification 
+name: ProcessPilot
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  - 20120118
+  version: 0.0.1.20120118
+platform: ruby
+authors: 
+- Muriel Salvan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-18 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rUtilAnts
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        version: "0.3"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: childprocess
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 3
+        version: 0.2.3
+  type: :runtime
+  version_requirements: *id002
+description: Ruby library giving a simple way to pilot an external process' stdin, stdout and stderr in real time. Very useful for interactive processes testing or automation.
+email: muriel@x-aeon.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- ChangeLog
+- Credits
+- lib/processpilot/processpilot.rb
+- lib/processpilot/wrapper.rb
+- LICENSE
+- README
+- ReleaseInfo
+- test/ProcessPilotTest/Common.rb
+- test/ProcessPilotTest/NonRuby.rb
+- test/ProcessPilotTest/Ruby.rb
+- test/Programs/Bash/Interactive.sh
+- test/Programs/Bash/InteractivePrompt.sh
+- test/Programs/Bash/InteractivePromptSTDERR.sh
+- test/Programs/Bash/InteractiveSeveralPrompts.sh
+- test/Programs/Bash/InteractiveSTDERR.sh
+- test/Programs/Bash/NotInteractive.sh
+- test/Programs/Bash/NotInteractiveSTDERR.sh
+- test/Programs/Ruby/NormalSTDOUT.rb
+- test/Programs/Ruby/Scenario.rb
+- test/Programs/Ruby/SyncedSTDOUT.rb
+- test/Programs/Windows/Interactive.bat
+- test/Programs/Windows/InteractivePrompt.bat
+- test/Programs/Windows/InteractivePromptSTDERR.bat
+- test/Programs/Windows/InteractiveSeveralPrompts.bat
+- test/Programs/Windows/InteractiveSTDERR.bat
+- test/Programs/Windows/NotInteractive.bat
+- test/Programs/Windows/NotInteractiveSTDERR.bat
+- test/run.rb
+has_rdoc: true
+homepage: http://processpilot.sourceforge.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: processpilot
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby library to pilot interactive command line processes in real time.
+test_files: 
+- test/run.rb