Results for: "match"

Adds this spec’s require paths to LOAD_PATH, in the proper location.

Reset nil attributes to their default values to make the spec valid

Raw Strings are JSON Objects (the raw bytes are stored in an array for the key “raw”). The Ruby String can be created by this module method.

@macro action

Processes the topmost available {RequirementState} on the stack @return [void]

@return [ResolutionState] the state whose ‘requirement` is the given

`requirement`.

Ensures there are no orphaned successors to the given {vertex}. @param [DependencyGraph::Vertex] vertex the vertex to fix up. @return [void]

@return [Boolean] whether the current spec is satisfied as a new possibility.

(see Gem::Resolver::Molinillo::SpecificationProvider#requirement_satisfied_by?)

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).

@return [Integer] The index to which the resolution should unwind in the

case of conflict.

Attempts to swp the current {#possibility} with the already-activated spec with the given name @return [Boolean] Whether the possibility was swapped into {#activated}

Pushes a new {DependencyState} that encapsulates both existing and new requirements @param [Array] new_requirements @return [void]

Pushes a new {DependencyState}. If the {#specification_provider} says to {SpecificationProvider#allow_missing?} that particular requirement, and there are no possibilities for that requirement, then ‘state` is not pushed, and the node in {#activated} is removed, and we continue resolving the remaining requirements. @param [DependencyState] state @return [void]

Ensures any raised {NoSuchDependencyError} has its {NoSuchDependencyError#required_by} set. @yield

Returns the regexp.

m = /a.*b/.match("abc")
m.regexp #=> /a.*b/

Returns a list of names of captures as an array of strings. It is same as mtch.regexp.names.

/(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge").names
#=> ["foo", "bar", "baz"]

m = /(?<x>.)(?<y>.)?/.match("a") #=> #<MatchData "a" x:"a" y:nil>
m.names                          #=> ["x", "y"]