win32-open3 0.2.6-x86-mswin32-60

data/CHANGES

@@ -0,0 +1,44 @@
+== 0.2.6 - 1-June-2007
+* Fixed RubyForge bug #20455 (closed IO stream). Thanks go an anonymous user
+  for the spot.
+* Added a Rakefile with tasks for building, testing and installation.
+* Minor updates to the test file.
+* Some minor rdoc improvements.
+
+== 0.2.5 - 8-Dec-2006
+* Added a WIN32_OPEN3_VERSION constant.
+* Fixes and updates to the gemspec.
+* Some internal reorganization.
+* Minor documentation updates and corrections.
+
+== 0.2.4 - 4-Jun-2006
+* Applied a patch for Windows 2000.  Thanks again to John-Mason Shackelford
+  for the patch.
+* Fixed the version number for the last release.
+
+== 0.2.3 - 3-Jun-2006
+* Now sets Process::Status when the block form is used.  Thanks go to
+  Samuel Tesla and John-Mason Shackelford for their patches.
+* Improved error messages.
+* Documentation updated with regards to the block form of the method calls.
+* Some internal reorganization that you don't care about.
+
+== 0.2.2 - 10-Feb-2006
+* Methods now support block form, and all handles are automatically closed
+  at the end of the block (via ensure).
+
+== 0.2.1 - 27-Oct-2005
+* Added a type check in the extconf.rb file and did some type mangling in
+  order to handle rb_pid_t in a backwards compatible way.  In other words,
+  you need this version to work with 1.8.3 or later.
+
+== 0.2.0 - 9-Jan-2005
+* Added the Open4 module and popen4 method.  Thanks go to Aslak Hellesoy for
+  the patch.
+* Added an optional 3rd parameter - the "show" flag.  See docs for details.
+* Made some documentation more rdoc friendly.
+* Moved the "examples" directory to the toplevel directory.
+* Added some information to the README file about possible compiler problems.
+
+== 0.1.0 - 8-Oct-2004
+* Initial release

data/MANIFEST

@@ -0,0 +1,11 @@
+* CHANGES
+* MANIFEST
+* README
+* Rakefile
+* win32-open3.gemspec
+* doc/open3.txt
+* examples/open3_test.rb
+* ext/extconf.rb
+* ext/win32/open3.c
+* ext/win32/open3.h
+* test/tc_open3.rb

data/README

@@ -0,0 +1,60 @@
+= Description
+   This library provides an Open3.popen3 implementation for MS Windows.
+
+= Prerequisites
+   Ruby 1.8.2 or later
+   C++ compiler (if building from source).
+   
+= Installation
+   rake test (optional)
+   rake install (non-gem) or rake install_gem (gem)
+   
+= Synopsis
+   require 'win32/open3'
+	
+   Open3.popen3('ver'){ |io_in, io_out, io_err|
+      error = io_err.gets
+      if error
+         puts "Error: " + error.chomp
+         exit
+      end
+      puts "Result: " + io_out.readlines.last.chomp
+   }
+
+= Notes
+   This library is not supported on Windows 95, 98, or ME.
+   This is a stripped down version of Park Heesob's win32_popen library.
+
+= Developer's Notes
+   This is a repackaging of Heesob's win32_popen module. The purpose of the
+   repackaging was to create a unified API between the existing Ruby open3
+   library and this library.
+
+   The popen2 and posix_popen methods are not included in this release. They
+   were originally part of the win32_popen module, but have been left out.
+   They may be added back in at a later date.
+
+   There are a couple of differences in the Windows version for open3 (which
+   also apply to Open4.popen4) - the mode flag and the show flag.  For the
+   mode, you can specify either 't' (text, the default) or 'b' (binary) as a
+   second argument. For the show flag, you can specify either true or false,
+   which will show the console window, or not, depending on the value you
+   pass.  The default is false.
+
+= Known Issues
+   I have noticed that this library (and others) may segfault if you are using
+   the latest version of the Ruby one-click installer and VC++ 7.0 or later.
+   This appears to be an issue between VC++ 6 (which the installer was built
+   with) and VC++ 7.0. Your best solution is to either upgrade your C
+   compiler or to rebuild Ruby from scratch rather than using the installer.
+
+   You can also download a precompiled binary from the project site. Look for a
+   file called 'open3-x.y.z-vc6.so' on the 'files' page, where 'x.y.z' is a
+   version number, if you want a binary that's compatible with Curt Hibbs one
+   click installer.
+   
+= Future Plans
+   Replace the current implementation with a pure Ruby version.
+ 
+= More Documentation
+   See the doc/open3.txt file for more details.

data/doc/open3.txt

@@ -0,0 +1,75 @@
+= Description
+   An open3 library for MS Windows.
+	
+= Synopsis
+   require 'win32/open3'
+	
+   Open3.popen3('ver'){ |io_in, io_out, io_err|
+      error = io_err.gets
+      if error
+         puts "Error: " + error.chomp
+         exit
+      end
+      puts "Result: " + io_out.readlines.last.chomp
+   }
+
+= Module functions
+Open3.popen3(command, mode='t', show=false)
+
+Open3.popen3(command, mode='t', show=false){ |io_in, io_out, io_err| ... }
+
+   Executes 'command', returning an array of three IO handles representing
+   STDIN, STDOUT and STDERR, respectively.  In block form these IO handles
+   are yielded back to the block and automatically closed at the end of the
+   block.
+	
+   You may optionally pass a mode flag of 't' (text, the default) or 'b'
+   (binary) to this method.
+	
+   If the 'show' variable is set to true, then a console window is shown.
+
+Open4.popen4(command, mode='t', show=false)
+
+Open4.popen4(command, mode='t', show=false){ |io_in, io_out, io_err, pid| ... }
+   
+   Executes 'command', returning an array consisting of three IO handles,
+   representing STDIN, STDOUT and STDERR, respectively, as well as the PID
+   of the newly generated process.  In block form these IO handles and pid
+   are yielded back to the block and automatically closed at the end of the
+   block.
+	
+   You may optionally pass a mode flag of 't' (text, the default) or 'b'
+   (binary) to this method.
+	
+   If the 'show' variable is set to true, then a console window is shown.
+	
+= Notes
+   This is a remake of Park Heesob's win32_popen package.  It has been reworked
+   in order to make the API (nearly) identical to the Open3 package currently
+   included in the Ruby standard library.
+	
+   For now only the popen3 and popen4 methods have been included.  In later
+   releases we will probably add the popen2 and posix_popen methods back in.
+
+= Acknowledgements
+   Thanks go to Samuel Tesla and John-Mason Shackelford for their patches that
+   enabled us to set Process::Status.
+	
+= Known Bugs  
+   None that I know of.  Please log any other bug reports on the RubyForge
+   project page at http://www.rubyforge.net/projects/win32utils.
+      
+= License
+   Ruby's
+        
+= Copyright
+   (C) 2003-2008 Daniel J. Berger, All Rights Reserved .
+       
+= Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
+		
+= Authors
+   Park Heesob
+   Daniel J. Berger

data/ext/win32/open3.c

@@ -0,0 +1,545 @@
+/***************************************************
+ * open3.c
+ *
+ * Source for the win32-open3 extension.
+ ***************************************************/
+#include "ruby.h"
+#include "rubysig.h"
+#include "rubyio.h"
+#include "open3.h"
+
+#include <malloc.h>
+#include <io.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+/* Necessary to work with Ruby 1.8.3 or later */
+#ifdef HAVE_TYPE_RB_PID_T
+#define pid_t rb_pid_t
+#endif
+
+static VALUE win32_last_status = Qnil;
+static HANDLE pid_handle = NULL;
+
+static VALUE ruby_popen(char *, int, VALUE);
+
+static int rb_io_mode_flags2(int mode){
+   int flags;
+
+   switch (mode & (O_RDONLY|O_WRONLY|O_RDWR)) {
+      case O_RDONLY:
+         flags = FMODE_READABLE;
+         break;
+      case O_WRONLY:
+         flags = FMODE_WRITABLE;
+         break;
+      case O_RDWR:
+         flags = FMODE_WRITABLE|FMODE_READABLE;
+         break;
+   }
+
+#ifdef O_BINARY
+   if(mode & O_BINARY)
+      flags |= FMODE_BINMODE;
+#endif
+
+   return flags;
+}
+
+static char* rb_io_modenum_mode(int flags, char* mode){
+    char *p = mode;
+
+    switch(flags & (O_RDONLY|O_WRONLY|O_RDWR)){
+      case O_RDONLY:
+         *p++ = 'r';
+         break;
+      case O_WRONLY:
+         *p++ = 'w';
+         break;
+      case O_RDWR:
+         *p++ = 'r';
+         *p++ = '+';
+         break;
+   }
+
+   *p++ = '\0';
+
+#ifdef O_BINARY
+   if(flags & O_BINARY){
+      if(mode[1] == '+'){
+         mode[1] = 'b';
+         mode[2] = '+';
+         mode[3] = '\0';
+      }
+      else{
+         mode[1] = 'b'; mode[2] = '\0';
+      }      
+   }
+#endif
+   return mode;
+}
+
+/* Used to close io handle */
+static VALUE io_close(VALUE val) {
+   int i;
+
+   for(i = 0; i < 3; i++){
+      if(rb_funcall(RARRAY(val)->ptr[i], rb_intern("closed?"), 0) == Qfalse)
+         rb_funcall(RARRAY(val)->ptr[i], rb_intern("close"), 0);
+   }
+
+   return Qnil;
+}
+
+/*
+ * call-seq:
+ *    Open3.popen3(cmd, mode='t', show=false)
+ *    Open3.popen3(cmd, mode='t', show=false){ |io_in, io_out, io_err| ... }
+ * 
+ * Executes 'command', returning an array of three IO handles representing
+ * STDIN, STDOUT and STDERR, respectively.  In block form these IO handles
+ * are yielded back to the block and automatically closed at the end of the
+ * block.
+ *  
+ * You may optionally pass a mode flag of 't' (text, the default) or 'b'
+ * (binary) to this method.
+ *  
+ * If the 'show' variable is set to true, then a console window is shown.
+ */
+static VALUE win32_popen3(int argc, VALUE *argv, VALUE klass)
+{
+   VALUE v_name, v_mode, v_port;
+   VALUE v_show_window = Qfalse;
+   char mbuf[4];
+   int tm = 0;
+   char *mode = "t";
+
+   rb_scan_args(argc, argv, "12", &v_name, &v_mode, &v_show_window);
+
+   // Mode can be either a string or a number
+   if(!NIL_P(v_mode)){
+      if(FIXNUM_P(v_mode))
+         mode = rb_io_modenum_mode(FIX2INT(v_mode), mbuf);
+      else
+         mode = StringValuePtr(v_mode);
+   }
+
+   if(*mode == 't')
+      tm = _O_TEXT;
+   else if(*mode != 'b')
+      rb_raise(rb_eArgError, "popen3() arg 2 must be 't' or 'b'");
+   else
+      tm = _O_BINARY;
+
+   v_port = ruby_popen(StringValuePtr(v_name), tm, v_show_window);
+   
+   // Ensure handles are closed in block form
+   if(rb_block_given_p()){
+      rb_ensure(rb_yield_splat, v_port, io_close, v_port);
+      return win32_last_status;
+   }
+   
+   return v_port;
+}
+
+static BOOL RubyCreateProcess(char *cmdstring, HANDLE hStdin, HANDLE hStdout,
+   HANDLE hStderr, HANDLE *hProcess, pid_t *pid, VALUE v_show_window)
+{
+   PROCESS_INFORMATION piProcInfo;
+   STARTUPINFO siStartInfo;
+   char *s1,*s2, *s3 = " /c ";
+   int i, x;
+
+   if(i = GetEnvironmentVariable("COMSPEC", NULL, 0)){
+      char *comshell;
+      s1 = (char *)_alloca(i);
+
+      if(!(x = GetEnvironmentVariable("COMSPEC", s1, i)))
+         return x;
+
+      /* Explicitly check if we are using COMMAND.COM. If we are
+       * then use the w9xpopen hack.
+       */
+      comshell = s1 + x;
+
+      while(comshell >= s1 && *comshell != '\\')
+         --comshell;
+
+      ++comshell;
+
+      // Windows 95, 98 and ME are not supported      
+      if(GetVersion() < 0x80000000 && _stricmp(comshell, "command.com") != 0){
+         x = i + strlen(s3) + strlen(cmdstring) + 1;
+         s2 = ALLOCA_N(char, x);
+         sprintf(s2, "%s%s%s", s1, s3, cmdstring);
+      }
+      else{
+         rb_raise(rb_eRuntimeError,"not supported on this platform");
+      }
+   }
+   else{
+      // Could be an else here to try cmd.exe / command.com in the path.
+      // Now we'll just error out..
+      rb_raise(rb_eRuntimeError,
+         "Cannot locate a COMSPEC environment variable to use as the shell"
+      );
+      return FALSE;
+   }
+
+   ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
+
+   siStartInfo.cb = sizeof(STARTUPINFO);
+   siStartInfo.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
+   siStartInfo.hStdInput = hStdin;
+   siStartInfo.hStdOutput = hStdout;
+   siStartInfo.hStdError = hStderr;
+   siStartInfo.wShowWindow = SW_HIDE;
+
+   if(v_show_window == Qtrue)
+      siStartInfo.wShowWindow = SW_SHOW;
+
+   // Try the command first without COMSPEC
+   if(CreateProcess(
+      NULL,
+      cmdstring,
+      NULL,
+      NULL,
+      TRUE,
+      0,
+      NULL,
+      NULL,
+      &siStartInfo,
+      &piProcInfo)
+    ){
+      // Close the handles now so anyone waiting is woken.
+      CloseHandle(piProcInfo.hThread);
+
+      // Return process handle
+      *hProcess = piProcInfo.hProcess;
+      *pid = (pid_t)piProcInfo.dwProcessId;
+      return TRUE;
+   }
+
+   // If that failed, try again with COMSPEC
+   if(CreateProcess(
+      NULL,
+      s2,
+      NULL,
+      NULL,
+      TRUE,
+      CREATE_NEW_CONSOLE,
+      NULL,
+      NULL,
+      &siStartInfo,
+      &piProcInfo)
+    ){
+      // Close the handles now so anyone waiting is woken.
+      CloseHandle(piProcInfo.hThread);
+
+      // Return process handle
+      *hProcess = piProcInfo.hProcess;
+      *pid = (pid_t)piProcInfo.dwProcessId;
+      return TRUE;
+   }
+
+   rb_raise(rb_eRuntimeError, "CreateProcess() failed: %s",
+      ErrorDescription(GetLastError())
+   );
+   
+   return FALSE;
+}
+
+/* Set the Process::Status. This code is based on patches by Samuel Tesla and
+ * John-Mason Shackelford.
+ */
+static void win32_set_last_status(const int status, const int pid)
+{
+  // rb_last_status is defined in process.c in the main ruby.exe
+  __declspec (dllimport) extern VALUE rb_last_status;
+  VALUE klass = rb_path2class("Process::Status");
+  VALUE process_status = rb_obj_alloc(klass);
+  rb_iv_set(process_status, "status", INT2FIX(status << 8));
+  rb_iv_set(process_status, "pid", INT2FIX(pid));
+  rb_last_status = process_status;
+  win32_last_status = process_status;
+}
+
+static void win32_pipe_finalize(OpenFile *file, int noraise)
+{
+   int status;
+
+   if(file->f){
+   	fclose(file->f);
+   	file->f = NULL;
+   }
+
+   if(file->f2){
+   	fclose(file->f2);
+   	file->f2 = NULL;
+   }
+
+   if(pid_handle != NULL){
+      GetExitCodeProcess(pid_handle, &status);
+      CloseHandle(pid_handle);
+
+      if(status != STILL_ACTIVE)
+ 	      win32_set_last_status(status, file->pid);
+   }
+}
+
+// The following code is based off of KB: Q190351
+static VALUE ruby_popen(char *cmdstring, int mode, VALUE v_show_window)
+{
+   HANDLE hChildStdinRd, hChildStdinWr, hChildStdoutRd, hChildStdoutWr,
+     hChildStderrRd, hChildStderrWr, hChildStdinWrDup, hChildStdoutRdDup,
+     hChildStderrRdDup, hProcess;
+
+   pid_t pid;
+
+   SECURITY_ATTRIBUTES saAttr;
+   BOOL fSuccess;
+   int fd1, fd2, fd3;
+   FILE *f1, *f2, *f3;
+   long file_count;
+   VALUE port;
+   VALUE p1,p2,p3;
+   int modef;
+   OpenFile *fptr;
+   char *m1, *m2;
+
+   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
+   saAttr.bInheritHandle = TRUE;
+   saAttr.lpSecurityDescriptor = NULL;
+
+   if(!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) {
+      rb_raise(rb_eRuntimeError, "CreatePipe() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   /* Create new output read handle and the input write handle. Set
+    * the inheritance properties to FALSE. Otherwise, the child inherits
+    * the these handles; resulting in non-closeable handles to the pipes
+    * being created.
+    */
+   fSuccess = DuplicateHandle(
+      GetCurrentProcess(),
+      hChildStdinWr,
+      GetCurrentProcess(),
+      &hChildStdinWrDup,
+      0,
+      FALSE,
+      DUPLICATE_SAME_ACCESS
+   );
+
+   if(!fSuccess){
+      rb_raise(rb_eRuntimeError, "DuplicateHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   // Close the inheritable version of ChildStdin that we're using
+   CloseHandle(hChildStdinWr);
+
+   if(!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) {
+      rb_raise(rb_eRuntimeError, "CreatePipe() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   fSuccess = DuplicateHandle(
+      GetCurrentProcess(),
+      hChildStdoutRd,
+      GetCurrentProcess(),
+      &hChildStdoutRdDup,
+      0,
+      FALSE,
+      DUPLICATE_SAME_ACCESS
+   );
+
+   if(!fSuccess){
+      rb_raise(rb_eRuntimeError, "DuplicateHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   // Close the inheritable version of ChildStdout that we're using.
+   CloseHandle(hChildStdoutRd);
+
+   if(!CreatePipe(&hChildStderrRd, &hChildStderrWr, &saAttr, 0)) {
+      rb_raise(rb_eRuntimeError, "CreatePipe() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   fSuccess = DuplicateHandle(
+      GetCurrentProcess(),
+      hChildStderrRd,
+      GetCurrentProcess(),
+      &hChildStderrRdDup,
+      0,
+      FALSE,
+      DUPLICATE_SAME_ACCESS
+   );
+
+   if (!fSuccess) {
+      rb_raise(rb_eRuntimeError, "DuplicateHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   // Close the inheritable version of ChildStdErr that we're using.
+   CloseHandle(hChildStderrRd);
+
+   if(mode & _O_TEXT){
+      m1 = "r";
+      m2 = "w";
+   }
+   else{
+      m1 = "rb";
+      m2 = "wb";
+   }
+
+   // Convert HANDLE's into file descriptors and, ultimately, Ruby IO objects.
+   fd1 = _open_osfhandle((long)hChildStdinWrDup, mode);
+   f1 = _fdopen(fd1, m2);
+
+   fd2 = _open_osfhandle((long)hChildStdoutRdDup, mode);
+   f2 = _fdopen(fd2, m1);
+
+   fd3 = _open_osfhandle((long)hChildStderrRdDup, mode);
+   f3 = _fdopen(fd3, m1);
+
+   file_count = 3;
+
+   if(!RubyCreateProcess(cmdstring,hChildStdinRd,hChildStdoutWr,
+      hChildStderrWr, &hProcess, &pid, v_show_window))
+   {
+      return Qnil;
+   }
+
+   // I think this is only possible on Win9x, but we'll leave it here
+   if(pid < 0){
+      pid = -pid;
+   }
+
+   modef = rb_io_mode_flags(m2);
+   p1 =  io_alloc(rb_cIO);
+   MakeOpenFile(p1, fptr);
+
+   fptr->finalize = win32_pipe_finalize;
+   fptr->mode = modef;
+   fptr->pid = pid;
+
+   if(modef & FMODE_READABLE){
+      fptr->f  = f1;
+   }
+
+   if(modef & FMODE_WRITABLE){
+      if(fptr->f){
+         fptr->f2 = f1;
+      }
+      else{
+         fptr->f = f1;
+      }
+      fptr->mode |= FMODE_SYNC;
+   }
+
+   modef = rb_io_mode_flags(m1);
+   p2 = io_alloc(rb_cIO);
+   MakeOpenFile(p2, fptr);
+
+   pid_handle = hProcess;
+   fptr->finalize = win32_pipe_finalize;
+   fptr->mode = modef;
+   fptr->pid = pid;
+
+   if(modef & FMODE_READABLE){
+      fptr->f  = f2;
+   }
+   if(modef & FMODE_WRITABLE){
+      if(fptr->f){
+         fptr->f2 = f2;
+      }
+      else{
+         fptr->f = f2;
+      }
+      fptr->mode |= FMODE_SYNC;
+   }
+
+   modef = rb_io_mode_flags(m1);
+   p3 =  io_alloc(rb_cIO);
+   MakeOpenFile(p3, fptr);
+
+   fptr->finalize = win32_pipe_finalize;
+   fptr->mode = modef;
+   fptr->pid = pid;
+
+   if(modef & FMODE_READABLE){
+      fptr->f  = f3;
+   }
+
+   if(modef & FMODE_WRITABLE){
+      if(fptr->f){
+         fptr->f2 = f3;
+      }
+      else{
+         fptr->f = f3;
+      }
+      fptr->mode |= FMODE_SYNC;
+   }
+
+   port = rb_ary_new2(4);
+   rb_ary_push(port,(VALUE)p1);
+   rb_ary_push(port,(VALUE)p2);
+   rb_ary_push(port,(VALUE)p3);
+   rb_ary_push(port,UINT2NUM((DWORD)pid));
+
+  /* Child is launched. Close the parents copy of those pipe
+   * handles that only the child should have open.  You need to
+   * make sure that no handles to the write end of the output pipe
+   * are maintained in this process or else the pipe will not close
+   * when the child process exits and the ReadFile() will hang.
+   */
+
+   if(!CloseHandle(hChildStdinRd)){
+      rb_raise(rb_eRuntimeError, "CloseHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   if(!CloseHandle(hChildStdoutWr)){
+      rb_raise(rb_eRuntimeError, "CloseHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+
+   if(!CloseHandle(hChildStderrWr)){
+      rb_raise(rb_eRuntimeError, "CloseHandle() failed: %s",
+         ErrorDescription(GetLastError())
+      );
+   }
+   
+   return port;
+}
+
+/*
+ * Spawn an external program and retrieve the stdin, stdout and stderr IO
+ * handles, as well as the process ID. Use in block or non-block form.
+ */
+void Init_open3()
+{
+   VALUE mOpen3 = rb_define_module("Open3");
+   
+   VALUE mOpen4 = rb_define_module("Open4");
+
+   rb_define_module_function(mOpen3, "popen3", win32_popen3, -1);
+   rb_define_module_function(mOpen4, "popen4", win32_popen3, -1);
+   
+   /* 0.2.6: The version of this library */
+   rb_define_const(mOpen3, "WIN32_OPEN3_VERSION", rb_str_new2(WIN32_OPEN3_VERSION));
+   
+   /* 0.2.6: The version of this library */
+   rb_define_const(mOpen4, "WIN32_OPEN3_VERSION", rb_str_new2(WIN32_OPEN3_VERSION));
+}

data/test/tc_open3.rb

@@ -0,0 +1,98 @@
+###########################################################################
+# tc_open3.rb
+#
+# Test suite for the win32-open3 library.  Except for the
+# 'test_open3_with_arguments' test and Open4 tests, this suite passes
+# on Unix as well.
+#
+# You should run this test suite via the 'rake test' task.
+###########################################################################
+require 'win32/open3'
+require 'test/unit'
+
+class TC_Win32_Open3 < Test::Unit::TestCase
+   def setup
+      @good_cmd = 'ver'
+      @bad_cmd  = 'verb'
+   end
+
+   def test_open3_version
+      assert_equal('0.2.6', Open3::WIN32_OPEN3_VERSION)
+      assert_equal('0.2.6', Open4::WIN32_OPEN3_VERSION)
+   end
+   
+   def test_open3_basic
+      assert_respond_to(Open3, :popen3)
+      assert_nothing_raised{ Open3.popen3(@good_cmd) }
+      assert_nothing_raised{ Open3.popen3(@bad_cmd) }
+   end
+   
+   def test_open4_basic
+      assert_respond_to(Open4, :popen4)
+      assert_nothing_raised{ Open4.popen4(@good_cmd) }
+      assert_nothing_raised{ Open4.popen4(@bad_cmd) }
+   end
+   
+   # This test would fail on other platforms
+   def test_open3_with_arguments
+      assert_nothing_raised{ Open3.popen3(@good_cmd, 't') }
+      assert_nothing_raised{ Open3.popen3(@bad_cmd, 't') }
+      assert_nothing_raised{ Open3.popen3(@good_cmd, 'b') }
+      assert_nothing_raised{ Open3.popen3(@bad_cmd, 'b') }
+      assert_nothing_raised{ Open3.popen3(@good_cmd, 't', false) }
+      assert_nothing_raised{ Open3.popen3(@good_cmd, 't', true) }
+   end
+   
+   def test_open3_handles
+      arr = Open3.popen3(@good_cmd)
+      assert_kind_of(Array, arr)
+      assert_kind_of(IO, arr[0])
+      assert_kind_of(IO, arr[1])
+      assert_kind_of(IO, arr[2])
+   end
+   
+   def test_open3_block
+      assert_nothing_raised{ Open3.popen3(@good_cmd){ |pin, pout, perr| } }
+      Open3.popen3(@good_cmd){ |pin, pout, perr|
+         assert_kind_of(IO, pin)
+         assert_kind_of(IO, pout)
+         assert_kind_of(IO, perr)
+      }
+   end
+   
+   def test_open4_block
+      assert_nothing_raised{ Open4.popen4(@good_cmd){ |pin, pout, perr, pid| } }
+      Open4.popen4(@good_cmd){ |pin, pout, perr, pid|
+         assert_kind_of(IO, pin)
+         assert_kind_of(IO, pout)
+         assert_kind_of(IO, perr)
+         assert_kind_of(Fixnum, pid)
+      }
+   end
+   
+   def test_open4_return_values
+      arr = Open4.popen4(@good_cmd)
+      assert_kind_of(Array,arr)
+      assert_kind_of(IO, arr[0])
+      assert_kind_of(IO, arr[1])
+      assert_kind_of(IO, arr[2])
+      assert_kind_of(Fixnum, arr[3])
+   end
+   
+   def test_handle_good_content
+      fin, fout, ferr = Open3.popen3(@good_cmd)
+      assert_kind_of(String, fout.gets)
+      assert_nil(ferr.gets)
+   end
+   
+   def test_handle_bad_content
+      fin, fout, ferr = Open3.popen3(@bad_cmd)
+      assert_kind_of(String, ferr.gets)
+      assert_nil(fout.gets)
+   end
+   
+   def teardown
+      @good_cmd = nil
+      @bad_cmd  = nil
+   end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: win32-open3
+version: !ruby/object:Gem::Version 
+  version: 0.2.6
+platform: x86-mswin32-60
+authors: 
+- Daniel J. Berger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-01 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: Provides an Open3.popen3 implementation for MS Windows
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+- doc/open3.txt
+- ext/win32/open3.c
+files: 
+- doc/open3.txt
+- test/tc_open3.rb
+- lib/win32
+- lib/win32/open3.so
+- CHANGES
+- README
+- MANIFEST
+- ext/win32/open3.c
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/win32utils
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: win32utils
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: Provides an Open3.popen3 implementation for MS Windows
+test_files: 
+- test/tc_open3.rb