How to write and read from process with Ruby and IO.popen?

Question

I wrote this, but it didn`t work...

output = IO.popen("irb", "r+") do |pipe|
  pipe.gets
  pipe.puts "10**6"
  pipe.gets
  pipe.puts "quit"
end

I rewrite so

IO.popen("irb", "w+") do |pipe|
  3.times {puts pipe.gets} # startup noise
  pipe.puts "10**6\n"
  puts pipe.gets # I expect " => 1000000"
  pipe.puts "quit" # I expect exit from irb
end 

but It didn`t work too

Answer 1

In general the above example will hang because the pipe is still open for writing, and the command you called (the ruby interpreter) expects further commands / data.

The other answer sends __END__ to ruby -- this works here, but this trick will of course not work with any other programs you might call via popen.

When you use popen you need to close the pipe with IO#close_write.

 IO.popen("ruby", "r+") do |pipe|
   pipe.puts "puts 10**6"

   pipe.close_write    # make sure to close stdin for the program you call

   pipe.gets
 end

See: Ruby 3.1 popen*

---

In more Detail:

In Ruby, IO.popen, IO.popen2, IO.popen2e, and IO.popen3 are methods used for working with subprocesses, and they differ in how they handle input, output, and error streams. Here's an explanation of the differences and when to use each:

1. IO.popen:

   • IO.popen is a versatile method that allows you to create a subprocess and interact with its standard input and output.
   • It returns an array containing the subprocess's standard input, standard output, and a thread representing the subprocess.
   • It's suitable for basic subprocess interaction when you need to send data to the process and capture its output.
   • Example:

     stdin, stdout, thr = IO.popen('some_command')
     

2. IO.popen2:

   • IO.popen2 creates a subprocess with separate pipes for standard input and output.
   • It returns an array containing the subprocess's standard input and output streams.
   • It's useful when you want to send data to the process and capture its output separately.
   • Example:

     stdin, stdout = IO.popen2('some_command')
     

3. IO.popen2e:

   • IO.popen2e is similar to IO.popen2, but it combines the standard output and standard error streams into a single stream.
   • It returns an array containing the subprocess's standard input and combined standard output/error streams.
   • This is useful when you want to capture both output and error messages together.
   • Example:

     stdin, stdout_err = IO.popen2e('some_command')
     

4. IO.popen3:

   • IO.popen3 creates a subprocess with separate pipes for standard input, standard output, and standard error.
   • It returns an array containing the subprocess's standard input, standard output, standard error, and a thread representing the subprocess.
   • It's suitable for scenarios where you need to interact with the process, capture its output, and handle potential error messages separately.
   • Example:

     stdin, stdout, stderr, thr = IO.popen3('some_command')
     

When to use each version depends on your specific requirements:

• Use IO.popen when you need to interact with a subprocess's input and output and don't require separate handling of error messages.

• Use IO.popen2 when you want to capture the standard output separately from the standard input and need to send data to the process.

• Use IO.popen2e when you want to capture both standard output and standard error together in a single stream.

• Use IO.popen3 when you need separate pipes for standard input, standard output, and standard error, and you want to interact with the subprocess and capture both output and error messages separately.