List of dependencies that are used for development
Duplicates Array and Gem::Requirement attributes from other_spec so state isn’t shared.
Checks if this specification meets the requirement of dependency.
Uninstalls gem spec
Given an already existing block in the frontier, expand it to see if it contains our invalid syntax
Constructs the default Hash of patterns.
Constructs the default Hash of Regexp’s.
Constructs the default Hash of patterns.
Constructs the default Hash of Regexp’s.
Invoked by IO#wait, IO#wait_readable, IO#wait_writable to ask whether the specified descriptor is ready for specified events within the specified timeout.
events is a bit mask of IO::READABLE, IO::WRITABLE, and IO::PRIORITY.
Suggested implementation should register which Fiber is waiting for which resources and immediately calling Fiber.yield to pass control to other fibers. Then, in the close method, the scheduler might dispatch all the I/O resources to fibers waiting for it.
Expected to return the subset of events that are ready immediately.
Invoked by IO#read or IO#Buffer.read to read length bytes from io into a specified buffer (see IO::Buffer) at the given offset.
The length argument is the “minimum length to be read”. If the IO buffer size is 8KiB, but the length is 1024 (1KiB), up to 8KiB might be read, but at least 1KiB will be. Generally, the only case where less data than length will be read is if there is an error reading the data.
Specifying a length of 0 is valid and means try reading at least once and return any available data.
Suggested implementation should try to read from io in a non-blocking manner and call io_wait if the io is not ready (which will yield control to other fibers).
See IO::Buffer for an interface available to return data.
Expected to return number of bytes read, or, in case of an error, -errno (negated number corresponding to system’s error code).
The method should be considered experimental.
Invoked by IO#write or IO::Buffer#write to write length bytes to io from from a specified buffer (see IO::Buffer) at the given offset.
The length argument is the “minimum length to be written”. If the IO buffer size is 8KiB, but the length specified is 1024 (1KiB), at most 8KiB will be written, but at least 1KiB will be. Generally, the only case where less data than length will be written is if there is an error writing the data.
Specifying a length of 0 is valid and means try writing at least once, as much data as possible.
Suggested implementation should try to write to io in a non-blocking manner and call io_wait if the io is not ready (which will yield control to other fibers).
See IO::Buffer for an interface available to get data from buffer efficiently.
Expected to return number of bytes written, or, in case of an error, -errno (negated number corresponding to system’s error code).
The method should be considered experimental.
Invoked by IO#pread or IO::Buffer#pread to read length bytes from io at offset from into a specified buffer (see IO::Buffer) at the given offset.
This method is semantically the same as io_read, but it allows to specify the offset to read from and is often better for asynchronous IO on the same file.
The method should be considered experimental.
Invoked by IO#pwrite or IO::Buffer#pwrite to write length bytes to io at offset from into a specified buffer (see IO::Buffer) at the given offset.
This method is semantically the same as io_write, but it allows to specify the offset to write to and is often better for asynchronous IO on the same file.
The method should be considered experimental.
Invoked by Timeout.timeout to execute the given block within the given duration. It can also be invoked directly by the scheduler or user code.
Attempt to limit the execution time of a given block to the given duration if possible. When a non-blocking operation causes the block‘s execution time to exceed the specified duration, that non-blocking operation should be interrupted by raising the specified exception_class constructed with the given exception_arguments.
General execution timeouts are often considered risky. This implementation will only interrupt non-blocking operations. This is by design because it’s expected that non-blocking operations can fail for a variety of unpredictable reasons, so applications should already be robust in handling these conditions and by implication timeouts.
However, as a result of this design, if the block does not invoke any non-blocking operations, it will be impossible to interrupt it. If you desire to provide predictable points for timeouts, consider adding +sleep(0)+.
If the block is executed successfully, its result will be returned.
The exception will typically be raised using Fiber#raise.
Returns the number of threads waiting on the queue.
Returns the number of threads waiting on the queue.