Ensures the root of chain has a trusted certificate in trust_dir and the digests of the two certificates match according to digester
Return the 2 dependency objects that conflicted
Returns true if this gem is installable for the current platform.
Returns true if this gem is installable for the current platform.
Returns true if this specification is installable on this platform.
Add a certificate to trusted certificate list.
Returns the new String formed by calling method #inspect on each array element:
a = [:foo, 'bar', 2] a.inspect # => "[:foo, \"bar\", 2]"
Returns a new Array containing each element found both in self and in all of the given Arrays other_arrays; duplicates are omitted; items are compared using eql? (items must also implement hash correctly):
[0, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3]) # => [0, 1] [0, 0, 1, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3]) # => [0, 1]
Preserves order from self:
[0, 1, 2].intersection([2, 1, 0]) # => [0, 1, 2]
Returns a copy of self if no arguments given.
Related: Array#&.
Returns true if the array and other_ary have at least one element in common, otherwise returns false:
a = [ 1, 2, 3 ] b = [ 3, 4, 5 ] c = [ 5, 6, 7 ] a.intersect?(b) #=> true a.intersect?(c) #=> false
Array elements are compared using eql? (items must also implement hash correctly).
Inserts given objects before or after the element at Integer index offset; returns self.
When index is non-negative, inserts all given objects before the element at offset index:
a = [:foo, 'bar', 2] a.insert(1, :bat, :bam) # => [:foo, :bat, :bam, "bar", 2]
Extends the array if index is beyond the array (index >= self.size):
a = [:foo, 'bar', 2] a.insert(5, :bat, :bam) a # => [:foo, "bar", 2, nil, nil, :bat, :bam]
Does nothing if no objects given:
a = [:foo, 'bar', 2] a.insert(1) a.insert(50) a.insert(-50) a # => [:foo, "bar", 2]
When index is negative, inserts all given objects after the element at offset index+self.size:
a = [:foo, 'bar', 2] a.insert(-2, :bat, :bam) a # => [:foo, "bar", :bat, :bam, 2]
Returns the count of elements in self.
Returns the index of a specified element.
When argument object is given but no block, returns the index of the first element element for which object == element:
a = [:foo, 'bar', 2, 'bar'] a.index('bar') # => 1
Returns nil if no such element found.
When both argument object and a block are given, calls the block with each successive element; returns the index of the first element for which the block returns a truthy value:
a = [:foo, 'bar', 2, 'bar'] a.index {|element| element == 'bar' } # => 1
Returns nil if the block never returns a truthy value.
When neither an argument nor a block is given, returns a new Enumerator:
a = [:foo, 'bar', 2] e = a.index e # => #<Enumerator: [:foo, "bar", 2]:index> e.each {|element| element == 'bar' } # => 1
Related: rindex.
Returns the new String formed by joining the array elements after conversion. For each element element:
Uses element.to_s if element is not a kind_of?(Array).
Uses recursive element.join(separator) if element is a kind_of?(Array).
With no argument, joins using the output field separator, $,:
a = [:foo, 'bar', 2] $, # => nil a.join # => "foobar2"
With string argument separator, joins using that separator:
a = [:foo, 'bar', 2] a.join("\n") # => "foo\nbar\n2"
Joins recursively for nested Arrays:
a = [:foo, [:bar, [:baz, :bat]]] a.join # => "foobarbazbat"
Transposes the rows and columns in an Array of Arrays; the nested Arrays must all be the same size:
a = [[:a0, :a1], [:b0, :b1], [:c0, :c1]] a.transpose # => [[:a0, :b0, :c0], [:a1, :b1, :c1]]
Returns true if for some index i in self, obj == self[i]; otherwise false:
[0, 1, 2].include?(2) # => true [0, 1, 2].include?(3) # => false
Returns one of the following:
The minimum-valued element from self.
A new Array of minimum-valued elements selected from self.
When no block is given, each element in self must respond to method <=> with an Integer.
With no argument and no block, returns the element in self having the minimum value per method <=>:
[0, 1, 2].min # => 0
With Integer argument n and no block, returns a new Array with at most n elements, in ascending order per method <=>:
[0, 1, 2, 3].min(3) # => [0, 1, 2] [0, 1, 2, 3].min(6) # => [0, 1, 2, 3]
When a block is given, the block must return an Integer.
With a block and no argument, calls the block self.size-1 times to compare elements; returns the element having the minimum value per the block:
['0', '00', '000'].min { |a, b| a.size <=> b.size } # => "0"
With an argument n and a block, returns a new Array with at most n elements, in ascending order per the block:
['0', '00', '000'].min(2) {|a, b| a.size <=> b.size } # => ["0", "00"]
Returns a new 2-element Array containing the minimum and maximum values from self, either per method <=> or per a given block:.
When no block is given, each element in self must respond to method <=> with an Integer; returns a new 2-element Array containing the minimum and maximum values from self, per method <=>:
[0, 1, 2].minmax # => [0, 2]
When a block is given, the block must return an Integer; the block is called self.size-1 times to compare elements; returns a new 2-element Array containing the minimum and maximum values from self, per the block:
['0', '00', '000'].minmax {|a, b| a.size <=> b.size } # => ["0", "000"]