Results for: "pstore"

Remove the oldest DependencyRequest from the list.

The prefetch method may be overridden, but this is not necessary. This default implementation does nothing, which is suitable for sets where looking up a specification is cheap (such as installed gems).

When overridden, the prefetch method should look up specifications matching reqs.

The platform this gem works on.

Installs this specification using the Gem::Installer options. The install method yields a Gem::Installer instance, which indicates the gem will be installed, or nil, which indicates the gem is already installed.

After installation spec is updated to point to the just-installed specification.

This is a null install as this gem was unpacked into a directory. options are ignored.

Executes a SpecFetcher setup block. Yields an instance then creates the gems and specifications defined in the instance.

Reloads passwords from the database

Reload groups from the database

Reload passwords from the database

Returns all the FormData as an Array

This FormData’s body

Returns a Kernel#caller style string representing this frame.

@macro action

@return [Array<Vertex>] the vertices of {#graph} where ‘self` is an

{#ancestor?}

Sets up the resolution process @return [void]

In case we’re building docs in a background process, this method waits for that process to exit (or if it’s already been reaped, or never happened, swallows the Errno::ECHILD error).

Similar to Object#to_enum, except it returns a lazy enumerator. This makes it easy to define Enumerable methods that will naturally remain lazy if called from a lazy enumerator.

For example, continuing from the example in Object#to_enum:

# See Object#to_enum for the definition of repeat
r = 1..Float::INFINITY
r.repeat(2).first(5) # => [1, 1, 2, 2, 3]
r.repeat(2).class # => Enumerator
r.repeat(2).map{|n| n ** 2}.first(5) # => endless loop!
# works naturally on lazy enumerator:
r.lazy.repeat(2).class # => Enumerator::Lazy
r.lazy.repeat(2).map{|n| n ** 2}.first(5) # => [1, 1, 4, 4, 9]

Similar to Object#to_enum, except it returns a lazy enumerator. This makes it easy to define Enumerable methods that will naturally remain lazy if called from a lazy enumerator.

For example, continuing from the example in Object#to_enum:

# See Object#to_enum for the definition of repeat
r = 1..Float::INFINITY
r.repeat(2).first(5) # => [1, 1, 2, 2, 3]
r.repeat(2).class # => Enumerator
r.repeat(2).map{|n| n ** 2}.first(5) # => endless loop!
# works naturally on lazy enumerator:
r.lazy.repeat(2).class # => Enumerator::Lazy
r.lazy.repeat(2).map{|n| n ** 2}.first(5) # => [1, 1, 4, 4, 9]

Like Enumerable#reject, but chains operation to be lazy-evaluated.

Like Enumerable#grep, but chains operation to be lazy-evaluated.

Like Enumerable#grep_v, but chains operation to be lazy-evaluated.

Returns a Proc object that takes an argument and yields it.

This method is implemented so that a Yielder object can be directly passed to another method as a block argument.

enum = Enumerator.new { |y|
  Dir.glob("*.rb") { |file|
    File.open(file) { |f| f.each_line(&y) }
  }
}