Responsible for finding the nearest targets to the given comment within the context of the given encapsulating node.
Fetch the start line of the value.
Fetch the start byte offset of the value.
Fetch the start byte column of the value.
Build a diagnostic from the given prism parse error.
Visit a list of elements, like the elements of an array or arguments.
Parse the given file and translate it into the seattlerb/ruby_parser gem’s Sexp format.
Parse the given file and translate it into the seattlerb/ruby_parser gem’s Sexp format.
Git binary path
Builds extensions. Valid types of extensions are extconf.rb files, configure scripts and rakefiles or mkrf_conf files.
Returns the path to the trusted certificate
Adds to self all elements from each array in other_arrays; returns self:
a = [0, 1] a.concat(['two', 'three'], [:four, :five], a) # => [0, 1, "two", "three", :four, :five, 0, 1]
Related: see Methods for Assigning.
Inserts the given objects as elements of self; returns self.
When index is non-negative, inserts objects before the element at offset index:
a = ['a', 'b', 'c'] # => ["a", "b", "c"] a.insert(1, :x, :y, :z) # => ["a", :x, :y, :z, "b", "c"]
Extends the array if index is beyond the array (index >= self.size):
a = ['a', 'b', 'c'] # => ["a", "b", "c"] a.insert(5, :x, :y, :z) # => ["a", "b", "c", nil, nil, :x, :y, :z]
When index is negative, inserts objects after the element at offset index + self.size:
a = ['a', 'b', 'c'] # => ["a", "b", "c"] a.insert(-2, :x, :y, :z) # => ["a", "b", :x, :y, :z, "c"]
With no objects given, does nothing:
a = ['a', 'b', 'c'] # => ["a", "b", "c"] a.insert(1) # => ["a", "b", "c"] a.insert(50) # => ["a", "b", "c"] a.insert(-50) # => ["a", "b", "c"]
Raises IndexError if objects are given and index is negative and out of range.
Related: see Methods for Assigning.
Returns a new array containing the elements of self, sorted.
With no block given, compares elements using operator #<=> (see Object#<=>):
[0, 2, 3, 1].sort # => [0, 1, 2, 3]
With a block given, calls the block with each combination of pairs of elements from self; for each pair a and b, the block should return a numeric:
Negative when b is to follow a.
Zero when a and b are equivalent.
Positive when a is to follow b.
Example:
a = [3, 2, 0, 1] a.sort {|a, b| a <=> b } # => [0, 1, 2, 3] a.sort {|a, b| b <=> a } # => [3, 2, 1, 0]
When the block returns zero, the order for a and b is indeterminate, and may be unstable.
Related: see Methods for Fetching.
Like Array#sort, but returns self with its elements sorted in place.
Related: see Methods for Assigning.
Removes all elements from self; returns self:
a = [:foo, 'bar', 2] a.clear # => []
Related: see Methods for Deleting.
Returns a new array containing only the non-nil elements from self; element order is preserved:
a = [nil, 0, nil, false, nil, '', nil, [], nil, {}] a.compact # => [0, false, "", [], {}]
Related: Array#compact!; see also Methods for Deleting.
Removes all nil elements from self; Returns self if any elements are removed, nil otherwise:
a = [nil, 0, nil, false, nil, '', nil, [], nil, {}] a.compact! # => [0, false, "", [], {}] a # => [0, false, "", [], {}] a.compact! # => nil
Related: Array#compact; see also Methods for Deleting.