win32-pipe 0.2.0

data/CHANGES

@@ -0,0 +1,34 @@
+== 0.2.0 - 28-May-2008
+* Now pure Ruby.
+* Major interface change. Pipe::Server.new and Pipe::Client.new replace the
+  Pipe.new_server and Pipe.new_client methods, respectively.
+* An optional 3rd argument, the open mode, is now accepted which allows finer
+  control over how pipes are created.
+* Several pipe mode and open mode constants were added.
+* The asynchronous pipe server actually works now.
+* Added the Pipe#name method.
+* Added the Pipe#asynchronous? method.
+* Added the Pipe#size method as an alias for Pipe#length.
+* Added a Rakefile with tasks for testing and installation.
+* Added a gemspec and uploaded a gem file to RubyForge.
+* Merged the doc files into the README and/or replaced them with inlined
+  comments that are RDoc friendly.
+
+== 0.1.2 - 1-Mar-2005
+* Moved the 'examples' directory to the toplevel directory.
+* Made the CHANGES and README files rdoc friendly.
+
+== 0.1.1 - 25-Aug-2004
+* Added many more tests to the test suite.
+* Moved the example programs to doc/examples.
+* Fixed minor bugs in the asynchronous client and server test programs.
+* Removed the pipe.html file.  You can generate your own html documentation
+  using rd2 on the pipe.rd file.
+
+== 0.1.0 - 13-Feb-2004
+* Asynchronous support added (thanks Park Heesob)
+* Sample test programs added.  See files under 'test'.
+* Documentation updates.
+
+== 0.0.1 - 20-Nov-2003
+* Initial release

data/MANIFEST

@@ -0,0 +1,15 @@
+* MANIFEST
+* README
+* CHANGES
+* Rakefile
+* win32-pipe.gemspec
+* examples/test_server.rb
+* examples/test_server_async.rb
+* examples/test_client.rb
+* examples/test_client_async.rb
+* lib/win32/pipe.rb
+* lib/win32/pipe/client.rb
+* lib/win32/pipe/server.rb
+* test/tc_pipe.rb
+* test/tc_pipe_client.rb
+* test/tc_pipe_server.rb

data/README

@@ -0,0 +1,56 @@
+= Description
+   A Ruby interface for named pipes on Windows.
+
+= Prerequisites
+* windows-pr 0.8.5 or later
+
+= Installation
+== Local
+   rake install (non-gem) or rake install_gem (gem)
+
+== Remote
+   gem install win32-pipe
+
+= Synopsis
+   require 'win32/pipe'
+   include Win32
+    
+   # In server.rb
+   pipe_server = Pipe::Server.new("foo_pipe")
+   pipe_server.connect
+   data = pipe_server.read
+   puts "Got #{data} from client"
+   pipe_server.close
+    
+   # In client.rb (run from a different shell)
+   pipe_client = Pipe::Client.new("foo_pipe")
+   pipe_client.write("Hello World")
+   pipe_client.close
+
+= What's a named pipe?
+   A pipe with a name - literally. In practice, it will feel more like a cross
+   between a socket and a pipe. At least, it does to me.
+
+= What good is it?
+   My hope is that it can be used in certain circumstances where a fork might
+   be desirable, but which is not possible on Windows. It could also be handy
+   for the traditional "piping data to a server" usage.  And if you come up
+   with anything cool, please let us all know!
+
+= Future Plans
+* Add transactions
+
+= License
+   Ruby's
+
+= 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.
+
+= Copyright
+   (C) 2003-2008, Daniel J. Berger, All Rights Reserved.
+
+= Authors
+   Daniel Berger
+   Park Heesob

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rbconfig'
+include Config
+
+desc 'Install the win32-pipe library (non-gem)'
+task :install do
+   sitelibdir = CONFIG['sitelibdir']
+
+   pipe_installdir = File.join(sitelibdir, 'win32')
+   sub_installdir = File.join(sitelibdir, 'win32', 'pipe')
+
+   pipe_file   = File.join('lib', 'win32', 'pipe.rb')
+   client_file = File.join('lib', 'win32', 'pipe', 'client.rb')
+   server_file = File.join('lib', 'win32', 'pipe', 'server.rb')
+   
+   FileUtils.mkdir_p(sub_installdir)
+
+   FileUtils.cp(pipe_file, pipe_installdir, :verbose => true)   
+   FileUtils.cp(client_file, sub_installdir, :verbose => true)   
+   FileUtils.cp(server_file, sub_installdir, :verbose => true)   
+end
+
+desc 'Install the win32-pipe library'
+task :install_c => [:build] do
+   Dir.chdir('ext'){
+      sh 'nmake install'
+   }
+end
+
+desc "Clean any build files for win32-pipe"
+task :clean do
+   Dir.chdir('ext') do
+      if File.exists?('pipe.so') ||
+         File.exists?('win32/pipe.so')
+      then
+         sh 'nmake distclean'
+         rm 'win32/pipe.so' if File.exists?('win32/pipe.so') 
+      end
+   end
+end
+
+desc "Build win32-pipe (but don't install it)"
+task :build => [:clean] do
+   Dir.chdir('ext') do
+      ruby 'extconf.rb'
+      sh 'nmake'
+      mv 'pipe.so', 'win32' # For the test suite
+   end
+end
+
+desc "Run the sample program"
+task :example do |t|
+   Dir.chdir('examples'){
+      sh 'ruby test.rb'
+   }
+end
+
+Rake::TestTask.new('test') do |test|
+   test.libs << 'lib/win32'
+   test.libs << 'lib/win32/pipe'
+   test.test_files = FileList['test/tc*']
+   test.warning = true
+end

data/examples/test_client.rb

@@ -0,0 +1,30 @@
+#########################################################################
+# test_client.rb
+#
+# Simple client test.  Be sure to start the server first in a separate
+# terminal. You can run this example via the 'rake example_client' task.
+#
+# Modify this code as you see fit.
+#########################################################################
+require 'win32/pipe'
+include Win32
+
+Thread.new { loop { sleep 0.01 } } # Allow Ctrl-C
+
+puts "VERSION: " + Pipe::VERSION
+
+# Block form
+Pipe::Client.new('foo') do |pipe|
+   puts "Connected..."
+   pipe.write("Ruby rocks!")
+   data = pipe.read
+   puts "Got [#{data}] back from server"
+end
+
+# Non-block form
+#pclient = Pipe::Client.new('foo')
+#puts "Connected..."
+#pclient.write("Ruby rocks!")
+#data = pclient.read
+#puts "Got [#{data}] back from server"
+#pclient.close

data/examples/test_client_async.rb

@@ -0,0 +1,82 @@
+#########################################################################
+# test_client_async.rb
+#
+# Simple client test. Be sure to start the server first in a separate
+# terminal. You can run this example via the 'rake example_async_client'
+# task.
+#########################################################################
+require 'win32/pipe'
+include Win32
+
+puts "VERSION: " + Pipe::VERSION
+
+Thread.new { loop { sleep 0.01 } } # Allow Ctrl-C
+
+CONNECTING_STATE = 0
+READING_STATE    = 1
+WRITING_STATE    = 2
+
+class MyPipe < Pipe::Client
+   def read_complete
+      puts "read_complete"
+      puts "Got [#{buffer}] back from server"
+      @state = WRITING_STATE
+   end
+    
+   def write_complete
+      puts "write_complete"
+      @state = READING_STATE
+   end
+ 
+   def mainloop
+      @state = WRITING_STATE
+      while true
+         if wait(1)          # wait for 1 second
+            if pending?      # IO is pending
+               case @state
+                  when READING_STATE
+                     if transferred == 0
+                        reconnect
+                        break
+                     end
+                     read_complete
+                     break
+                  when WRITING_STATE
+                     if transferred != length
+                        reconnect
+                        break
+                     end
+                     write_complete
+               end
+            end
+
+            case @state
+               when READING_STATE
+                  if read
+                     if not pending?
+                        read_complete
+                        break
+                     end
+                  end
+               when WRITING_STATE
+                  if write("Ruby rocks!")
+                     if not pending?
+                        write_complete
+                     end
+                  end
+            end
+         end
+	    
+         sleep(1)
+         puts "pipe client is running"
+      end    
+   end
+end
+
+flags = Pipe::DEFAULT_OPEN_MODE | Pipe::OVERLAPPED
+
+MyPipe.new('foo', nil, flags) do |client|
+   puts "Connected..."
+   client.mainloop
+end
+    

data/examples/test_server.rb

@@ -0,0 +1,33 @@
+#########################################################################
+# test_server.rb
+#
+# A simple named pipe server.  Start this up in its own terminal window.
+# You may have to use the task manager to kill it if you don't connect
+# with the test client program.
+#
+# You can start this server with the 'rake example_server' task. Modify
+# this code as you see fit.
+#########################################################################
+require 'win32/pipe'
+include Win32
+
+Thread.new { loop { sleep 0.01 } } # Allow Ctrl-C
+
+puts "VERSION: " + Pipe::VERSION
+
+# Block form
+Pipe::Server.new('foo') do |pipe|
+   pipe.connect
+   data = pipe.read
+   puts "Got [#{data}]"
+   pipe.write "Thanks for the data!"
+end
+
+# Non-block form
+#pserver = Pipe::Server.new('foo')
+#pserver.connect # put server in wait connect
+#data = pserver.read
+#puts "Got [#{data}]"
+#pserver.write("Thanks for the data!")
+#pserver.disconnect
+#pserver.close

data/examples/test_server_async.rb

@@ -0,0 +1,100 @@
+#######################################################################
+# test_server_async.rb
+#
+# A simple, asynchronous named pipe server. Start this up in its own
+# terminal window. You can run this program via the
+# 'rake example_async_server' task.
+#######################################################################
+require 'win32/pipe'
+include Win32
+
+puts "VERSION: " + Pipe::VERSION
+
+Thread.new { loop { sleep 0.01 } } # Allow Ctrl-C
+
+CONNECTING_STATE = 0
+READING_STATE    = 1
+WRITING_STATE    = 2
+
+class MyPipe < Pipe::Server
+   def connected
+      puts "connected"
+      @state = READING_STATE
+   end
+   
+   def read_complete
+      puts "read_complete"
+      puts "Got [#{buffer}]"       
+      @state = WRITING_STATE
+   end
+   
+   def write_complete
+      puts "write_complete"
+      disconnect
+      @state = CONNECTING_STATE
+   end
+   
+   def reconnect
+      disconnect
+      mainloop
+   end
+   
+   def mainloop
+      @state = CONNECTING_STATE
+      while true
+         if wait(1)          # wait for 1 second
+            if pending?      # IO is pending
+               case @state
+                  when CONNECTING_STATE
+                     connected
+                  when READING_STATE
+                     if transferred == 0
+                        reconnect
+                        break
+                     end
+                     read_complete
+                  when WRITING_STATE
+                     if transferred != length
+                        reconnect
+                        break
+                     end
+                     write_complete
+               end
+            end
+
+            case @state
+               when CONNECTING_STATE
+                  if connect
+                     connected
+                  end 
+               when READING_STATE
+                  if read
+                     if !pending?
+                        read_complete
+                     end
+                  else
+                      reconnect
+                  end
+               when WRITING_STATE
+                  if write("Thanks for the data!")
+                     if not pending?
+                        write_complete
+                     end
+                  else
+                     reconnect
+                     break
+                  end
+               end
+         end
+ 
+         sleep(1)
+         puts "pipe server is running"
+      end
+   end
+end
+
+flags = Pipe::ACCESS_DUPLEX | Pipe::OVERLAPPED
+
+MyPipe.new('foo', 0, flags) do |pipe|
+   pipe.mainloop
+end

data/lib/win32/pipe.rb

@@ -0,0 +1,253 @@
+require 'windows/pipe'
+require 'windows/synchronize'
+require 'windows/handle'
+require 'windows/file'
+require 'windows/error'
+
+# The Win32 module serves as a namespace only.
+module Win32
+   # The Pipe class is an abstract base class for the Pipe::Server and
+   # Pipe::Client classes. Do not use this directly.
+   #
+   class Pipe
+      include Windows::Pipe
+      include Windows::Synchronize
+      include Windows::Handle
+      include Windows::File
+      include Windows::Error
+      
+      class Error < StandardError; end
+      
+      # The version of this library
+      VERSION = '0.2.0'
+
+      PIPE_BUFFER_SIZE = 512 #:nodoc:
+      PIPE_TIMEOUT = 5000    #:nodoc:
+      
+      # Blocking mode is enabled
+      WAIT = PIPE_WAIT
+
+      # Nonblocking mode is enabled
+      NOWAIT = PIPE_NOWAIT
+
+      # The pipe is bi-directional. Both server and client processes can read
+      # from and write to the pipe.
+      ACCESS_DUPLEX = PIPE_ACCESS_DUPLEX
+
+      # The flow of data in the pipe goes from client to server only.
+      ACCESS_INBOUND = PIPE_ACCESS_INBOUND
+
+      # The flow of data in the pipe goes from server to client only.
+      ACCESS_OUTBOUND = PIPE_ACCESS_OUTBOUND
+
+      # Data is written to the pipe as a stream of bytes.
+      TYPE_BYTE = PIPE_TYPE_BYTE
+
+      # Data is written to the pipe as a stream of messages.
+      TYPE_MESSAGE = PIPE_TYPE_MESSAGE
+
+      # Data is read from the pipe as a stream of bytes.
+      READMODE_BYTE = PIPE_READMODE_BYTE
+
+      # Data is read from the pipe as a stream of messages.
+      READMODE_MESSAGE = PIPE_READMODE_MESSAGE
+
+      # All instances beyond the first will fail with access denied errors.
+      FIRST_PIPE_INSTANCE = FILE_FLAG_FIRST_PIPE_INSTANCE
+
+      # Functions do not return until the data is written across the network.
+      WRITE_THROUGH = FILE_FLAG_WRITE_THROUGH
+
+      # Overlapped mode enables asynchronous communication.
+      OVERLAPPED = FILE_FLAG_OVERLAPPED
+
+      # The default pipe mode
+      DEFAULT_PIPE_MODE = NOWAIT
+
+      # The default open mode
+      DEFAULT_OPEN_MODE = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH
+      
+      # The data still in the pipe's buffer
+      attr_reader :buffer
+      
+      # The number of bytes to be written to the pipe.
+      attr_reader :size
+      
+      # The number of characters that are actually transferred over the pipe.
+      attr_reader :transferred
+      
+      # The full name of the pipe, e.g. "\\\\.\\pipe\\my_pipe"
+      attr_reader :name
+
+      # The pipe mode of the pipe.
+      attr_reader :open_mode
+
+      # The open mode of the pipe.
+      attr_reader :pipe_mode
+      
+      # Abstract initializer for base class. This handles automatic prepending
+      # of '\\.\pipe\' to each named pipe so that you don't have to.  Don't
+      # use this directly. Add the full implementation in subclasses.
+      #
+      # The default pipe mode is PIPE_WAIT.
+      #
+      # The default open mode is FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH.
+      #
+      def initialize(name, pipe_mode = DEFAULT_PIPE_MODE, open_mode = DEFAULT_OPEN_MODE)
+         @name      = "\\\\.\\pipe\\" + name
+
+         @pipe_mode = pipe_mode.nil? ? DEFAULT_PIPE_MODE : pipe_mode
+         @open_mode = open_mode.nil? ? DEFAULT_OPEN_MODE : open_mode
+
+         @pipe         = nil
+         @pending_io   = false
+         @buffer       = 0.chr * PIPE_BUFFER_SIZE
+         @size         = 0
+         @overlapped   = 0.chr * 20 # sizeof(OVERLAPPED)
+         @transferred  = 0
+         @asynchronous = false
+
+         if open_mode & FILE_FLAG_OVERLAPPED > 0
+            @asynchronous = true
+         end
+
+         if @asynchronous
+            @event = CreateEvent(nil, true, true, nil)
+            @overlapped[16, 4] = [@event].pack('L')
+         end
+      end
+      
+      # Disconnects the pipe.
+      def disconnect
+         DisconnectNamedPipe(@pipe)
+      end
+      
+      # Closes the pipe.
+      # 
+      def close
+         CloseHandle(@pipe)
+      end
+      
+      # Returns whether or not there is a pending IO operation on the pipe.
+      # 
+      def pending?
+         @pending_io
+      end
+      
+      # Returns whether or not the pipe is asynchronous.
+      #
+      def asynchronous?
+         @asynchronous
+      end
+      
+      # Reads data from the pipe. You can read data from either end of a named
+      # pipe.
+      # 
+      def read
+         bytes = [0].pack('L')
+         @buffer = 0.chr * PIPE_BUFFER_SIZE
+         
+         if @asynchronous
+            bool = ReadFile(@pipe, @buffer, @buffer.size, bytes, @overlapped)
+
+            bytes_read = bytes.unpack('L').first
+
+            if bool && bytes_read > 0
+               @pending_io = false
+               @buffer = @buffer[0, bytes_read]
+               return true
+            end
+
+            error = GetLastError()
+            if !bool && error == ERROR_IO_PENDING
+               @pending_io = true
+               return true
+            end
+
+            return false
+         else
+            unless ReadFile(@pipe, @buffer, @buffer.size, bytes, nil)
+               raise Error, get_last_error
+            end
+         end
+         
+         @buffer.unpack("A*")
+      end
+      
+      # Writes 'data' to the pipe. You can write data to either end of a
+      # named pipe.
+      # 
+      def write(data)
+         @buffer = data
+         @size   = data.size
+         bytes   = [0].pack('L')
+
+         if @asynchronous
+            bool = WriteFile(@pipe, @buffer, @buffer.size, bytes, @overlapped)
+
+            bytes_written = bytes.unpack('L').first
+
+            if bool && bytes_written > 0
+               @pending_io = false
+               return true
+            end
+
+            error = GetLastError()
+
+            if !bool && error == ERROR_IO_PENDING
+               @pending_io = true
+               return true
+            end
+
+            return false
+         else
+            unless WriteFile(@pipe, @buffer, @buffer.size, bytes, 0)
+               raise Error, get_last_error
+            end
+
+            return true
+         end
+      end   
+
+      # Returns the pipe object if an event (such as a client connection)
+      # occurs within the +max_time+ specified (in seconds). Otherwise, it
+      # returns false.
+      #
+      def wait(max_time = nil)
+         unless @asynchronous
+            raise Error, 'cannot wait in synchronous (blocking) mode'
+         end
+
+         max_time = max_time ? max_time * 1000 : INFINITE
+
+         wait = WaitForSingleObject(@event, max_time)
+
+         if wait == WAIT_TIMEOUT
+            return false
+         else
+            if wait != WAIT_OBJECT_0
+               raise Error, get_last_error
+            end
+         end
+
+         if @pending_io
+            transferred = [0].pack('L')
+            bool = GetOverlappedResult(@pipe, @overlapped, transferred, false)
+
+            unless bool
+               raise Error, get_last_error
+            end
+
+            @transferred = transferred.unpack('L')[0]
+            @buffer = @buffer[0, @transferred]
+         end
+
+         self
+      end
+      
+      alias length size
+   end
+end
+
+require 'win32/pipe/server'
+require 'win32/pipe/client'

data/lib/win32/pipe/client.rb

@@ -0,0 +1,49 @@
+# The Win32 module serves as a namespace only
+module Win32
+   # The Pipe::Client class encapsulates the client side of a named pipe
+   # connection.
+   #
+   class Pipe::Client < Pipe
+      # Create and return a new Pipe::Client instance.
+      #
+      # The default pipe mode is PIPE_WAIT.
+      #
+      # The default open mode is FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH.
+      #--
+      # 2147483776 is FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH
+      def initialize(name, pipe_mode = DEFAULT_PIPE_MODE, open_mode = DEFAULT_OPEN_MODE)
+         super(name, pipe_mode, open_mode)
+         
+         @pipe = CreateFile(
+            @name,
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            nil,
+            OPEN_EXISTING,
+            @open_mode,
+            nil 
+         )
+
+         error = GetLastError()
+         
+         if error == ERROR_PIPE_BUSY
+            unless WaitNamedPipe(@name, NMPWAIT_WAIT_FOREVER)
+               raise Error, get_last_error
+            end
+         end
+         
+         if @pipe == INVALID_HANDLE_VALUE
+            raise Error, get_last_error
+         end
+         
+         if block_given?
+            begin
+               yield self
+            ensure
+               disconnect
+               close
+            end
+         end
+      end
+   end
+end

data/lib/win32/pipe/server.rb

@@ -0,0 +1,96 @@
+# The Win32 module serves as a namespace only.
+module Win32
+   # The Pipe::Server class encapsulates the server side of a named pipe
+   # connection.
+   class Pipe::Server < Pipe
+   
+      # Creates and returns a new Pipe::Server instance, using +name+ as the
+      # name for the pipe. Note that this does not actually connect the pipe.
+      # Use Pipe::Server#connect for that.
+      #
+      # The default pipe_mode is PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT.
+      #
+      # The default open_mode is Pipe::ACCESS_DUPLEX.
+      #--
+      # The default pipe_mode also happens to be 0.
+      # 
+      def initialize(name, pipe_mode = 0, open_mode = Pipe::ACCESS_DUPLEX)
+         super(name, pipe_mode, open_mode)
+         
+         @pipe = CreateNamedPipe(
+            @name,
+            @open_mode,
+            @pipe_mode,
+            PIPE_UNLIMITED_INSTANCES,
+            PIPE_BUFFER_SIZE,
+            PIPE_BUFFER_SIZE,
+            PIPE_TIMEOUT,
+            0
+         )
+         
+         if @pipe == INVALID_HANDLE_VALUE
+            raise Error, get_last_error
+         end
+
+         if block_given?
+            begin
+               yield self
+            ensure
+               close
+            end
+         end
+      end
+      
+      # Enables the named pipe server process to wait for a client process
+      # to connect to an instance of a named pipe. In other words, it puts
+      # the server in 'connection wait' status.
+      #
+      # In synchronous mode always returns true on success. In asynchronous
+      # mode returns true if there is pending IO, or false otherwise.
+      # 
+      def connect
+         if @asynchronous
+            # An overlapped ConnectNamedPipe should return 0
+            if ConnectNamedPipe(@pipe, @overlapped)
+               raise Error, get_last_error
+            end
+            
+            error = GetLastError()
+
+            case error
+               when ERROR_IO_PENDING
+                  @pending_io = true
+               when ERROR_PIPE_CONNECTED
+                  unless SetEvent(@event)
+                     raise Error, get_last_error(error)
+                  end
+               when ERROR_PIPE_LISTENING
+                  # Do nothing
+               else
+                  raise Error, get_last_error(error)
+            end
+
+            if @pending_io
+               return false
+            else
+               return true
+            end
+         else
+            unless ConnectNamedPipe(@pipe, nil)
+               raise Error, get_last_error
+            end
+         end
+
+         return true
+      end
+      
+      # Close the server. This will flush file buffers, disconnect the
+      # pipe, and close the pipe handle.
+      #
+      def close
+         FlushFileBuffers(@pipe)
+         DisconnectNamedPipe(@pipe)
+         super
+      end
+   end
+end

data/test/tc_pipe.rb

@@ -0,0 +1,122 @@
+##########################################################################
+# tc_pipe.rb
+#
+# Test suite for the win32-pipe library. This test suite should be run
+# via the 'rake test' task.
+##########################################################################
+require 'test/unit'
+require 'win32/pipe'
+include Win32
+
+class TC_Win32_Pipe < Test::Unit::TestCase
+   def setup
+      @pipe = Pipe.new('foo')
+   end
+   
+   def test_version
+      assert_equal('0.2.0', Pipe::VERSION)
+   end
+
+   def test_name
+      assert_respond_to(@pipe, :name)
+      assert_nothing_raised{ @pipe.name }
+      assert_equal("\\\\.\\pipe\\foo", @pipe.name)
+   end
+
+   def test_pipe_mode
+      assert_respond_to(@pipe, :pipe_mode)
+      assert_nothing_raised{ @pipe.pipe_mode }
+      assert_equal(Pipe::DEFAULT_PIPE_MODE, @pipe.pipe_mode)
+   end
+
+   def test_open_mode
+      assert_respond_to(@pipe, :open_mode)
+      assert_nothing_raised{ @pipe.open_mode }
+      assert_equal(Pipe::DEFAULT_OPEN_MODE, @pipe.open_mode)
+   end
+   
+   def test_buffer
+      assert_respond_to(@pipe, :buffer)
+      assert_nothing_raised{ @pipe.buffer }
+   end
+   
+   def test_size
+      assert_respond_to(@pipe, :size)
+      assert_nothing_raised{ @pipe.size }
+   end
+   
+   def test_length_alias
+      assert_respond_to(@pipe, :length)
+      assert_equal(true, @pipe.method(:length) == @pipe.method(:size))
+   end
+   
+   def test_pending
+      assert_respond_to(@pipe, :pending?)
+      assert_nothing_raised{ @pipe.pending? }
+      assert_equal(false, @pipe.pending?)
+   end
+
+   def test_asynchronous
+      assert_respond_to(@pipe, :asynchronous?)
+      assert_nothing_raised{ @pipe.asynchronous? }
+      assert_equal(false, @pipe.asynchronous?)
+   end
+   
+   def test_read
+      assert_respond_to(@pipe, :read)
+      assert_raises(Pipe::Error){ @pipe.read } # Nothing to read
+   end
+   
+   def test_transferred
+      assert_respond_to(@pipe, :transferred)
+      assert_nothing_raised{ @pipe.transferred }
+   end
+   
+   def test_wait
+      assert_respond_to(@pipe, :wait)
+      assert_raises(Pipe::Error){ @pipe.wait } # Can't wait in blocking mode
+   end
+   
+   def test_write
+      assert_respond_to(@pipe, :write)
+      assert_raises(ArgumentError){ @pipe.write }    # Must have 1 argument
+      assert_raises(Pipe::Error){ @pipe.write("foo") } # Nothing to write to
+   end
+
+   def test_disconnect
+      assert_respond_to(@pipe, :disconnect)
+      assert_nothing_raised{ @pipe.disconnect }
+   end
+
+   def test_close
+      assert_respond_to(@pipe, :close)
+      assert_nothing_raised{ @pipe.close }
+   end
+   
+   def test_pipe_mode_constants
+      assert_not_nil(Pipe::WAIT)
+      assert_not_nil(Pipe::NOWAIT)
+      assert_not_nil(Pipe::TYPE_BYTE)
+      assert_not_nil(Pipe::TYPE_MESSAGE)
+      assert_not_nil(Pipe::READMODE_BYTE)
+      assert_not_nil(Pipe::READMODE_MESSAGE)
+   end
+
+   def test_open_mode_constants
+      assert_not_nil(Pipe::ACCESS_DUPLEX)
+      assert_not_nil(Pipe::ACCESS_INBOUND)
+      assert_not_nil(Pipe::ACCESS_OUTBOUND)
+      assert_not_nil(Pipe::FIRST_PIPE_INSTANCE)
+      assert_not_nil(Pipe::WRITE_THROUGH)
+      assert_not_nil(Pipe::OVERLAPPED)
+   end
+
+   def test_other_constants
+      assert_not_nil(Pipe::INFINITE)
+   end
+   
+   def teardown
+      @pipe.close
+      @pipe = nil
+   end
+end

data/test/tc_pipe_client.rb

@@ -0,0 +1,28 @@
+##########################################################################
+# tc_pipe_client.rb
+#
+# Test suite for the Pipe::Client class. This test suite should be run
+# as part of the 'rake test' task.
+##########################################################################
+require 'test/unit'
+require 'win32/pipe'
+include Win32
+
+class TC_Win32_Pipe_Client < Test::Unit::TestCase
+   def setup
+      @pipe = nil
+   end
+
+   def test_constructor_basic
+      assert_respond_to(Pipe::Client, :new)
+   end
+
+   def test_constructor_expected_errors
+      assert_raise(ArgumentError){ Pipe::Client.new }
+      assert_raise(TypeError){ Pipe::Client.new(1) }
+   end
+
+   def teardown
+      @pipe = nil
+   end
+end

data/test/tc_pipe_server.rb

@@ -0,0 +1,34 @@
+##########################################################################
+# tc_pipe_server.rb
+#
+# Test suite for the Pipe::Server class. This test suite should be run
+# as part of the 'rake test' task.
+##########################################################################
+require 'test/unit'
+require 'win32/pipe'
+include Win32
+
+class TC_Win32_Pipe_Server < Test::Unit::TestCase
+   def setup
+      @pipe = nil
+   end
+
+   def test_constructor_basic
+      assert_respond_to(Pipe::Server, :new)
+      assert_nothing_raised{ Pipe::Server.new('foo') }
+   end
+
+   def test_connect
+      assert_nothing_raised{ @pipe = Pipe::Server.new('foo') }
+      assert_respond_to(@pipe, :connect)
+   end
+
+   def test_constructor_expected_errors
+      assert_raise(ArgumentError){ Pipe::Server.new }
+      assert_raise(TypeError){ Pipe::Server.new(1) }
+   end
+
+   def teardown
+      @pipe = nil
+   end
+end

data/win32-pipe.gemspec

@@ -0,0 +1,26 @@
+require "rubygems"
+
+spec = Gem::Specification.new do |gem|
+	gem.name         = "win32-pipe"
+	gem.version      = "0.2.0"
+	gem.author       = "Daniel J. Berger"
+	gem.email        = "djberg96@gmail.com"
+	gem.homepage     = "http://www.rubyforge.org/projects/win32utils"
+	gem.platform     = Gem::Platform::RUBY
+	gem.summary      = "An interface for named pipes on MS Windows" 
+	gem.description  = "An interface for named pipes on MS Windows"
+	gem.test_files   = Dir["test/tc_*.rb"]
+	gem.has_rdoc     = true
+	gem.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
+	gem.rubyforge_project = "win32utils"
+	
+	files = Dir["doc/*"] + Dir["examples/*"] + Dir["lib/win32/**/*.rb"]
+	files += Dir["test/*"] + Dir["[A-Z]*"]
+	files.delete_if{ |item| item.include?("CVS") }
+	gem.files = files
+end
+
+if $0 == __FILE__
+   Gem.manage_gems
+   Gem::Builder.new(spec).build
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: win32-pipe
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+date: 2008-05-28 00:00:00 -06:00
+summary: An interface for named pipes on MS Windows
+require_paths: 
+- lib
+email: djberg96@gmail.com
+homepage: http://www.rubyforge.org/projects/win32utils
+rubyforge_project: win32utils
+description: An interface for named pipes on MS Windows
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Daniel J. Berger
+files: 
+- examples/test_client.rb
+- examples/test_client_async.rb
+- examples/test_server.rb
+- examples/test_server_async.rb
+- lib/win32/pipe/client.rb
+- lib/win32/pipe/server.rb
+- lib/win32/pipe.rb
+- test/tc_pipe.rb
+- test/tc_pipe_client.rb
+- test/tc_pipe_server.rb
+- CHANGES
+- examples
+- ext
+- lib
+- MANIFEST
+- Rakefile
+- README
+- test
+- win32-pipe.gemspec
+test_files: 
+- test/tc_pipe.rb
+- test/tc_pipe_client.rb
+- test/tc_pipe_server.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- CHANGES
+- README
+- MANIFEST
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+