Return the receiver associated with this KeyError exception.
Return the receiver associated with this NameError exception.
Return the receiver associated with this FrozenError exception.
Returns a list of modules included/prepended in mod (including mod itself).
module Mod include Math include Comparable prepend Enumerable end Mod.ancestors #=> [Enumerable, Mod, Comparable, Math] Math.ancestors #=> [Math] Enumerable.ancestors #=> [Enumerable]
Limit the number of significant digits in newly created BigDecimal numbers to the specified value. Rounding is performed as necessary, as specified by BigDecimal.mode.
A limit of 0, the default, means no upper limit.
The limit specified by this method takes less priority over any limit specified to instance methods such as ceil, floor, truncate, or round.
Splits a BigDecimal number into four parts, returned as an array of values.
The first value represents the sign of the BigDecimal, and is -1 or 1, or 0 if the BigDecimal is Not a Number.
The second value is a string representing the significant digits of the BigDecimal, with no leading zeros.
The third value is the base used for arithmetic (currently always 10) as an Integer.
The fourth value is an Integer exponent.
If the BigDecimal can be represented as 0.xxxxxx*10**n, then xxxxxx is the string of significant digits with no leading zeros, and n is the exponent.
From these values, you can translate a BigDecimal to a float as follows:
sign, significant_digits, base, exponent = a.split f = sign * "0.#{significant_digits}".to_f * (base ** exponent)
(Note that the to_f method is provided as a more convenient way to translate a BigDecimal to a Float.)
Return the smallest integer greater than or equal to the value, as a BigDecimal.
BigDecimal('3.14159').ceil #=> 4 BigDecimal('-9.1').ceil #=> -9
If n is specified and positive, the fractional part of the result has no more than that many digits.
If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result.
BigDecimal('3.14159').ceil(3) #=> 3.142 BigDecimal('13345.234').ceil(-2) #=> 13400.0
The coerce method provides support for Ruby type coercion. It is not enabled by default.
This means that binary operations like + * / or - can often be performed on a BigDecimal and an object of another type, if the other object can be coerced into a BigDecimal value.
e.g.
a = BigDecimal("1.0") b = a / 2.0 #=> 0.5
Note that coercing a String to a BigDecimal is not supported by default; it requires a special compile-time option when building Ruby.
Returns the smallest number greater than or equal to rat with a precision of ndigits decimal digits (default: 0).
When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.
Returns a rational when ndigits is positive, otherwise returns an integer.
Rational(3).ceil #=> 3 Rational(2, 3).ceil #=> 1 Rational(-3, 2).ceil #=> -1 # decimal - 1 2 3 . 4 5 6 # ^ ^ ^ ^ ^ ^ # precision -3 -2 -1 0 +1 +2 Rational('-123.456').ceil(+1).to_f #=> -123.4 Rational('-123.456').ceil(-1) #=> -120
Returns a simpler approximation of the value if the optional argument eps is given (rat-|eps| <= result <= rat+|eps|), self otherwise.
r = Rational(5033165, 16777216) r.rationalize #=> (5033165/16777216) r.rationalize(Rational('0.01')) #=> (3/10) r.rationalize(Rational('0.1')) #=> (1/3)
Returns true if the date is before the date of calendar reform, false otherwise:
(Date.new(1582, 10, 15) - 1).julian? # => true Date.new(1582, 10, 15).julian? # => false
Equivalent to Date#new_start with argument Date::JULIAN.
Returns a new Time object whose numerical value is greater than or equal to self with its seconds truncated to precision ndigits:
t = Time.utc(2010, 3, 30, 5, 43, 25.123456789r) t # => 2010-03-30 05:43:25.123456789 UTC t.ceil # => 2010-03-30 05:43:26 UTC t.ceil(2) # => 2010-03-30 05:43:25.13 UTC t.ceil(4) # => 2010-03-30 05:43:25.1235 UTC t.ceil(6) # => 2010-03-30 05:43:25.123457 UTC t.ceil(8) # => 2010-03-30 05:43:25.12345679 UTC t.ceil(10) # => 2010-03-30 05:43:25.123456789 UTC t = Time.utc(1999, 12, 31, 23, 59, 59) t # => 1999-12-31 23:59:59 UTC (t + 0.4).ceil # => 2000-01-01 00:00:00 UTC (t + 0.9).ceil # => 2000-01-01 00:00:00 UTC (t + 1.4).ceil # => 2000-01-01 00:00:01 UTC (t + 1.9).ceil # => 2000-01-01 00:00:01 UTC
Related: Time#floor, Time#round.
Returns an array of all lines read from the stream.
When called from class IO (but not subclasses of IO), this method has potential security vulnerabilities if called with untrusted input; see Command Injection.
The first argument must be a string; its meaning depends on whether it starts with the pipe character ('|'):
If so (and if self is IO), the rest of the string is a command to be executed as a subprocess.
Otherwise, the string is the path to a file.
With only argument command given, executes the command in a shell, parses its $stdout into lines, as determined by the default line separator, and returns those lines in an array:
IO.readlines('| cat t.txt') # => ["First line\n", "Second line\n", "\n", "Third line\n", "Fourth line\n"]
With only argument path given, parses lines from the file at the given path, as determined by the default line separator, and returns those lines in an array:
IO.readlines('t.txt') # => ["First line\n", "Second line\n", "\n", "Third line\n", "Fourth line\n"]
For both forms, command and path, the remaining arguments are the same.
With argument sep given, parses lines as determined by that line separator (see Line Separator):
# Ordinary separator. IO.readlines('t.txt', 'li') # =>["First li", "ne\nSecond li", "ne\n\nThird li", "ne\nFourth li", "ne\n"] # Get-paragraphs separator. IO.readlines('t.txt', '') # => ["First line\nSecond line\n\n", "Third line\nFourth line\n"] # Get-all separator. IO.readlines('t.txt', nil) # => ["First line\nSecond line\n\nThird line\nFourth line\n"]
With argument limit given, parses lines as determined by the default line separator and the given line-length limit (see Line Limit):
IO.readlines('t.txt', 7) # => ["First l", "ine\n", "Second ", "line\n", "\n", "Third l", "ine\n", "Fourth ", "line\n"]
With arguments sep and limit given, parses lines as determined by the given line separator and the given line-length limit (see Line Separator and Line Limit):
Optional keyword arguments opts specify:
Encoding options.
Returns the current line number for the stream; see Line Number.
Sets and returns the line number for the stream; see Line Number.
Reads and returns all remaining line from the stream; does not modify $_. See Line IO.
With no arguments given, returns lines as determined by line separator $/, or nil if none:
f = File.new('t.txt') f.readlines # => ["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"] f.readlines # => [] f.close
With only string argument sep given, returns lines as determined by line separator sep, or nil if none; see Line Separator:
f = File.new('t.txt') f.readlines('li') # => ["First li", "ne\nSecond li", "ne\n\nFourth li", "ne\nFifth li", "ne\n"] f.close
The two special values for sep are honored:
f = File.new('t.txt') # Get all into one string. f.readlines(nil) # => ["First line\nSecond line\n\nFourth line\nFifth line\n"] # Get paragraphs (up to two line separators). f.rewind f.readlines('') # => ["First line\nSecond line\n\n", "Fourth line\nFifth line\n"] f.close
With only integer argument limit given, limits the number of bytes in each line; see Line Limit:
f = File.new('t.txt') f.readlines(8) # => ["First li", "ne\n", "Second l", "ine\n", "\n", "Fourth l", "ine\n", "Fifth li", "ne\n"] f.close
With arguments sep and limit given, combines the two behaviors:
Returns lines as determined by line separator sep.
But returns no more bytes in a line than are allowed by the limit.
Optional keyword argument chomp specifies whether line separators are to be omitted:
f = File.new('t.txt') f.readlines(chomp: true) # => ["First line", "Second line", "", "Fourth line", "Fifth line"] f.close
Reads a line as with IO#gets, but raises EOFError if already at end-of-stream.
Optional keyword argument chomp specifies whether line separators are to be omitted.
Returns the original string of self:
/ab+c/ix.source # => "ab+c"
Regexp escape sequences are retained:
/\x20\+/.source # => "\\x20\\+"
Lexer escape characters are not retained:
/\//.source # => "/"
Replaces the contents of the set with the contents of the given enumerable object and returns self.
set = Set[1, 'c', :s] #=> #<Set: {1, "c", :s}> set.replace([1, 2]) #=> #<Set: {1, 2}> set #=> #<Set: {1, 2}>
Iterates over and yields a new Pathname object for each element in the given path in descending order.
Pathname.new('/path/to/some/file.rb').descend {|v| p v} #<Pathname:/> #<Pathname:/path> #<Pathname:/path/to> #<Pathname:/path/to/some> #<Pathname:/path/to/some/file.rb> Pathname.new('path/to/some/file.rb').descend {|v| p v} #<Pathname:path> #<Pathname:path/to> #<Pathname:path/to/some> #<Pathname:path/to/some/file.rb>
Returns an Enumerator if no block was given.
enum = Pathname.new("/usr/bin/ruby").descend
# ... do stuff ...
enum.each { |e| ... }
# yields Pathnames /, /usr, /usr/bin, and /usr/bin/ruby.
It doesn’t access the filesystem.
Iterates over and yields a new Pathname object for each element in the given path in ascending order.
Pathname.new('/path/to/some/file.rb').ascend {|v| p v} #<Pathname:/path/to/some/file.rb> #<Pathname:/path/to/some> #<Pathname:/path/to> #<Pathname:/path> #<Pathname:/> Pathname.new('path/to/some/file.rb').ascend {|v| p v} #<Pathname:path/to/some/file.rb> #<Pathname:path/to/some> #<Pathname:path/to> #<Pathname:path>
Returns an Enumerator if no block was given.
enum = Pathname.new("/usr/bin/ruby").ascend
# ... do stuff ...
enum.each { |e| ... }
# yields Pathnames /usr/bin/ruby, /usr/bin, /usr, and /.
It doesn’t access the filesystem.