Results for: "match"

Add the current {#possibility} to the dependency graph of the current {#state} @return [void]

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

Ruby expects the dylib to follow a file name convention for loading

This method verifies that there are no (obvious) ambiguities with the provided col_sep and strip parsing options. For example, if col_sep and strip were both equal to \t, then there would be no clear way to parse the input.

Raises a VersionConflict error, or any underlying error, if there is no current state @return [void]

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

@return [Boolean] where the requirement of the state we’re unwinding

to directly caused the conflict. Note: in this case, it is
impossible for the state we're unwinding to to be a parent of
any of the other conflicting requirements (or we would have
circularity)

Filter’s a state’s possibilities to remove any that would not satisfy the requirements in the conflict we’ve just rewound from @param [UnwindDetails] unwind_details details of the conflict just unwound from @return [void]

Attempts to update the existing vertex’s ‘PossibilitySet` with a filtered version @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 vertex 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 that produced the match:

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

Returns an array of the capture names (see Named Captures):

m = /(?<foo>.)(?<bar>.)(?<baz>.)/.match("hoge")
# => #<MatchData "hog" foo:"h" bar:"o" baz:"g">
m.names # => ["foo", "bar", "baz"]

m = /foo/.match('foo') # => #<MatchData "foo">
m.names # => [] # No named captures.

Equivalent to:

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

Returns size of the match array:

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m.size # => 5

MatchData#length is an alias for MatchData.size.

Returns size of the match array:

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m.size # => 5

MatchData#length is an alias for MatchData.size.

Returns a 2-element array containing the beginning and ending offsets (in characters) of the specified match.

When non-negative integer argument n is given, returns the starting and ending offsets of the nth match:

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m[0]        # => "HX1138"
m.offset(0) # => [1, 7]
m[3]        # => "113"
m.offset(3) # => [3, 6]

m = /(т)(е)(с)/.match('тест')
# => #<MatchData "тес" 1:"т" 2:"е" 3:"с">
m[0]        # => "тес"
m.offset(0) # => [0, 3]
m[3]        # => "с"
m.offset(3) # => [2, 3]

When string or symbol argument name is given, returns the starting and ending offsets for the named match:

m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
# => #<MatchData "hog" foo:"h" bar:"g">
m[:foo]         # => "h"
m.offset('foo') # => [0, 1]
m[:bar]         # => "g"
m.offset(:bar)  # => [2, 3]

Related: MatchData#byteoffset, MatchData#begin, MatchData#end.

Returns a two-element array containing the beginning and ending byte-based offsets of the nth match. n can be a string or symbol to reference a named capture.

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
m.byteoffset(0)      #=> [1, 7]
m.byteoffset(4)      #=> [6, 7]

m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
p m.byteoffset(:foo) #=> [0, 1]
p m.byteoffset(:bar) #=> [2, 3]

Returns the offset (in characters) of the beginning of the specified match.

When non-negative integer argument n is given, returns the offset of the beginning of the nth match:

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m[0]       # => "HX1138"
m.begin(0) # => 1
m[3]       # => "113"
m.begin(3) # => 3

m = /(т)(е)(с)/.match('тест')
# => #<MatchData "тес" 1:"т" 2:"е" 3:"с">
m[0]       # => "тес"
m.begin(0) # => 0
m[3]       # => "с"
m.begin(3) # => 2

When string or symbol argument name is given, returns the offset of the beginning for the named match:

m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
# => #<MatchData "hog" foo:"h" bar:"g">
m[:foo]        # => "h"
m.begin('foo') # => 0
m[:bar]        # => "g"
m.begin(:bar)  # => 2

Related: MatchData#end, MatchData#offset, MatchData#byteoffset.

Returns the offset (in characters) of the end of the specified match.

When non-negative integer argument n is given, returns the offset of the end of the nth match:

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m[0]     # => "HX1138"
m.end(0) # => 7
m[3]     # => "113"
m.end(3) # => 6

m = /(т)(е)(с)/.match('тест')
# => #<MatchData "тес" 1:"т" 2:"е" 3:"с">
m[0]     # => "тес"
m.end(0) # => 3
m[3]     # => "с"
m.end(3) # => 3

When string or symbol argument name is given, returns the offset of the end for the named match:

m = /(?<foo>.)(.)(?<bar>.)/.match("hoge")
# => #<MatchData "hog" foo:"h" bar:"g">
m[:foo]      # => "h"
m.end('foo') # => 1
m[:bar]      # => "g"
m.end(:bar)  # => 3

Related: MatchData#begin, MatchData#offset, MatchData#byteoffset.

Returns the array of matches:

m = /(.)(.)(\d+)(\d)/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8">
m.to_a # => ["HX1138", "H", "X", "113", "8"]

Related: MatchData#captures.