See any remaining errors held in queue.
Any errors you see here are probably due to a bug in Ruby’s OpenSSL implementation.
Parse a YAML string in yaml. Returns the Psych::Nodes::Document. filename is used in the exception message if a Psych::SyntaxError is raised.
Raises a Psych::SyntaxError when a YAML syntax error is detected.
Example:
Psych.parse("---\n - a\n - b") # => #<Psych::Nodes::Document:0x00> begin Psych.parse("--- `", filename: "file.txt") rescue Psych::SyntaxError => ex ex.file # => 'file.txt' ex.message # => "(file.txt): found character that cannot start any token" end
See Psych::Nodes for more information about YAML AST.
Returns a default parser
Returns true if the named file exists and the effective used id of the calling process is the owner of the file.
file_name can be an IO object.
Returns true if the named file exists and the effective group id of the calling process is the owner of the file. Returns false on Windows.
file_name can be an IO object.
Returns true if filepath points to a character device, false otherwise.
File.chardev?($stdin) # => true File.chardev?('t.txt') # => false
Initiates garbage collection, even if manually disabled.
The full_mark keyword argument determines whether or not to perform a major garbage collection cycle. When set to true, a major garbage collection cycle is run, meaning all objects are marked. When set to false, a minor garbage collection cycle is run, meaning only young objects are marked.
The immediate_mark keyword argument determines whether or not to perform incremental marking. When set to true, marking is completed during the call to this method. When set to false, marking is performed in steps that are interleaved with future Ruby code execution, so marking might not be completed during this method call. Note that if full_mark is false, then marking will always be immediate, regardless of the value of immediate_mark.
The immediate_sweep keyword argument determines whether or not to defer sweeping (using lazy sweep). When set to false, sweeping is performed in steps that are interleaved with future Ruby code execution, so sweeping might not be completed during this method call. When set to true, sweeping is completed during the call to this method.
Note: These keyword arguments are implementation and version-dependent. They are not guaranteed to be future-compatible and may be ignored if the underlying implementation does not support them.
Invokes the block with a Benchmark::Report object, which may be used to collect and report on the results of individual benchmark tests. Reserves label_width leading spaces for labels on each line. Prints caption at the top of the report, and uses format to format each line. (Note: caption must contain a terminating newline character, see the default Benchmark::Tms::CAPTION for an example.)
Returns an array of Benchmark::Tms objects.
If the block returns an array of Benchmark::Tms objects, these will be used to format additional lines of output. If labels parameter are given, these are used to label these extra lines.
Note: Other methods provide a simpler interface to this one, and are suitable for nearly all benchmarking requirements. See the examples in Benchmark, and the bm and bmbm methods.
Example:
require 'benchmark' include Benchmark # we need the CAPTION and FORMAT constants n = 5000000 Benchmark.benchmark(CAPTION, 7, FORMAT, ">total:", ">avg:") do |x| tf = x.report("for:") { for i in 1..n; a = "1"; end } tt = x.report("times:") { n.times do ; a = "1"; end } tu = x.report("upto:") { 1.upto(n) do ; a = "1"; end } [tf+tt+tu, (tf+tt+tu)/3] end
Generates:
user system total real for: 0.970000 0.000000 0.970000 ( 0.970493) times: 0.990000 0.000000 0.990000 ( 0.989542) upto: 0.970000 0.000000 0.970000 ( 0.972854) >total: 2.930000 0.000000 2.930000 ( 2.932889) >avg: 0.976667 0.000000 0.976667 ( 0.977630)
Invokes the block with a Benchmark::Report object, which may be used to collect and report on the results of individual benchmark tests. Reserves label_width leading spaces for labels on each line. Prints caption at the top of the report, and uses format to format each line. (Note: caption must contain a terminating newline character, see the default Benchmark::Tms::CAPTION for an example.)
Returns an array of Benchmark::Tms objects.
If the block returns an array of Benchmark::Tms objects, these will be used to format additional lines of output. If labels parameter are given, these are used to label these extra lines.
Note: Other methods provide a simpler interface to this one, and are suitable for nearly all benchmarking requirements. See the examples in Benchmark, and the bm and bmbm methods.
Example:
require 'benchmark' include Benchmark # we need the CAPTION and FORMAT constants n = 5000000 Benchmark.benchmark(CAPTION, 7, FORMAT, ">total:", ">avg:") do |x| tf = x.report("for:") { for i in 1..n; a = "1"; end } tt = x.report("times:") { n.times do ; a = "1"; end } tu = x.report("upto:") { 1.upto(n) do ; a = "1"; end } [tf+tt+tu, (tf+tt+tu)/3] end
Generates:
user system total real for: 0.970000 0.000000 0.970000 ( 0.970493) times: 0.990000 0.000000 0.990000 ( 0.989542) upto: 0.970000 0.000000 0.970000 ( 0.972854) >total: 2.930000 0.000000 2.930000 ( 2.932889) >avg: 0.976667 0.000000 0.976667 ( 0.977630)
The standard configuration object for gems.
Use the given configuration object (which implements the ConfigFile protocol) as the standard configuration object.
Skips the current file or directory, restarting the loop with the next entry. If the current file is a directory, that directory will not be recursively entered. Meaningful only within the block associated with Find::find.
See the Find module documentation for an example.
Skips the current file or directory, restarting the loop with the next entry. If the current file is a directory, that directory will not be recursively entered. Meaningful only within the block associated with Find::find.
See the Find module documentation for an example.
Returns a new URI object constructed from the given string uri:
URI.parse('https://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top') # => #<URI::HTTPS https://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top> URI.parse('http://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top') # => #<URI::HTTP http://john.doe@www.example.com:123/forum/questions/?tag=networking&order=newest#top>
It’s recommended to first ::escape string uri if it may contain invalid URI characters.
Basically a wrapper for Process.spawn that:
Creates a child process for each of the given cmds by calling Process.spawn.
Pipes the stdout from each child to the stdin of the next child, or, for the last child, to the caller’s stdout.
The method does not wait for child processes to exit, so the caller must do so.
With no block given, returns a 2-element array containing:
The stdout stream of the last child process.
An array of the wait threads for all of the child processes.
Example:
last_stdout, wait_threads = Open3.pipeline_r('ls', 'grep R') # => [#<IO:fd 5>, [#<Process::Waiter:0x000055e8de2f9898 dead>, #<Process::Waiter:0x000055e8de2f94b0 sleep>]] puts last_stdout.read wait_threads.each do |wait_thread| wait_thread.join end
Output:
Rakefile README.md
With a block given, calls the block with the stdout stream of the last child process, and an array of the wait processes:
Open3.pipeline_r('ls', 'grep R') do |last_stdout, wait_threads| puts last_stdout.read wait_threads.each do |wait_thread| wait_thread.join end end
Output:
Rakefile README.md
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
If the first argument is a hash, it becomes leading argument env in each call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in each call to Process.spawn; see Execution Options.
Each remaining argument in cmds is one of:
A command_line: a string that begins with a shell reserved word or special built-in, or contains one or more metacharacters.
An exe_path: the string path to an executable to be called.
An array containing a command_line or an exe_path, along with zero or more string arguments for the command.
Basically a wrapper for Process.spawn that:
Creates a child process for each of the given cmds by calling Process.spawn.
Pipes the stdout from each child to the stdin of the next child, or, for the last child, to the caller’s stdout.
The method does not wait for child processes to exit, so the caller must do so.
With no block given, returns a 2-element array containing:
The stdout stream of the last child process.
An array of the wait threads for all of the child processes.
Example:
last_stdout, wait_threads = Open3.pipeline_r('ls', 'grep R') # => [#<IO:fd 5>, [#<Process::Waiter:0x000055e8de2f9898 dead>, #<Process::Waiter:0x000055e8de2f94b0 sleep>]] puts last_stdout.read wait_threads.each do |wait_thread| wait_thread.join end
Output:
Rakefile README.md
With a block given, calls the block with the stdout stream of the last child process, and an array of the wait processes:
Open3.pipeline_r('ls', 'grep R') do |last_stdout, wait_threads| puts last_stdout.read wait_threads.each do |wait_thread| wait_thread.join end end
Output:
Rakefile README.md
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
If the first argument is a hash, it becomes leading argument env in each call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in each call to Process.spawn; see Execution Options.
Each remaining argument in cmds is one of:
A command_line: a string that begins with a shell reserved word or special built-in, or contains one or more metacharacters.
An exe_path: the string path to an executable to be called.
An array containing a command_line or an exe_path, along with zero or more string arguments for the command.
Basically a wrapper for Process.spawn that:
Creates a child process for each of the given cmds by calling Process.spawn.
Pipes the stdout from each child to the stdin of the next child, or, for the first child, pipes the caller’s stdout to the child’s stdin.
The method does not wait for child processes to exit, so the caller must do so.
With no block given, returns a 2-element array containing:
The stdin stream of the first child process.
An array of the wait threads for all of the child processes.
Example:
first_stdin, wait_threads = Open3.pipeline_w('sort', 'cat -n') # => [#<IO:fd 7>, [#<Process::Waiter:0x000055e8de928278 run>, #<Process::Waiter:0x000055e8de923e80 run>]] first_stdin.puts("foo\nbar\nbaz") first_stdin.close # Send EOF to sort. wait_threads.each do |wait_thread| wait_thread.join end
Output:
1 bar 2 baz 3 foo
With a block given, calls the block with the stdin stream of the first child process, and an array of the wait processes:
Open3.pipeline_w('sort', 'cat -n') do |first_stdin, wait_threads| first_stdin.puts("foo\nbar\nbaz") first_stdin.close # Send EOF to sort. wait_threads.each do |wait_thread| wait_thread.join end end
Output:
1 bar 2 baz 3 foo
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
If the first argument is a hash, it becomes leading argument env in each call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in each call to Process.spawn; see Execution Options.
Each remaining argument in cmds is one of:
A command_line: a string that begins with a shell reserved word or special built-in, or contains one or more metacharacters.
An exe_path: the string path to an executable to be called.
An array containing a command_line or an exe_path, along with zero or more string arguments for the command.
Basically a wrapper for Process.spawn that:
Creates a child process for each of the given cmds by calling Process.spawn.
Pipes the stdout from each child to the stdin of the next child, or, for the first child, pipes the caller’s stdout to the child’s stdin.
The method does not wait for child processes to exit, so the caller must do so.
With no block given, returns a 2-element array containing:
The stdin stream of the first child process.
An array of the wait threads for all of the child processes.
Example:
first_stdin, wait_threads = Open3.pipeline_w('sort', 'cat -n') # => [#<IO:fd 7>, [#<Process::Waiter:0x000055e8de928278 run>, #<Process::Waiter:0x000055e8de923e80 run>]] first_stdin.puts("foo\nbar\nbaz") first_stdin.close # Send EOF to sort. wait_threads.each do |wait_thread| wait_thread.join end
Output:
1 bar 2 baz 3 foo
With a block given, calls the block with the stdin stream of the first child process, and an array of the wait processes:
Open3.pipeline_w('sort', 'cat -n') do |first_stdin, wait_threads| first_stdin.puts("foo\nbar\nbaz") first_stdin.close # Send EOF to sort. wait_threads.each do |wait_thread| wait_thread.join end end
Output:
1 bar 2 baz 3 foo
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
If the first argument is a hash, it becomes leading argument env in each call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in each call to Process.spawn; see Execution Options.
Each remaining argument in cmds is one of:
A command_line: a string that begins with a shell reserved word or special built-in, or contains one or more metacharacters.
An exe_path: the string path to an executable to be called.
An array containing a command_line or an exe_path, along with zero or more string arguments for the command.
Basically a wrapper for Process.spawn that:
Creates a child process for each of the given cmds by calling Process.spawn.
Pipes the stdout from each child to the stdin of the next child, or, for the last child, to the caller’s stdout.
Waits for the child processes to exit.
Returns an array of Process::Status objects (one for each child).
Example:
wait_threads = Open3.pipeline('ls', 'grep R') # => [#<Process::Status: pid 2139200 exit 0>, #<Process::Status: pid 2139202 exit 0>]
Output:
Rakefile README.md
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
If the first argument is a hash, it becomes leading argument env in each call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in each call to Process.spawn‘ see Execution Options.
Each remaining argument in cmds is one of:
A command_line: a string that begins with a shell reserved word or special built-in, or contains one or more metacharacters.
An exe_path: the string path to an executable to be called.
An array containing a command_line or an exe_path, along with zero or more string arguments for the command.
Basically a wrapper for Process.spawn that:
Creates a child process for each of the given cmds by calling Process.spawn.
Pipes the stdout from each child to the stdin of the next child, or, for the last child, to the caller’s stdout.
Waits for the child processes to exit.
Returns an array of Process::Status objects (one for each child).
Example:
wait_threads = Open3.pipeline('ls', 'grep R') # => [#<Process::Status: pid 2139200 exit 0>, #<Process::Status: pid 2139202 exit 0>]
Output:
Rakefile README.md
Like Process.spawn, this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
If the first argument is a hash, it becomes leading argument env in each call to Process.spawn; see Execution Environment.
If the last argument is a hash, it becomes trailing argument options in each call to Process.spawn‘ see Execution Options.
Each remaining argument in cmds is one of:
A command_line: a string that begins with a shell reserved word or special built-in, or contains one or more metacharacters.
An exe_path: the string path to an executable to be called.
An array containing a command_line or an exe_path, along with zero or more string arguments for the command.
Mirror the Prism.parse API by using the serialization API.
Notify the Ruby virtual machine that the boot sequence is finished, and that now is a good time to optimize the application. This is useful for long running applications.
This method is expected to be called at the end of the application boot. If the application is deployed using a pre-forking model, Process.warmup should be called in the original process before the first fork.
The actual optimizations performed are entirely implementation specific and may change in the future without notice.
On CRuby, Process.warmup:
Performs a major GC.
Compacts the heap.
Promotes all surviving objects to the old generation.
Precomputes the coderange of all strings.
Frees all empty heap pages and increments the allocatable pages counter by the number of pages freed.
Invoke malloc_trim if available to free empty malloc pages.
Returns the name of the script being executed. The value is not affected by assigning a new value to $0.
This method first appeared in Ruby 2.1 to serve as a global variable free means to get the script name.