An Integer object represents an integer value.

You can create an Integer object explicitly with:

• An integer literal.

You can convert certain objects to Integers with:

• Method Integer.

An attempt to add a singleton method to an instance of this class causes an exception to be raised.

What’s Here

First, what’s elsewhere. Class Integer:

• Inherits from class Numeric and class Object.

• Includes module Comparable.

Here, class Integer provides methods for:

• Querying

• Comparing

• Converting

• Other

Querying

• allbits?: Returns whether all bits in self are set.

• anybits?: Returns whether any bits in self are set.

• nobits?: Returns whether no bits in self are set.

Comparing

• <: Returns whether self is less than the given value.

• <=: Returns whether self is less than or equal to the given value.

• <=>: Returns a number indicating whether self is less than, equal to, or greater than the given value.

• == (aliased as ===): Returns whether self is equal to the given

  value.

• >: Returns whether self is greater than the given value.

• >=: Returns whether self is greater than or equal to the given value.

Converting

• ::sqrt: Returns the integer square root of the given value.

• ::try_convert: Returns the given value converted to an Integer.

• % (aliased as modulo): Returns self modulo the given value.

• &: Returns the bitwise AND of self and the given value.

• *: Returns the product of self and the given value.

• **: Returns the value of self raised to the power of the given value.

• +: Returns the sum of self and the given value.

• -: Returns the difference of self and the given value.

• /: Returns the quotient of self and the given value.

• <<: Returns the value of self after a leftward bit-shift.

• >>: Returns the value of self after a rightward bit-shift.

• []: Returns a slice of bits from self.

• ^: Returns the bitwise EXCLUSIVE OR of self and the given value.

• ceil: Returns the smallest number greater than or equal to self.

• chr: Returns a 1-character string containing the character represented by the value of self.

• digits: Returns an array of integers representing the base-radix digits of self.

• div: Returns the integer result of dividing self by the given value.

• divmod: Returns a 2-element array containing the quotient and remainder results of dividing self by the given value.

• fdiv: Returns the Float result of dividing self by the given value.

• floor: Returns the greatest number smaller than or equal to self.

• pow: Returns the modular exponentiation of self.

• pred: Returns the integer predecessor of self.

• remainder: Returns the remainder after dividing self by the given value.

• round: Returns self rounded to the nearest value with the given precision.

• succ (aliased as next): Returns the integer successor of self.

• to_f: Returns self converted to a Float.

• to_s (aliased as inspect): Returns a string containing the place-value representation of self in the given radix.

• truncate: Returns self truncated to the given precision.

• |: Returns the bitwise OR of self and the given value.

Other

• downto: Calls the given block with each integer value from self down to the given value.

• times: Calls the given block self times with each integer in (0..self-1).

• upto: Calls the given block with each integer value from self up to the given value.

Raised when an invalid operation is attempted on a Fiber, in particular when attempting to call/resume a dead fiber, attempting to yield from the root fiber, or calling a fiber across threads.

fiber = Fiber.new{}
fiber.resume #=> nil
fiber.resume #=> FiberError: dead fiber called

Raised when a given numerical value is out of range.

[1, 2, 3].drop(1 << 100)

raises the exception:

RangeError: bignum too big to convert into `long'

Raised when a file required (a Ruby script, extension library, …) fails to load.

require 'this/file/does/not/exist'

raises the exception:

LoadError: no such file to load -- this/file/does/not/exist

EncodingError is the base class for encoding errors.

TCPServer represents a TCP/IP server socket.

A simple TCP server may look like:

require 'socket'

server = TCPServer.new 2000 # Server bind to port 2000
loop do
  client = server.accept    # Wait for a client to connect
  client.puts "Hello !"
  client.puts "Time is #{Time.now}"
  client.close
end

A more usable server (serving multiple clients):

require 'socket'

server = TCPServer.new 2000
loop do
  Thread.start(server.accept) do |client|
    client.puts "Hello !"
    client.puts "Time is #{Time.now}"
    client.close
  end
end

UNIXServer represents a UNIX domain stream server socket.

Raised when attempting to divide an integer by 0.

42 / 0   #=> ZeroDivisionError: divided by 0

Note that only division by an exact 0 will raise the exception:

42 /  0.0   #=> Float::INFINITY
42 / -0.0   #=> -Float::INFINITY
0  /  0.0   #=> NaN

Raised when attempting to convert special float values (in particular Infinity or NaN) to numerical classes which don’t support them.

Float::INFINITY.to_r   #=> FloatDomainError: Infinity

Raised when Ruby can’t yield as requested.

A typical scenario is attempting to yield when no block is given:

def call_block
  yield 42
end
call_block

raises the exception:

LocalJumpError: no block given (yield)

A more subtle example:

def get_me_a_return
  Proc.new { return 42 }
end
get_me_a_return.call

raises the exception:

LocalJumpError: unexpected return

Raised when given an invalid regexp expression.

Regexp.new("?")

raises the exception:

RegexpError: target of repeat operator is not specified: /?/

The exception class which will be raised when pushing into a closed Queue. See Thread::Queue#close and Thread::SizedQueue#close.

Coverage provides coverage measurement feature for Ruby. This feature is experimental, so these APIs may be changed in future.

Caveat: Currently, only process-global coverage measurement is supported. You cannot measure per-thread coverage.

Usage

1. require “coverage”

2. do Coverage.start

3. require or load Ruby source file

4. Coverage.result will return a hash that contains filename as key and coverage array as value. A coverage array gives, for each line, the number of line execution by the interpreter. A nil value means coverage is disabled for this line (lines like else and end).

Examples

[foo.rb]
s = 0
10.times do |x|
  s += x
end

if s == 45
  p :ok
else
  p :ng
end
[EOF]

require "coverage"
Coverage.start
require "foo.rb"
p Coverage.result  #=> {"foo.rb"=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}

Lines Coverage

If a coverage mode is not explicitly specified when starting coverage, lines coverage is what will run. It reports the number of line executions for each line.

require "coverage"
Coverage.start(lines: true)
require "foo.rb"
p Coverage.result #=> {"foo.rb"=>{:lines=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}}

The value of the lines coverage result is an array containing how many times each line was executed. Order in this array is important. For example, the first item in this array, at index 0, reports how many times line 1 of this file was executed while coverage was run (which, in this example, is one time).

A nil value means coverage is disabled for this line (lines like else and end).

Oneshot Lines Coverage

Oneshot lines coverage tracks and reports on the executed lines while coverage is running. It will not report how many times a line was executed, only that it was executed.

require "coverage"
Coverage.start(oneshot_lines: true)
require "foo.rb"
p Coverage.result #=> {"foo.rb"=>{:oneshot_lines=>[1, 2, 3, 6, 7]}}

The value of the oneshot lines coverage result is an array containing the line numbers that were executed.

Branches Coverage

Branches coverage reports how many times each branch within each conditional was executed.

require "coverage"
Coverage.start(branches: true)
require "foo.rb"
p Coverage.result #=> {"foo.rb"=>{:branches=>{[:if, 0, 6, 0, 10, 3]=>{[:then, 1, 7, 2, 7, 7]=>1, [:else, 2, 9, 2, 9, 7]=>0}}}}

Each entry within the branches hash is a conditional, the value of which is another hash where each entry is a branch in that conditional. The values are the number of times the method was executed, and the keys are identifying information about the branch.

The information that makes up each key identifying branches or conditionals is the following, from left to right:

1. A label for the type of branch or conditional.

2. A unique identifier.

3. The starting line number it appears on in the file.

4. The starting column number it appears on in the file.

5. The ending line number it appears on in the file.

6. The ending column number it appears on in the file.

Methods Coverage

Methods coverage reports how many times each method was executed.

[foo_method.rb]
class Greeter
  def greet
    "welcome!"
  end
end

def hello
  "Hi"
end

hello()
Greeter.new.greet()
[EOF]

require "coverage"
Coverage.start(methods: true)
require "foo_method.rb"
p Coverage.result #=> {"foo_method.rb"=>{:methods=>{[Object, :hello, 7, 0, 9, 3]=>1, [Greeter, :greet, 2, 2, 4, 5]=>1}}}

Each entry within the methods hash represents a method. The values in this hash are the number of times the method was executed, and the keys are identifying information about the method.

The information that makes up each key identifying a method is the following, from left to right:

1. The class.

2. The method name.

3. The starting line number the method appears on in the file.

4. The starting column number the method appears on in the file.

5. The ending line number the method appears on in the file.

6. The ending column number the method appears on in the file.

All Coverage Modes

You can also run all modes of coverage simultaneously with this shortcut. Note that running all coverage modes does not run both lines and oneshot lines. Those modes cannot be run simultaneously. Lines coverage is run in this case, because you can still use it to determine whether or not a line was executed.

require "coverage"
Coverage.start(:all)
require "foo.rb"
p Coverage.result #=> {"foo.rb"=>{:lines=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil], :branches=>{[:if, 0, 6, 0, 10, 3]=>{[:then, 1, 7, 2, 7, 7]=>1, [:else, 2, 9, 2, 9, 7]=>0}}, :methods=>{}}}

Response class for Internal Server Error responses (status code 500).

An unexpected condition was encountered and no more specific message is suitable.

References:

• Mozilla.

• RFC 9110.

• Wikipedia.

This exception is raised if a generator or unparser error occurs.

This class is used as a return value from ObjectSpace::reachable_objects_from.

When ObjectSpace::reachable_objects_from returns an object with references to an internal object, an instance of this class is returned.

You can use the type method to check the type of the internal object.

Raised when OLE query failed.