Net::HTTP
exception class. You cannot use Net::HTTPExceptions
directly; instead, you must use its subclasses.
Keyword completion module. This allows partial arguments to be specified and resolved against a list of acceptable values.
This module is responsible for converting the prism syntax tree into other syntax trees.
Mixin methods for install and update options for Gem::Commands
Mixin methods for local and remote Gem::Command
options.
Mixin methods for Gem::Command
to promote available RubyGems update
Module
that defines the default UserInteraction
. Any class including this module will have access to the ui
method that returns the default UI.
UserInteraction
allows RubyGems to interact with the user through standard methods that can be replaced with more-specific UI methods for different displays.
Since UserInteraction
dispatches to a concrete UI class you may need to reference other classes for specific behavior such as Gem::ConsoleUI
or Gem::SilentUI
.
Example:
class X include Gem::UserInteraction def get_answer n = ask("What is the meaning of life?") end end
A pointer to a C structure
Response class for Continue
responses (status code 100).
A Continue
response indicates that the server has received the request headers.
References:
Response class for Unprocessable Entity
responses (status code 422).
The request was well-formed but had semantic errors.
References:
Response class for HTTP Version Not Supported
responses (status code 505).
The server does not support the HTTP
version used in the request.
References:
WriteTimeout
, a subclass of Timeout::Error
, is raised if a chunk of the response cannot be written within the write_timeout. Not raised on Windows.
This represents a warning that was encountered during parsing.
There are three main phases in the algorithm:
Sanitize/format input source
Search for invalid blocks
Format invalid blocks into something meaninful
The Code frontier is a critical part of the second step
## Knowing where we’ve been
Once a code block is generated it is added onto the frontier. Then it will be sorted by indentation and frontier can be filtered. Large blocks that fully enclose a smaller block will cause the smaller block to be evicted.
CodeFrontier#<<(block) # Adds block to frontier CodeFrontier#pop # Removes block from frontier
## Knowing where we can go
Internally the frontier keeps track of “unvisited” lines which are exposed via ‘next_indent_line` when called, this method returns, a line of code with the highest indentation.
The returned line of code can be used to build a CodeBlock
and then that code block is added back to the frontier. Then, the lines are removed from the “unvisited” so we don’t double-create the same block.
CodeFrontier#next_indent_line # Shows next line CodeFrontier#register_indent_block(block) # Removes lines from unvisited
## Knowing when to stop
The frontier knows how to check the entire document for a syntax error. When blocks are added onto the frontier, they’re removed from the document. When all code containing syntax errors has been added to the frontier, the document will be parsable without a syntax error and the search can stop.
CodeFrontier#holds_all_syntax_errors? # Returns true when frontier holds all syntax errors
## Filtering false positives
Once the search is completed, the frontier may have multiple blocks that do not contain the syntax error. To limit the result to the smallest subset of “invalid blocks” call:
CodeFrontier#detect_invalid_blocks
An Array
is an ordered, integer-indexed collection of objects, called elements. Any object (even another array) may be an array element, and an array can contain objects of different types.
Array
Indexes Array
indexing starts at 0, as in C or Java.
A positive index is an offset from the first element:
Index 0 indicates the first element.
Index 1 indicates the second element.
…
A negative index is an offset, backwards, from the end of the array:
Index -1 indicates the last element.
Index -2 indicates the next-to-last element.
…
A non-negative index is in range if and only if it is smaller than the size of the array. For a 3-element array:
Indexes 0 through 2 are in range.
Index 3 is out of range.
A negative index is in range if and only if its absolute value is not larger than the size of the array. For a 3-element array:
Indexes -1 through -3 are in range.
Index -4 is out of range.
Although the effective index into an array is always an integer, some methods (both within and outside of class Array
) accept one or more non-integer arguments that are integer-convertible objects.
You can create an Array
object explicitly with:
An array literal:
[1, 'one', :one, [2, 'two', :two]]
A array literal:
%w[foo bar baz] # => ["foo", "bar", "baz"] %w[1 % *] # => ["1", "%", "*"]
A array literal:
%i[foo bar baz] # => [:foo, :bar, :baz] %i[1 % *] # => [:"1", :%, :*]
Method Kernel#Array
:
Array(["a", "b"]) # => ["a", "b"] Array(1..5) # => [1, 2, 3, 4, 5] Array(key: :value) # => [[:key, :value]] Array(nil) # => [] Array(1) # => [1] Array({:a => "a", :b => "b"}) # => [[:a, "a"], [:b, "b"]]
Method Array.new
:
Array.new # => [] Array.new(3) # => [nil, nil, nil] Array.new(4) {Hash.new} # => [{}, {}, {}, {}] Array.new(3, true) # => [true, true, true]
Note that the last example above populates the array with references to the same object. This is recommended only in cases where that object is a natively immutable object such as a symbol, a numeric, nil
, true
, or false
.
Another way to create an array with various objects, using a block; this usage is safe for mutable objects such as hashes, strings or other arrays:
Array.new(4) {|i| i.to_s } # => ["0", "1", "2", "3"]
Here is a way to create a multi-dimensional array:
Array.new(3) {Array.new(3)} # => [[nil, nil, nil], [nil, nil, nil], [nil, nil, nil]]
A number of Ruby methods, both in the core and in the standard library, provide instance method to_a
, which converts an object to an array.
CSV::Table#to_a
Gem::List#to_a
Racc::ISet#to_a
Rinda::RingFinger#to_a
In addition to the methods it mixes in through the Enumerable
module, the Array
class has proprietary methods for accessing, searching and otherwise manipulating arrays.
Some of the more common ones are illustrated below.
Elements in an array can be retrieved using the Array#[]
method. It can take a single integer argument (a numeric index), a pair of arguments (start and length) or a range. Negative indices start counting from the end, with -1 being the last element.
arr = [1, 2, 3, 4, 5, 6] arr[2] #=> 3 arr[100] #=> nil arr[-3] #=> 4 arr[2, 3] #=> [3, 4, 5] arr[1..4] #=> [2, 3, 4, 5] arr[1..-3] #=> [2, 3, 4]
Another way to access a particular array element is by using the at
method
arr.at(0) #=> 1
The slice
method works in an identical manner to Array#[]
.
To raise an error for indices outside of the array bounds or else to provide a default value when that happens, you can use fetch
.
arr = ['a', 'b', 'c', 'd', 'e', 'f'] arr.fetch(100) #=> IndexError: index 100 outside of array bounds: -6...6 arr.fetch(100, "oops") #=> "oops"
The special methods first
and last
will return the first and last elements of an array, respectively.
arr.first #=> 1 arr.last #=> 6
To return the first n
elements of an array, use take
arr.take(3) #=> [1, 2, 3]
drop
does the opposite of take
, by returning the elements after n
elements have been dropped:
arr.drop(3) #=> [4, 5, 6]
Array
Arrays keep track of their own length at all times. To query an array about the number of elements it contains, use length
, count
or size
.
browsers = ['Chrome', 'Firefox', 'Safari', 'Opera', 'IE'] browsers.length #=> 5 browsers.count #=> 5
To check whether an array contains any elements at all
browsers.empty? #=> false
To check whether a particular item is included in the array
browsers.include?('Konqueror') #=> false
Items can be added to the end of an array by using either push
or <<
arr = [1, 2, 3, 4] arr.push(5) #=> [1, 2, 3, 4, 5] arr << 6 #=> [1, 2, 3, 4, 5, 6]
unshift
will add a new item to the beginning of an array.
arr.unshift(0) #=> [0, 1, 2, 3, 4, 5, 6]
With insert
you can add a new element to an array at any position.
arr.insert(3, 'apple') #=> [0, 1, 2, 'apple', 3, 4, 5, 6]
Using the insert
method, you can also insert multiple values at once:
arr.insert(3, 'orange', 'pear', 'grapefruit') #=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]
Array
The method pop
removes the last element in an array and returns it:
arr = [1, 2, 3, 4, 5, 6] arr.pop #=> 6 arr #=> [1, 2, 3, 4, 5]
To retrieve and at the same time remove the first item, use shift
:
arr.shift #=> 1 arr #=> [2, 3, 4, 5]
To delete an element at a particular index:
arr.delete_at(2) #=> 4 arr #=> [2, 3, 5]
To delete a particular element anywhere in an array, use delete
:
arr = [1, 2, 2, 3] arr.delete(2) #=> 2 arr #=> [1,3]
A useful method if you need to remove nil
values from an array is compact
:
arr = ['foo', 0, nil, 'bar', 7, 'baz', nil] arr.compact #=> ['foo', 0, 'bar', 7, 'baz'] arr #=> ['foo', 0, nil, 'bar', 7, 'baz', nil] arr.compact! #=> ['foo', 0, 'bar', 7, 'baz'] arr #=> ['foo', 0, 'bar', 7, 'baz']
Another common need is to remove duplicate elements from an array.
It has the non-destructive uniq
, and destructive method uniq!
arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556] arr.uniq #=> [2, 5, 6, 556, 8, 9, 0, 123]
Like all classes that include the Enumerable
module, Array
has an each method, which defines what elements should be iterated over and how. In case of Array’s each
, all elements in the Array
instance are yielded to the supplied block in sequence.
Note that this operation leaves the array unchanged.
arr = [1, 2, 3, 4, 5] arr.each {|a| print a -= 10, " "} # prints: -9 -8 -7 -6 -5 #=> [1, 2, 3, 4, 5]
Another sometimes useful iterator is reverse_each
which will iterate over the elements in the array in reverse order.
words = %w[first second third fourth fifth sixth] str = "" words.reverse_each {|word| str += "#{word} "} p str #=> "sixth fifth fourth third second first "
The map
method can be used to create a new array based on the original array, but with the values modified by the supplied block:
arr.map {|a| 2*a} #=> [2, 4, 6, 8, 10] arr #=> [1, 2, 3, 4, 5] arr.map! {|a| a**2} #=> [1, 4, 9, 16, 25] arr #=> [1, 4, 9, 16, 25]
Array
Elements can be selected from an array according to criteria defined in a block. The selection can happen in a destructive or a non-destructive manner. While the destructive operations will modify the array they were called on, the non-destructive methods usually return a new array with the selected elements, but leave the original array unchanged.
arr = [1, 2, 3, 4, 5, 6] arr.select {|a| a > 3} #=> [4, 5, 6] arr.reject {|a| a < 3} #=> [3, 4, 5, 6] arr.drop_while {|a| a < 4} #=> [4, 5, 6] arr #=> [1, 2, 3, 4, 5, 6]
select!
and reject!
are the corresponding destructive methods to select
and reject
Similar to select
vs. reject
, delete_if
and keep_if
have the exact opposite result when supplied with the same block:
arr.delete_if {|a| a < 4} #=> [4, 5, 6] arr #=> [4, 5, 6] arr = [1, 2, 3, 4, 5, 6] arr.keep_if {|a| a < 4} #=> [1, 2, 3] arr #=> [1, 2, 3]
First, what’s elsewhere. Class Array
:
Inherits from class Object.
Includes module Enumerable, which provides dozens of additional methods.
Here, class Array
provides methods that are useful for:
Array
::[]
: Returns a new array populated with given objects.
::new
: Returns a new array.
::try_convert
: Returns a new array created from a given object.
include?
: Returns whether any element ==
a given object.
empty?
: Returns whether there are no elements.
all?
: Returns whether all elements meet a given criterion.
any?
: Returns whether any element meets a given criterion.
none?
: Returns whether no element ==
a given object.
one?
: Returns whether exactly one element ==
a given object.
count
: Returns the count of elements that meet a given criterion.
find_index
, index
: Returns the index of the first element that meets a given criterion.
rindex
: Returns the index of the last element that meets a given criterion.
hash
: Returns the integer hash code.
<=>
: Returns -1, 0, or 1 * as self
is less than, equal to, or greater than a given object.
==
: Returns whether each element in self
is ==
to the corresponding element in a given object.
eql?
: Returns whether each element in self
is eql?
to the corresponding element in a given object.
These methods do not modify self
.
[]
: Returns one or more elements.
fetch
: Returns the element at a given offset.
first
: Returns one or more leading elements.
last
: Returns one or more trailing elements.
max
: Returns one or more maximum-valued elements, as determined by <=>
or a given block.
min
: Returns one or more minimum-valued elements, as determined by <=>
or a given block.
minmax
: Returns the minimum-valued and maximum-valued elements, as determined by <=>
or a given block.
assoc
: Returns the first element that is an array whose first element ==
a given object.
rassoc
: Returns the first element that is an array whose second element ==
a given object.
at
: Returns the element at a given offset.
values_at
: Returns the elements at given offsets.
dig
: Returns the object in nested objects that is specified by a given index and additional arguments.
drop
: Returns trailing elements as determined by a given index.
take
: Returns leading elements as determined by a given index.
drop_while
: Returns trailing elements as determined by a given block.
take_while
: Returns leading elements as determined by a given block.
slice
: Returns consecutive elements as determined by a given argument.
sort
: Returns all elements in an order determined by <=>
or a given block.
reverse
: Returns all elements in reverse order.
compact
: Returns an array containing all non-nil
elements.
select
, filter
: Returns an array containing elements selected by a given block.
uniq
: Returns an array containing non-duplicate elements.
rotate
: Returns all elements with some rotated from one end to the other.
bsearch
: Returns an element selected via a binary search as determined by a given block.
bsearch_index
: Returns the index of an element selected via a binary search as determined by a given block.
sample
: Returns one or more random elements.
shuffle
: Returns elements in a random order.
These methods add, replace, or reorder elements in self
.
[]=
: Assigns specified elements with a given object.
insert
: Inserts given objects at a given offset; does not replace elements.
concat
: Appends all elements from given arrays.
fill
: Replaces specified elements with specified objects.
replace
: Replaces the content of self
with the content of a given array.
reverse!
: Replaces self
with its elements reversed.
rotate!
: Replaces self
with its elements rotated.
shuffle!
: Replaces self
with its elements in random order.
sort!
: Replaces self
with its elements sorted, as determined by <=>
or a given block.
sort_by!
: Replaces self
with its elements sorted, as determined by a given block.
Each of these methods removes elements from self
:
pop
: Removes and returns the last element.
shift
: Removes and returns the first element.
compact!
: Removes all nil
elements.
delete
: Removes elements equal to a given object.
delete_at
: Removes the element at a given offset.
delete_if
: Removes elements specified by a given block.
keep_if
: Removes elements not specified by a given block.
reject!
: Removes elements specified by a given block.
select!
, filter!
: Removes elements not specified by a given block.
slice!
: Removes and returns a sequence of elements.
uniq!
: Removes duplicates.
&
: Returns an array containing elements found both in self
and a given array.
intersection
: Returns an array containing elements found both in self
and in each given array.
+
: Returns an array containing all elements of self
followed by all elements of a given array.
-
: Returns an array containing all elements of self
that are not found in a given array.
|
: Returns an array containing all elements of self
and all elements of a given array, duplicates removed.
union
: Returns an array containing all elements of self
and all elements of given arrays, duplicates removed.
difference
: Returns an array containing all elements of self
that are not found in any of the given arrays..
product
: Returns or yields all combinations of elements from self
and given arrays.
each
: Passes each element to a given block.
reverse_each
: Passes each element, in reverse order, to a given block.
each_index
: Passes each element index to a given block.
cycle
: Calls a given block with each element, then does so again, for a specified number of times, or forever.
combination
: Calls a given block with combinations of elements of self
; a combination does not use the same element more than once.
permutation
: Calls a given block with permutations of elements of self
; a permutation does not use the same element more than once.
repeated_combination
: Calls a given block with combinations of elements of self
; a combination may use the same element more than once.
repeated_permutation
: Calls a given block with permutations of elements of self
; a permutation may use the same element more than once.
map
, collect
: Returns an array containing the block return-value for each element.
map!
, collect!
: Replaces each element with a block return-value.
flatten
: Returns an array that is a recursive flattening of self
.
flatten!
: Replaces each nested array in self
with the elements from that array.
inspect
, to_s
: Returns a new String
containing the elements.
join
: Returns a newsString containing the elements joined by the field separator.
to_a
: Returns self
or a new array containing all elements.
to_ary
: Returns self
.
to_h
: Returns a new hash formed from the elements.
transpose
: Transposes self
, which must be an array of arrays.
zip
: Returns a new array of arrays containing self
and given arrays; follow the link for details.
*
: Returns one of the following:
With integer argument n
, a new array that is the concatenation of n
copies of self
.
With string argument field_separator
, a new string that is equivalent to join(field_separator)
.
abbrev: Returns a hash of unambiguous abbreviations for elements.
pack
: Packs the elements into a binary sequence.
sum
: Returns a sum of elements according to either +
or a given block.
Raised by exit
to initiate the termination of the script.
The most standard error types are subclasses of StandardError
. A rescue clause without an explicit Exception
class will rescue all StandardErrors (and only those).
def foo raise "Oups" end foo rescue "Hello" #=> "Hello"
On the other hand:
require 'does/not/exist' rescue "Hi"
raises the exception:
LoadError: no such file to load -- does/not/exist
Raised when the arguments are wrong and there isn’t a more specific Exception
class.
Ex: passing the wrong number of arguments
[1, 2, 3].first(4, 5)
raises the exception:
ArgumentError: wrong number of arguments (given 2, expected 1)
Ex: passing an argument that is not acceptable:
[1, 2, 3].first(-4)
raises the exception:
ArgumentError: negative array size