win32-open3 0.2.5

data/CHANGES

@@ -0,0 +1,37 @@
+== 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,14 @@
+CHANGES
+MANIFEST
+README
+win32-open3.gemspec
+
+doc/open3.txt
+
+examples/open3_test.rb
+
+ext/extconf.rb
+ext/open3.c
+ext/open3.h
+
+test/tc_open3.rb

data/README

@@ -0,0 +1,64 @@
+= Description
+   This package provides an Open3.popen3 implementation for Win32 systems
+
+= Prerequisites
+   Ruby 1.8.0 or later
+   C++ compiler (if building from source).
+   
+= Installation
+== Manual Installation
+   cd ext
+   ruby extconf.rb
+   nmake
+   ruby tc_open3.rb (optional, in the 'test' directory)
+   nmake install
+== Gem Installation
+   ruby win32-open3.gemspec
+   gem install win32-open3-X.Y.Z.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 package is not supported on Windows 95, 98, or ME.
+   This is a stripped down version of Park Heesob's win32_popen package.
+
+= 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
+   package and this package.
+
+   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 package (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.
+ 
+ = More Documentation
+   See the doc/open3.txt file for more details.

data/doc/open3.txt

@@ -0,0 +1,75 @@
+= Description
+   An open3 library for Win32
+	
+= 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-2006 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/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+have_type('rb_pid_t', 'ruby.h') # For 1.8.3 and later
+create_makefile('win32/open3')

data/ext/open3.c

@@ -0,0 +1,526 @@
+/***************************************************
+ * 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 pname, pmode, port;
+   VALUE v_show_window = Qfalse;
+   char mbuf[4];
+   int tm = 0;
+   char *mode = "t";
+
+   rb_scan_args(argc, argv, "12", &pname, &pmode, &v_show_window);
+
+   /* Mode can be either a string or a number */
+   if(!NIL_P(pmode)){
+      if(FIXNUM_P(pmode)){
+         mode = rb_io_modenum_mode(FIX2INT(pmode), mbuf);
+      }
+      else{
+         mode = StringValuePtr(pmode);
+      }
+   }
+
+   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;
+   }
+
+   port = ruby_popen(StringValuePtr(pname), tm, v_show_window);
+   
+   /* Ensure handles are closed in block form */
+   if(rb_block_given_p()) {
+      rb_ensure(rb_yield_splat, port, io_close, port);
+      return win32_last_status;
+   }
+   
+   return 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;
+
+      if (GetVersion() < 0x80000000 &&
+         _stricmp(comshell, "command.com") != 0) {
+       // NT/2000 and not using command.com.
+         x = i + strlen(s3) + strlen(cmdstring) + 1;
+         s2 = ALLOCA_N(char, x);
+        sprintf(s2, "%s%s%s", s1, s3, cmdstring);
+     }
+      else{
+        // Windows 9x or ME
+        rb_raise(rb_eRuntimeError,"not supported on this platform");
+     }
+   }
+
+   // Could be an else here to try cmd.exe / command.com in the path
+   // Now we'll just error out..
+  else {
+    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.  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(pid_handle != NULL){
+      GetExitCodeProcess(pid_handle, &status);
+      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 our HANDLE's into file descriptors and, ultimately, into
+   // 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;
+}
+
+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);
+   
+   rb_define_const(mOpen3, "WIN32_OPEN3_VERSION", rb_str_new2(WIN32_OPEN3_VERSION));
+   rb_define_const(mOpen4, "WIN32_OPEN3_VERSION", rb_str_new2(WIN32_OPEN3_VERSION));
+}

data/ext/open3.h

@@ -0,0 +1,73 @@
+#define WIN32_OPEN3_VERSION "0.2.5"
+#define MAX_STRING 512
+
+static VALUE io_alloc _((VALUE));
+
+static VALUE io_alloc(VALUE klass){
+    NEWOBJ(io, struct RFile);
+    OBJSETUP(io, klass, T_FILE);
+
+    io->fptr = 0;
+
+    return (VALUE)io;
+}
+
+int rb_io_mode_flags(const char* mode){
+    int flags = 0;
+
+    switch (mode[0]){
+      case 'r':
+         flags |= FMODE_READABLE;
+         break;
+      case 'w':
+         flags |= FMODE_WRITABLE;
+         break;
+      case 'a':
+         flags |= FMODE_WRITABLE;
+         break;
+      default:
+         error:
+         rb_raise(rb_eArgError, "illegal access mode %s", mode);
+   }
+
+   if(mode[1] == 'b'){
+      flags |= FMODE_BINMODE;
+      mode++;
+   }
+
+   if(mode[1] == '+'){
+      flags |= FMODE_READWRITE;
+      if(mode[2] != 0){
+         goto error;
+      }
+   }
+   else if(mode[1] != 0) goto error;
+
+   return flags;
+}
+
+// Return an error code as a string
+LPTSTR ErrorDescription(DWORD p_dwError)
+{
+   HLOCAL hLocal = NULL;
+   static char ErrStr[MAX_STRING];
+   int len;
+
+   if (!(len=FormatMessage(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER |
+      FORMAT_MESSAGE_FROM_SYSTEM |
+      FORMAT_MESSAGE_IGNORE_INSERTS,
+      NULL,
+      p_dwError,
+      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
+      (LPTSTR)&hLocal,
+      0,
+      NULL)))
+   {
+      rb_raise(rb_eStandardError,"Unable to format error message");
+   }
+   memset(ErrStr, 0, MAX_STRING);
+   strncpy(ErrStr, (LPTSTR)hLocal, len-2); /* remove \r\n */
+   LocalFree(hLocal);
+   return ErrStr;
+}

data/test/tc_open3.rb

@@ -0,0 +1,101 @@
+###########################################################################
+# tc_open3.rb
+#
+# Test suite for the win32-open3 package.  Except for the
+# 'test_open3_with_arguments' test and Open4 tests, this suite passes
+# on Unix as well.
+###########################################################################
+base = File.basename(Dir.pwd)
+if base == 'test' || base =~ /win32-open3/i
+   require 'ftools'
+   Dir.chdir('..') if base == 'test'
+   Dir.mkdir('win32') unless File.exists?('win32')
+   File.copy('open3.so', 'win32') if File.exists?('open3.so')
+   $LOAD_PATH.unshift Dir.pwd   
+   Dir.chdir('test') rescue nil
+end
+
+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_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,56 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: win32-open3
+version: !ruby/object:Gem::Version 
+  version: 0.2.5
+date: 2006-12-08 00:00:00 -07:00
+summary: Provides an Open3.popen3 implementation for MS Windows
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/win32utils
+rubyforge_project: win32utils
+description: Provides an Open3.popen3 implementation for MS Windows
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- doc/open3.txt
+- test/tc_open3.rb
+- ext/open3.c
+- ext/open3.h
+- CHANGES
+- README
+- MANIFEST
+test_files: 
+- test/tc_open3.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+- doc/open3.txt
+- ext/open3.c
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+