right_popen 1.0.9 → 1.0.11

data/README.rdoc

@@ -26,6 +26,11 @@ to report issues.
   @stdout_text = ""
   @stderr_text = ""
   @exit_status = nil
+  @pid = nil
+
+  def on_pid(pid)
+    @pid = pid
+  end
 
   def on_read_stdout(data)
     @stdout_text << data
@@ -45,6 +50,7 @@ to report issues.
       RightScale.popen3(:command        => command,
                         :target         => self,
                         :environment    => nil,
+                        :pid_handler    => :on_pid,
                         :stdout_handler => :on_read_stdout,
                         :stderr_handler => :on_read_stderr,
                         :exit_handler   => :on_exit)
@@ -60,6 +66,7 @@ to report issues.
   puts "@stdout_text = #{@stdout_text}"
   puts "@stderr_text = #{@stderr_text}"
   puts "@exit_status.exitstatus = #{@exit_status.exitstatus}"
+  puts "@pid = #{@pid}"
 
 
 == INSTALLATION

data/lib/linux/right_popen.rb

@@ -27,82 +27,27 @@
 
 require 'rubygems'
 require 'eventmachine'
+require 'tempfile'
 
 module RightScale
-
-  # Provides an eventmachine callback handler for the stdout stream.
-  module StdOutHandler
-
-    # === Parameters
-    # options[:input](String):: Input to be sent to child process stdin
-    # options[:target](Object):: Object defining handler methods to be called.
-    # options[:stdout_handler(String):: Token for stdout handler method name.
-    # options[:exit_handler(String):: Token for exit handler method name.
-    # options[:exec_file](String):: Path to executed file
-    # stderr_eventable(Connector):: EM object representing stderr handler.
-    # read_fd(IO):: Standard output read file descriptor.
-    # write_fd(IO):: Standard output write file descriptor.
-    def initialize(options, stderr_eventable, read_fd, write_fd)
-      @input = options[:input]
-      @target = options[:target]
-      @stdout_handler = options[:stdout_handler]
-      @exit_handler = options[:exit_handler]
-      @exec_file = options[:exec_file]
-      @stderr_eventable = stderr_eventable
-      # Just so they don't get GCed before the process goes away
-      @read_fd = read_fd
-      @write_fd = write_fd
-    end
-
-    # Send input to child process stdin
-    def post_init
-      send_data(@input) if @input
-    end
-
-    # Callback from EM to receive data.
-    def receive_data(data)
-      @target.method(@stdout_handler).call(data) if @stdout_handler
-    end
-
-    # Callback from EM to unbind.
-    def unbind
-      # We force the attached stderr handler to go away so that
-      # we don't end up with a broken pipe
-      File.delete(@exec_file) if File.file?(@exec_file)
-      @stderr_eventable.force_detach if @stderr_eventable
-      @target.method(@exit_handler).call(get_status) if @exit_handler
-    end
-  end
-
-  module StdErrHandler
-
-    # === Parameters
-    # target(Object):: Object defining handler methods to be called.
-    #
-    # stderr_handler(String):: Token for stderr handler method name.
-    # read_fd(IO):: Error output read file descriptor.
-    def initialize(target, stderr_handler, read_fd)
+  module PipeHandler
+    def initialize(target, handler)
       @target = target
-      @stderr_handler = stderr_handler
-      @unbound = false
-      @read_fd = read_fd # So it doesn't get GCed
+      @handler = handler
     end
 
-    # Callback from EM to receive data.
     def receive_data(data)
-      @target.method(@stderr_handler).call(data)
+      @target.method(@handler).call(data) if @handler
     end
-
-    # Callback from EM to unbind.
-    def unbind
-      @unbound = true
+  end
+  module InputHandler
+    def initialize(string)
+      @string = string
     end
 
-    # Forces detachment of the stderr handler on EM's next tick.
-    def force_detach
-      # Use next tick to prevent issue in EM where descriptors list
-      # gets out-of-sync when calling detach in an unbind callback
-      EM.next_tick { detach unless @unbound }
+    def post_init
+      send_data(@string) if @string
+      close_connection_after_writing
     end
   end
 
@@ -110,49 +55,64 @@ module RightScale
   # standard streams of the child process.
   #
   # === Parameters
+  # options[:pid_handler](Symbol):: Token for pid handler method name.
   # options[:temp_dir]:: Path to temporary directory where executable files are
   #                      created, default to /tmp if not specified
   #
   # See RightScale.popen3
   def self.popen3_imp(options)
-    # First write command to file so that it's possible to use popen3 with
-    # a bash command line (e.g. 'for i in 1 2 3 4 5; ...')
-    temp_dir = options[:temp_dir] || '/tmp'
-    exec_file = File.join(temp_dir, Time.new.to_i.to_s)
-    options[:exec_file] = exec_file
-    File.open(exec_file, 'w') { |f| f.puts options[:command] }
-    File.chmod(0700, exec_file)
     GC.start # To garbage collect open file descriptors from passed executions
     EM.next_tick do
-      saved_stderr = $stderr.dup
-      r, w = Socket::pair(Socket::AF_LOCAL, Socket::SOCK_STREAM, 0)#IO::pipe
-
-      $stderr.reopen w
-      c = EM.attach(r, StdErrHandler, options[:target], options[:stderr_handler], r) if options[:stderr_handler]
-
-      # Setup environment for child process
-      envs = {}
-      options[:environment].each { |k, v| envs[k.to_s] = v } if options[:environment]
-      unless envs.empty?
-        old_envs = {}
-        ENV.each { |k, v| old_envs[k] = v if envs.include?(k) }
-        envs.each { |k, v| ENV[k] = v }
+      inr, inw = IO::pipe
+      outr, outw = IO::pipe
+      errr, errw = IO::pipe
+
+      [inr, inw, outr, outw, errr, errw].each {|fdes| fdes.sync = true}
+
+      pid = fork do
+        options[:environment].each do |k, v|
+          ENV[k.to_s] = v
+        end unless options[:environment].nil?
+
+        inw.close
+        outr.close
+        errr.close
+        $stdin.reopen inr
+        $stdout.reopen outw
+        $stderr.reopen errw
+
+        if options[:command].instance_of?(String)
+          exec "sh", "-c", options[:command]
+        else
+          exec *options[:command]
+        end
       end
 
-      # Launch child process
-      EM.popen(exec_file, StdOutHandler, options, c, r, w)
-
-      # Restore environment variables
-      unless envs.empty?
-        envs.each { |k, _| ENV[k] = nil }
-        old_envs.each { |k, v| ENV[k] = v }
+      inr.close
+      outw.close
+      errw.close
+      stderr = EM.attach(errr, PipeHandler, options[:target],
+                         options[:stderr_handler])
+      stdout = EM.attach(outr, PipeHandler, options[:target],
+                         options[:stdout_handler])
+      stdin = EM.attach(inw, InputHandler, options[:input])
+
+      options[:target].method(options[:pid_handler]).call(pid) if
+        options.key? :pid_handler
+
+      wait_timer = EM::PeriodicTimer.new(1) do
+        value = Process.waitpid2(pid, Process::WNOHANG)
+        unless value.nil?
+          ignored, status = value
+          wait_timer.cancel
+          stdin.close_connection
+          stdout.close_connection
+          stderr.close_connection
+          options[:target].method(options[:exit_handler]).call(status) if
+            options[:exit_handler]
+        end
       end
-
-      # Do not close 'w', strange things happen otherwise
-      # (command protocol socket gets closed during decommission) 
-      $stderr.reopen saved_stderr
     end
     true
   end
-
 end

data/lib/right_popen.rb

@@ -45,10 +45,11 @@ module RightScale
   # All handlers must be methods exposed by the given target.
   #
   # === Parameters
-  # options[:command](String):: Command to execute, including any arguments
+  # options[:command](String or Array):: Command to execute, including any arguments as a single string or an array of command and arguments
   # options[:environment](Hash):: Hash of environment variables values keyed by name
   # options[:input](String):: Input string that will get streamed into child's process stdin
   # options[:target](Object):: object defining handler methods to be called, optional (no handlers can be defined if not specified)
+  # options[:pid_handler](String):: PID notification handler method name, optional
   # options[:stdout_handler](String):: Stdout handler method name, optional
   # options[:stderr_handler](String):: Stderr handler method name, optional
   # options[:exit_handler](String):: Exit handler method name, optional
@@ -58,7 +59,7 @@ module RightScale
   def self.popen3(options)
     raise "EventMachine reactor must be started" unless EM.reactor_running?
     raise "Missing command" unless options[:command]
-    raise "Missing target" unless options[:target] || !options[:stdout_handler] && !options[:stderr_handler] && !options[:exit_handler]
+    raise "Missing target" unless options[:target] || !options[:stdout_handler] && !options[:stderr_handler] && !options[:exit_handler] && !options[:pid_handler]
     RightScale.popen3_imp(options)
     true
   end

data/right_popen.gemspec

@@ -6,8 +6,8 @@ end
 
 spec = Gem::Specification.new do |spec|
   spec.name      = 'right_popen'
-  spec.version   = '1.0.9'
-  spec.authors   = ['Scott Messier', 'Raphael Simon']
+  spec.version   = '1.0.11'
+  spec.authors   = ['Scott Messier', 'Raphael Simon', 'Graham Hughes']
   spec.email     = 'scott@rightscale.com'
   spec.homepage  = 'https://github.com/rightscale/right_popen'
   if is_windows?

data/spec/right_popen_spec.rb

@@ -1,182 +1,233 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-RUBY_CMD         = 'ruby'
-STANDARD_MESSAGE = 'Standard message'
-ERROR_MESSAGE    = 'Error message'
-EXIT_STATUS      = 146
+describe 'RightScale::popen3' do
 
-# manually bump count up for more aggressive multi-processor testing, lessen
-# for a quick smoke test
-LARGE_OUTPUT_COUNTER = 1000
+  module RightPopenSpec
+    class Runner
+      class RunnerStatus
+        def initialize(command, block)
+          @output_text = ""
+          @error_text  = ""
+          @status      = nil
+          @did_timeout = false
+          @callback    = block
+          @pid         = nil
+          EM.next_tick do
+            @timeout = EM::Timer.new(2) do
+              puts "\n** Failed to run #{command.inspect}: Timeout"
+              @did_timeout = true
+              @callback.call(self)
+            end
+          end
+        end
 
-# bump up count for most exhaustive leak detection.
-REPEAT_TEST_COUNTER = 256
+        attr_accessor :output_text, :error_text, :status, :did_timeout, :pid
 
-def is_windows?
-  return RUBY_PLATFORM =~ /mswin/
-end
+        def on_read_stdout(data)
+          @output_text << data
+        end
 
-describe 'RightScale::popen3' do
+        def on_read_stderr(data)
+          @error_text << data
+        end
 
-  module RightPopenSpec
+        def on_pid(pid)
+          raise "PID already set!" unless @pid.nil?
+          @pid = pid
+        end
+
+        def on_exit(status)
+          @timeout.cancel if @timeout
+          @status = status
+          @callback.call(self)
+        end
+      end
 
-    class Runner
       def initialize
+        @count          = 0
         @done           = false
-        @output_text    = nil
-        @error_text     = nil
-        @status         = nil
         @last_exception = nil
         @last_iteration = 0
       end
 
-      attr_reader :output_text, :error_text, :status
-
-      def do_right_popen(command, env=nil, input=nil)
-        @timeout = EM::Timer.new(2) { puts "\n** Failed to run #{command.inspect}: Timeout"; EM.stop }
-        @output_text = ''
-        @error_text  = ''
-        @status      = nil
-        RightScale.popen3(:command        => command, 
+      def do_right_popen(command, env=nil, input=nil, &callback)
+        status = RunnerStatus.new(command, callback)
+        RightScale.popen3(:command        => command,
                           :input          => input,
-                          :target         => self, 
+                          :target         => status,
                           :environment    => env,
-                          :stdout_handler => :on_read_stdout, 
-                          :stderr_handler => :on_read_stderr, 
+                          :stdout_handler => :on_read_stdout,
+                          :stderr_handler => :on_read_stderr,
+                          :pid_handler    => :on_pid,
                           :exit_handler   => :on_exit)
+        status
       end
 
       def run_right_popen(command, env=nil, input=nil, count=1)
         begin
-          @command = command
-          @env = env
-          @last_iteration = 0
-          @count = count
-          puts "#{count}>" if count > 1
-          EM.run { EM.next_tick { do_right_popen(command, env, input) } }
+          @iterations = 0
+          EM.run do
+            EM.next_tick do
+              do_right_popen(command, env, input) do |status|
+                maybe_continue(status)
+              end
+            end
+          end
+          @status
         rescue Exception => e
           puts "\n** Failed: #{e.message} FROM\n#{e.backtrace.join("\n")}"
           raise e
         end
       end
 
-      def on_read_stdout(data)
-        @output_text << data
-      end
-
-      def on_read_stderr(data)
-        @error_text << data
-      end
-
-      def on_exit(status)
-        @last_iteration += 1
-        @timeout.cancel if @timeout
-        if @last_iteration < @count
-          EM.next_tick do
-            print '+'
-            STDOUT.flush
-            do_right_popen(@command, @env)
-          end
+      def maybe_continue(status)
+        @iterations += 1
+        if @iterations < @count
+          do_right_popen(command, env, input) {|status| maybe_continue(status)}
         else
-          puts "<" if @count > 1
+          @status = status
           EM.stop
         end
-        @status = status
       end
     end
+  end
 
+  def is_windows?
+    return !!(RUBY_PLATFORM =~ /mswin/)
   end
 
   it 'should redirect output' do
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_output.rb'))}\" \"#{STANDARD_MESSAGE}\" \"#{ERROR_MESSAGE}\""
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 0
-    runner.output_text.should == STANDARD_MESSAGE + "\n"
-    runner.error_text.should == ERROR_MESSAGE + "\n"
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
+    status.output_text.should == STANDARD_MESSAGE + "\n"
+    status.error_text.should == ERROR_MESSAGE + "\n"
+    status.pid.should > 0
   end
 
   it 'should return the right status' do
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_status.rb'))}\" #{EXIT_STATUS}"
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == EXIT_STATUS
-    runner.output_text.should == ''
-    runner.error_text.should == ''
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == EXIT_STATUS
+    status.output_text.should == ''
+    status.error_text.should == ''
+    status.pid.should > 0
+  end
+
+  it 'should correctly handle many small processes' do
+    pending 'Set environment variable TEST_STRESS to enable' unless ENV['TEST_STRESS']
+    TO_RUN = 100
+    command = is_windows? ? "cmd.exe /c exit 0" : "exit 0"
+    runner = RightPopenSpec::Runner.new
+    @completed = 0
+    @started = 0
+    run_cmd = Proc.new do
+      runner.do_right_popen(command) do |status|
+        @completed += 1
+        status.status.exitstatus.should == 0
+        status.output_text.should == ''
+        status.error_text.should == ''
+        status.pid.should > 0
+      end
+      @started += 1
+      if @started < TO_RUN
+        EM.next_tick { run_cmd.call }
+      end
+    end
+    EM.run do
+      EM.next_tick { run_cmd.call }
+
+      EM::PeriodicTimer.new(1) do
+        if @completed >= TO_RUN
+          EM.stop
+        end
+      end
+    end
   end
 
   it 'should preserve the integrity of stdout when stderr is unavailable' do
     count = LARGE_OUTPUT_COUNTER
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_stdout_only.rb'))}\" #{count}"
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 0
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
 
     results = ''
     count.times do |i|
       results << "stdout #{i}\n"
     end
-    runner.output_text.should == results
-    runner.error_text.should == ''
+    status.output_text.should == results
+    status.error_text.should == ''
+    status.pid.should > 0
   end
 
   it 'should preserve the integrity of stderr when stdout is unavailable' do
     count = LARGE_OUTPUT_COUNTER
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_stderr_only.rb'))}\" #{count}"
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 0
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
 
     results = ''
     count.times do |i|
       results << "stderr #{i}\n"
     end
-    runner.error_text.should == results
-    runner.output_text.should == ''
+    status.error_text.should == results
+    status.output_text.should == ''
+    status.pid.should > 0
   end
 
   it 'should preserve the integrity of stdout and stderr despite interleaving' do
     count = LARGE_OUTPUT_COUNTER
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_mixed_output.rb'))}\" #{count}"
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 99
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 99
 
     results = ''
     count.times do |i|
       results << "stdout #{i}\n"
     end
-    runner.output_text.should == results
+    status.output_text.should == results
 
     results = ''
     count.times do |i|
       (results << "stderr #{i}\n") if 0 == i % 10
     end
-    runner.error_text.should == results
+    status.error_text.should == results
+    status.pid.should > 0
   end
-  
+
   it 'should setup environment variables' do
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command)
-    runner.status.exitstatus.should == 0
-    runner.output_text.should_not include('_test_')
-    runner.run_right_popen(command, :__test__ => '42')
-    runner.status.exitstatus.should == 0
-    runner.output_text.should match(/^__test__=42$/)
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
+    status.output_text.should_not include('_test_')
+    status = runner.run_right_popen(command, :__test__ => '42')
+    status.status.exitstatus.should == 0
+    status.output_text.should match(/^__test__=42$/)
+    status.pid.should > 0
   end
 
   it 'should restore environment variables' do
-    ENV['__test__'] = '41'
-    old_envs = {}
-    ENV.each { |k, v| old_envs[k] = v }
-    command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
-    runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command, :__test__ => '42')
-    runner.status.exitstatus.should == 0
-    runner.output_text.should match(/^__test__=42$/)
-    ENV.each { |k, v| old_envs[k].should == v }
-    old_envs.each { |k, v| ENV[k].should == v }
+    begin
+      ENV['__test__'] = '41'
+      old_envs = {}
+      ENV.each { |k, v| old_envs[k] = v }
+      command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
+      runner = RightPopenSpec::Runner.new
+      status = runner.run_right_popen(command, :__test__ => '42')
+      status.status.exitstatus.should == 0
+      status.output_text.should match(/^__test__=42$/)
+      ENV.each { |k, v| old_envs[k].should == v }
+      old_envs.each { |k, v| ENV[k].should == v }
+      status.pid.should > 0
+    ensure
+      ENV.delete('__test__')
+    end
   end
 
   if is_windows?
@@ -185,37 +236,63 @@ describe 'RightScale::popen3' do
     it 'should merge the PATH variable instead of overriding it' do
       command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'print_env.rb'))}\""
       runner = RightPopenSpec::Runner.new
-      runner.run_right_popen(command, 'PATH' => "c:/bogus\\bin")
-      runner.status.exitstatus.should == 0
-      runner.output_text.should include('PATH=c:\\bogus\\bin;')
+      status = runner.run_right_popen(command, 'PATH' => "c:/bogus\\bin")
+      status.status.exitstatus.should == 0
+      status.output_text.should include('PATH=c:\\bogus\\bin;')
+      status.pid.should > 0
     end
   else
     it 'should allow running bash command lines starting with a built-in command' do
       command = "for i in 1 2 3 4 5; do echo $i;done"
       runner = RightPopenSpec::Runner.new
-      runner.run_right_popen(command)
-      runner.status.exitstatus.should == 0
-      runner.output_text.should == "1\n2\n3\n4\n5\n"
+      status = runner.run_right_popen(command)
+      status.status.exitstatus.should == 0
+      status.output_text.should == "1\n2\n3\n4\n5\n"
+      status.pid.should > 0
     end
+
+    it 'should support running background processes' do
+      command = "(sleep 20)&"
+      now = Time.now
+      runner = RightPopenSpec::Runner.new
+      status = runner.run_right_popen(command)
+      finished = Time.now
+      (finished - now).should < 20
+      status.did_timeout.should be_false
+      status.status.exitstatus.should == 0
+      status.output_text.should == ""
+      status.pid.should > 0
+    end
+  end
+
+  it 'should support raw command arguments' do
+    command = is_windows? ? ["cmd.exe", "/c", "echo", "*"] : ["echo", "*"]
+    runner = RightPopenSpec::Runner.new
+    status = runner.run_right_popen(command)
+    status.status.exitstatus.should == 0
+    status.output_text.should == "*\n"
+    status.pid.should > 0
   end
 
   it 'should run repeatedly without leaking resources' do
     pending 'Set environment variable TEST_LEAK to enable' unless ENV['TEST_LEAK']
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'produce_output.rb'))}\" \"#{STANDARD_MESSAGE}\" \"#{ERROR_MESSAGE}\""
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command, nil, nil, REPEAT_TEST_COUNTER)
-    runner.status.exitstatus.should == 0
-    runner.output_text.should == STANDARD_MESSAGE + "\n"
-    runner.error_text.should == ERROR_MESSAGE + "\n"
+    status = runner.run_right_popen(command, nil, nil, REPEAT_TEST_COUNTER)
+    status.status.exitstatus.should == 0
+    status.output_text.should == STANDARD_MESSAGE + "\n"
+    status.error_text.should == ERROR_MESSAGE + "\n"
+    status.pid.should > 0
   end
 
   it 'should pass input to child process' do
     command = "\"#{RUBY_CMD}\" \"#{File.expand_path(File.join(File.dirname(__FILE__), 'increment.rb'))}\""
     runner = RightPopenSpec::Runner.new
-    runner.run_right_popen(command, nil, "42\n")
-    runner.status.exitstatus.should == 0
-    runner.output_text.should == "43\n"
-    runner.error_text.should be_empty
+    status = runner.run_right_popen(command, nil, "42\n")
+    status.status.exitstatus.should == 0
+    status.output_text.should == "43\n"
+    status.error_text.should be_empty
+    status.pid.should > 0
   end
 
 end

data/spec/spec_helper.rb

@@ -2,3 +2,19 @@ require 'rubygems'
 require 'spec'
 require 'eventmachine'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'right_popen')
+
+RUBY_CMD         = 'ruby'
+STANDARD_MESSAGE = 'Standard message'
+ERROR_MESSAGE    = 'Error message'
+EXIT_STATUS      = 146
+
+# manually bump count up for more aggressive multi-processor testing, lessen
+# for a quick smoke test
+LARGE_OUTPUT_COUNTER = 1000
+
+# bump up count for most exhaustive leak detection.
+REPEAT_TEST_COUNTER = 256
+
+def is_windows?
+  return RUBY_PLATFORM =~ /mswin/
+end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification 
 name: right_popen
 version: !ruby/object:Gem::Version 
-  version: 1.0.9
+  version: 1.0.11
 platform: ruby
 authors: 
 - Scott Messier
 - Raphael Simon
+- Graham Hughes
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-06-21 00:00:00 -07:00
+date: 2010-09-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency