Initialize the filesystem paths to use from env. env is a hash-like object (typically ENV) that is queried for ‘GEM_HOME’, ‘GEM_PATH’, and ‘GEM_SPEC_CACHE’ Keys for the env hash should be Strings, and values of the hash should be Strings or nil.
Prints the amount of time the supplied block takes to run using the debug UI output.
Returns the currently set formatter. By default, it is set to DidYouMean::Formatter.
Updates the primary formatter used to format the suggestions.
Returns true if the file at path new is newer than all the files at paths in array old_list; false otherwise.
Argument new and the elements of old_list should be interpretable as paths:
FileUtils.uptodate?('Rakefile', ['Gemfile', 'README.md']) # => true FileUtils.uptodate?('Gemfile', ['Rakefile', 'README.md']) # => false
A non-existent file is considered to be infinitely old.
Related: FileUtils.touch.
Returns true if the file at path new is newer than all the files at paths in array old_list; false otherwise.
Argument new and the elements of old_list should be interpretable as paths:
FileUtils.uptodate?('Rakefile', ['Gemfile', 'README.md']) # => true FileUtils.uptodate?('Gemfile', ['Rakefile', 'README.md']) # => false
A non-existent file is considered to be infinitely old.
Related: FileUtils.touch.
Executes command similarly to xsystem, but yields opened pipe.
Allows the opening of various resources including URIs.
If the first argument responds to the ‘open’ method, ‘open’ is called on it with the rest of the arguments.
If the first argument is a string that begins with (protocol)://, it is parsed by URI.parse. If the parsed object responds to the ‘open’ method, ‘open’ is called on it with the rest of the arguments.
Otherwise, Kernel#open is called.
OpenURI::OpenRead#open provides URI::HTTP#open, URI::HTTPS#open and URI::FTP#open, Kernel#open.
We can accept URIs and strings that begin with http://, https:// and ftp://. In these cases, the opened file object is extended by OpenURI::Meta.
Basically a wrapper for Process.spawn that:
Creates a child process, by calling Process.spawn with the given arguments.
Creates streams stdin, stdout, and stderr, which are the standard input, standard output, and standard error streams in the child process.
Creates thread wait_thread that waits for the child process to exit; the thread has method pid, which returns the process ID of the child process.
With no block given, returns the array [stdin, stdout, stderr, wait_thread]. The caller should close each of the three returned streams.
stdin, stdout, stderr, wait_thread = Open3.popen3('echo') # => [#<IO:fd 8>, #<IO:fd 10>, #<IO:fd 12>, #<Process::Waiter:0x00007f58d5428f58 run>] stdin.close stdout.close stderr.close wait_thread.pid # => 2210481 wait_thread.value # => #<Process::Status: pid 2210481 exit 0>
With a block given, calls the block with the four variables (three streams and the wait thread) and returns the block’s return value. The caller need not close the streams:
Open3.popen3('echo') do |stdin, stdout, stderr, wait_thread| p stdin p stdout p stderr p wait_thread p wait_thread.pid p wait_thread.value end
Output:
#<IO:fd 6> #<IO:fd 7> #<IO:fd 9> #<Process::Waiter:0x00007f58d53606e8 sleep> 2211047 #<Process::Status: pid 2211047 exit 0>
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
Unlike Process.spawn, this method waits for the child process to exit before returning, so the caller need not do so.
If the first argument is a hash, it becomes leading argument env in the call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in the call to Process.spawn; see Execution Options.
The single required argument is one of the following:
command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more metacharacters.
exe_path otherwise.
Argument command_line
String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
Open3.popen3('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word. Open3.popen3('echo') {|*args| p args } # Built-in. Open3.popen3('date > date.tmp') {|*args| p args } # Contains meta character.
Output (similar for each call above):
[#<IO:(closed)>, #<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f58d52f28c8 dead>]
The command line may also contain arguments and options for the command:
Open3.popen3('echo "Foo"') { |i, o, e, t| o.gets } "Foo\n"
Argument exe_path
Argument exe_path is one of the following:
The string path to an executable to be called.
A 2-element array containing the path to an executable and the string to be used as the name of the executing process.
Example:
Open3.popen3('/usr/bin/date') { |i, o, e, t| o.gets } # => "Wed Sep 27 02:56:44 PM CDT 2023\n"
Ruby invokes the executable directly, with no shell and no shell expansion:
Open3.popen3('doesnt_exist') { |i, o, e, t| o.gets } # Raises Errno::ENOENT
If one or more args is given, each is an argument or option to be passed to the executable:
Open3.popen3('echo', 'C #') { |i, o, e, t| o.gets } # => "C #\n" Open3.popen3('echo', 'hello', 'world') { |i, o, e, t| o.gets } # => "hello world\n"
Take care to avoid deadlocks. Output streams stdout and stderr have fixed-size buffers, so reading extensively from one but not the other can cause a deadlock when the unread buffer fills. To avoid that, stdout and stderr should be read simultaneously (using threads or IO.select).
Related:
Open3.popen2: Makes the standard input and standard output streams of the child process available as separate streams, with no access to the standard error stream.
Open3.popen2e: Makes the standard input and the merge of the standard output and standard error streams of the child process available as separate streams.
Basically a wrapper for Process.spawn that:
Creates a child process, by calling Process.spawn with the given arguments.
Creates streams stdin, stdout, and stderr, which are the standard input, standard output, and standard error streams in the child process.
Creates thread wait_thread that waits for the child process to exit; the thread has method pid, which returns the process ID of the child process.
With no block given, returns the array [stdin, stdout, stderr, wait_thread]. The caller should close each of the three returned streams.
stdin, stdout, stderr, wait_thread = Open3.popen3('echo') # => [#<IO:fd 8>, #<IO:fd 10>, #<IO:fd 12>, #<Process::Waiter:0x00007f58d5428f58 run>] stdin.close stdout.close stderr.close wait_thread.pid # => 2210481 wait_thread.value # => #<Process::Status: pid 2210481 exit 0>
With a block given, calls the block with the four variables (three streams and the wait thread) and returns the block’s return value. The caller need not close the streams:
Open3.popen3('echo') do |stdin, stdout, stderr, wait_thread| p stdin p stdout p stderr p wait_thread p wait_thread.pid p wait_thread.value end
Output:
#<IO:fd 6> #<IO:fd 7> #<IO:fd 9> #<Process::Waiter:0x00007f58d53606e8 sleep> 2211047 #<Process::Status: pid 2211047 exit 0>
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
Unlike Process.spawn, this method waits for the child process to exit before returning, so the caller need not do so.
If the first argument is a hash, it becomes leading argument env in the call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in the call to Process.spawn; see Execution Options.
The single required argument is one of the following:
command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more metacharacters.
exe_path otherwise.
Argument command_line
String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
Open3.popen3('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word. Open3.popen3('echo') {|*args| p args } # Built-in. Open3.popen3('date > date.tmp') {|*args| p args } # Contains meta character.
Output (similar for each call above):
[#<IO:(closed)>, #<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f58d52f28c8 dead>]
The command line may also contain arguments and options for the command:
Open3.popen3('echo "Foo"') { |i, o, e, t| o.gets } "Foo\n"
Argument exe_path
Argument exe_path is one of the following:
The string path to an executable to be called.
A 2-element array containing the path to an executable and the string to be used as the name of the executing process.
Example:
Open3.popen3('/usr/bin/date') { |i, o, e, t| o.gets } # => "Wed Sep 27 02:56:44 PM CDT 2023\n"
Ruby invokes the executable directly, with no shell and no shell expansion:
Open3.popen3('doesnt_exist') { |i, o, e, t| o.gets } # Raises Errno::ENOENT
If one or more args is given, each is an argument or option to be passed to the executable:
Open3.popen3('echo', 'C #') { |i, o, e, t| o.gets } # => "C #\n" Open3.popen3('echo', 'hello', 'world') { |i, o, e, t| o.gets } # => "hello world\n"
Take care to avoid deadlocks. Output streams stdout and stderr have fixed-size buffers, so reading extensively from one but not the other can cause a deadlock when the unread buffer fills. To avoid that, stdout and stderr should be read simultaneously (using threads or IO.select).
Related:
Open3.popen2: Makes the standard input and standard output streams of the child process available as separate streams, with no access to the standard error stream.
Open3.popen2e: Makes the standard input and the merge of the standard output and standard error streams of the child process available as separate streams.
Basically a wrapper for Process.spawn that:
Creates a child process, by calling Process.spawn with the given arguments.
Creates streams stdin and stdout, which are the standard input and standard output streams in the child process.
Creates thread wait_thread that waits for the child process to exit; the thread has method pid, which returns the process ID of the child process.
With no block given, returns the array [stdin, stdout, wait_thread]. The caller should close each of the two returned streams.
stdin, stdout, wait_thread = Open3.popen2('echo') # => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f58d52dbe98 run>] stdin.close stdout.close wait_thread.pid # => 2263572 wait_thread.value # => #<Process::Status: pid 2263572 exit 0>
With a block given, calls the block with the three variables (two streams and the wait thread) and returns the block’s return value. The caller need not close the streams:
Open3.popen2('echo') do |stdin, stdout, wait_thread| p stdin p stdout p wait_thread p wait_thread.pid p wait_thread.value end
Output:
#<IO:fd 6> #<IO:fd 7> #<Process::Waiter:0x00007f58d59a34b0 sleep> 2263636 #<Process::Status: pid 2263636 exit 0>
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
Unlike Process.spawn, this method waits for the child process to exit before returning, so the caller need not do so.
If the first argument is a hash, it becomes leading argument env in the call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in the call to Process.spawn; see Execution Options.
The single required argument is one of the following:
command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more metacharacters.
exe_path otherwise.
Argument command_line
String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
Open3.popen2('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word. Open3.popen2('echo') {|*args| p args } # Built-in. Open3.popen2('date > date.tmp') {|*args| p args } # Contains meta character.
Output (similar for each call above):
# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577dfe410 dead>]
The command line may also contain arguments and options for the command:
Open3.popen2('echo "Foo"') { |i, o, t| o.gets } "Foo\n"
Argument exe_path
Argument exe_path is one of the following:
The string path to an executable to be called.
A 2-element array containing the path to an executable and the string to be used as the name of the executing process.
Example:
Open3.popen2('/usr/bin/date') { |i, o, t| o.gets } # => "Thu Sep 28 09:41:06 AM CDT 2023\n"
Ruby invokes the executable directly, with no shell and no shell expansion:
Open3.popen2('doesnt_exist') { |i, o, t| o.gets } # Raises Errno::ENOENT
If one or more args is given, each is an argument or option to be passed to the executable:
Open3.popen2('echo', 'C #') { |i, o, t| o.gets } # => "C #\n" Open3.popen2('echo', 'hello', 'world') { |i, o, t| o.gets } # => "hello world\n"
Related:
Open3.popen2e: Makes the standard input and the merge of the standard output and standard error streams of the child process available as separate streams.
Open3.popen3: Makes the standard input, standard output, and standard error streams of the child process available as separate streams.
Basically a wrapper for Process.spawn that:
Creates a child process, by calling Process.spawn with the given arguments.
Creates streams stdin and stdout, which are the standard input and standard output streams in the child process.
Creates thread wait_thread that waits for the child process to exit; the thread has method pid, which returns the process ID of the child process.
With no block given, returns the array [stdin, stdout, wait_thread]. The caller should close each of the two returned streams.
stdin, stdout, wait_thread = Open3.popen2('echo') # => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f58d52dbe98 run>] stdin.close stdout.close wait_thread.pid # => 2263572 wait_thread.value # => #<Process::Status: pid 2263572 exit 0>
With a block given, calls the block with the three variables (two streams and the wait thread) and returns the block’s return value. The caller need not close the streams:
Open3.popen2('echo') do |stdin, stdout, wait_thread| p stdin p stdout p wait_thread p wait_thread.pid p wait_thread.value end
Output:
#<IO:fd 6> #<IO:fd 7> #<Process::Waiter:0x00007f58d59a34b0 sleep> 2263636 #<Process::Status: pid 2263636 exit 0>
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
Unlike Process.spawn, this method waits for the child process to exit before returning, so the caller need not do so.
If the first argument is a hash, it becomes leading argument env in the call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in the call to Process.spawn; see Execution Options.
The single required argument is one of the following:
command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more metacharacters.
exe_path otherwise.
Argument command_line
String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
Open3.popen2('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word. Open3.popen2('echo') {|*args| p args } # Built-in. Open3.popen2('date > date.tmp') {|*args| p args } # Contains meta character.
Output (similar for each call above):
# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577dfe410 dead>]
The command line may also contain arguments and options for the command:
Open3.popen2('echo "Foo"') { |i, o, t| o.gets } "Foo\n"
Argument exe_path
Argument exe_path is one of the following:
The string path to an executable to be called.
A 2-element array containing the path to an executable and the string to be used as the name of the executing process.
Example:
Open3.popen2('/usr/bin/date') { |i, o, t| o.gets } # => "Thu Sep 28 09:41:06 AM CDT 2023\n"
Ruby invokes the executable directly, with no shell and no shell expansion:
Open3.popen2('doesnt_exist') { |i, o, t| o.gets } # Raises Errno::ENOENT
If one or more args is given, each is an argument or option to be passed to the executable:
Open3.popen2('echo', 'C #') { |i, o, t| o.gets } # => "C #\n" Open3.popen2('echo', 'hello', 'world') { |i, o, t| o.gets } # => "hello world\n"
Related:
Open3.popen2e: Makes the standard input and the merge of the standard output and standard error streams of the child process available as separate streams.
Open3.popen3: Makes the standard input, standard output, and standard error streams of the child process available as separate streams.
Basically a wrapper for Process.spawn that:
Creates a child process, by calling Process.spawn with the given arguments.
Creates streams stdin, stdout_and_stderr, which are the standard input and the merge of the standard output and standard error streams in the child process.
Creates thread wait_thread that waits for the child process to exit; the thread has method pid, which returns the process ID of the child process.
With no block given, returns the array [stdin, stdout_and_stderr, wait_thread]. The caller should close each of the two returned streams.
stdin, stdout_and_stderr, wait_thread = Open3.popen2e('echo') # => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f7577da4398 run>] stdin.close stdout_and_stderr.close wait_thread.pid # => 2274600 wait_thread.value # => #<Process::Status: pid 2274600 exit 0>
With a block given, calls the block with the three variables (two streams and the wait thread) and returns the block’s return value. The caller need not close the streams:
Open3.popen2e('echo') do |stdin, stdout_and_stderr, wait_thread| p stdin p stdout_and_stderr p wait_thread p wait_thread.pid p wait_thread.value end
Output:
#<IO:fd 6> #<IO:fd 7> #<Process::Waiter:0x00007f75777578c8 sleep> 2274763 #<Process::Status: pid 2274763 exit 0>
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
Unlike Process.spawn, this method waits for the child process to exit before returning, so the caller need not do so.
If the first argument is a hash, it becomes leading argument env in the call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in the call to Process.spawn; see Execution Options.
The single required argument is one of the following:
command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more metacharacters.
exe_path otherwise.
Argument command_line
String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
Open3.popen2e('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word. Open3.popen2e('echo') {|*args| p args } # Built-in. Open3.popen2e('date > date.tmp') {|*args| p args } # Contains meta character.
Output (similar for each call above):
# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577d8a1f0 dead>]
The command line may also contain arguments and options for the command:
Open3.popen2e('echo "Foo"') { |i, o_and_e, t| o_and_e.gets } "Foo\n"
Argument exe_path
Argument exe_path is one of the following:
The string path to an executable to be called.
A 2-element array containing the path to an executable and the string to be used as the name of the executing process.
Example:
Open3.popen2e('/usr/bin/date') { |i, o_and_e, t| o_and_e.gets } # => "Thu Sep 28 01:58:45 PM CDT 2023\n"
Ruby invokes the executable directly, with no shell and no shell expansion:
Open3.popen2e('doesnt_exist') { |i, o_and_e, t| o_and_e.gets } # Raises Errno::ENOENT
If one or more args is given, each is an argument or option to be passed to the executable:
Open3.popen2e('echo', 'C #') { |i, o_and_e, t| o_and_e.gets } # => "C #\n" Open3.popen2e('echo', 'hello', 'world') { |i, o_and_e, t| o_and_e.gets } # => "hello world\n"
Related:
Open3.popen2: Makes the standard input and standard output streams of the child process available as separate streams, with no access to the standard error stream.
Open3.popen3: Makes the standard input, standard output, and standard error streams of the child process available as separate streams.
Basically a wrapper for Process.spawn that:
Creates a child process, by calling Process.spawn with the given arguments.
Creates streams stdin, stdout_and_stderr, which are the standard input and the merge of the standard output and standard error streams in the child process.
Creates thread wait_thread that waits for the child process to exit; the thread has method pid, which returns the process ID of the child process.
With no block given, returns the array [stdin, stdout_and_stderr, wait_thread]. The caller should close each of the two returned streams.
stdin, stdout_and_stderr, wait_thread = Open3.popen2e('echo') # => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f7577da4398 run>] stdin.close stdout_and_stderr.close wait_thread.pid # => 2274600 wait_thread.value # => #<Process::Status: pid 2274600 exit 0>
With a block given, calls the block with the three variables (two streams and the wait thread) and returns the block’s return value. The caller need not close the streams:
Open3.popen2e('echo') do |stdin, stdout_and_stderr, wait_thread| p stdin p stdout_and_stderr p wait_thread p wait_thread.pid p wait_thread.value end
Output:
#<IO:fd 6> #<IO:fd 7> #<Process::Waiter:0x00007f75777578c8 sleep> 2274763 #<Process::Status: pid 2274763 exit 0>
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
Unlike Process.spawn, this method waits for the child process to exit before returning, so the caller need not do so.
If the first argument is a hash, it becomes leading argument env in the call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in the call to Process.spawn; see Execution Options.
The single required argument is one of the following:
command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more metacharacters.
exe_path otherwise.
Argument command_line
String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:
Open3.popen2e('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word. Open3.popen2e('echo') {|*args| p args } # Built-in. Open3.popen2e('date > date.tmp') {|*args| p args } # Contains meta character.
Output (similar for each call above):
# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577d8a1f0 dead>]
The command line may also contain arguments and options for the command:
Open3.popen2e('echo "Foo"') { |i, o_and_e, t| o_and_e.gets } "Foo\n"
Argument exe_path
Argument exe_path is one of the following:
The string path to an executable to be called.
A 2-element array containing the path to an executable and the string to be used as the name of the executing process.
Example:
Open3.popen2e('/usr/bin/date') { |i, o_and_e, t| o_and_e.gets } # => "Thu Sep 28 01:58:45 PM CDT 2023\n"
Ruby invokes the executable directly, with no shell and no shell expansion:
Open3.popen2e('doesnt_exist') { |i, o_and_e, t| o_and_e.gets } # Raises Errno::ENOENT
If one or more args is given, each is an argument or option to be passed to the executable:
Open3.popen2e('echo', 'C #') { |i, o_and_e, t| o_and_e.gets } # => "C #\n" Open3.popen2e('echo', 'hello', 'world') { |i, o_and_e, t| o_and_e.gets } # => "hello world\n"
Related:
Open3.popen2: Makes the standard input and standard output streams of the child process available as separate streams, with no access to the standard error stream.
Open3.popen3: Makes the standard input, standard output, and standard error streams of the child process available as separate streams.