Ruby

https://www.ruby-lang.org/en/documentation
Admin
Ruby is a dynamic, open-source programming language with a focus on simplicity and productivity,...
Tokens:28,116
Snippets:434
Trust Score:9.5
Update:4 months ago
Show doc for...
Tokens:
Raw
### Build Ruby from Source

Source: https://www.ruby-lang.org/en/documentation/installation

Standard commands to configure, make, and install Ruby from source.

```bash
$ ./configure
$ make
$ sudo make install
```

--------------------------------

### Install Ruby on Windows using Windows Package Manager

Source: https://www.ruby-lang.org/en/documentation/installation

Installs Ruby on Windows using the Windows Package Manager CLI. Includes examples for specific versions and searching available versions. Also notes the option to install Ruby with DevKit.

```powershell
> winget install RubyInstallerTeam.Ruby.{MAJOR}.{MINOR}
> winget install RubyInstallerTeam.Ruby.3.2
> winget search RubyInstallerTeam.Ruby
> winget install RubyInstallerTeam.RubyWithDevKit.3.2
```

--------------------------------

### Install Ruby with snap

Source: https://www.ruby-lang.org/en/documentation/installation

Command to install Ruby using snap on Ubuntu or other Linux distributions.

```bash
$ sudo snap install ruby --classic
```

--------------------------------

### Install Ruby with portage (Gentoo)

Source: https://www.ruby-lang.org/en/documentation/installation

Command to install Ruby using portage on Gentoo.

```bash
$ sudo emerge dev-lang/ruby
```

--------------------------------

### Install Ruby with apt (Debian/Ubuntu)

Source: https://www.ruby-lang.org/en/documentation/installation

Command to install the ruby-full package using apt on Debian or Ubuntu.

```bash
$ sudo apt-get install ruby-full
```

--------------------------------

### Install Ruby with pkg_add (OpenBSD)

Source: https://www.ruby-lang.org/en/documentation/installation

Command to install Ruby using pkg_add on OpenBSD.

```bash
$ doas pkg_add ruby
```

--------------------------------

### Install Ruby on OpenIndiana

Source: https://www.ruby-lang.org/en/documentation/installation

Installs Ruby binaries and RubyGems from OpenIndiana repositories using the Image Packaging System (IPS) client.

```bash
$ pkg install runtime/ruby
```

--------------------------------

### Getting a list of configure options

Source: https://www.ruby-lang.org/en/documentation/faq/3

Command to display all available configure options for building Ruby.

```bash
$ ./configure --help

```

--------------------------------

### Switch to Ruby 2.3 with snap

Source: https://www.ruby-lang.org/en/documentation/installation

Commands to switch to a specific Ruby minor series (e.g., 2.3) using snap.

```bash
$ sudo snap switch ruby --channel=2.3/stable
$ sudo snap refresh
```

--------------------------------

### Install Ruby with Homebrew (macOS)

Source: https://www.ruby-lang.org/en/documentation/installation

Command to install Ruby using Homebrew on macOS.

```bash
$ brew install ruby
```

--------------------------------

### Install Ruby with pkg (FreeBSD)

Source: https://www.ruby-lang.org/en/documentation/installation

Command to install Ruby using the pkg tool on FreeBSD.

```bash
$ pkg install ruby
```

--------------------------------

### MegaGreeter Class Example

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

An example demonstrating the MegaGreeter class with methods for saying hi and bye, handling different types of input for names.

```ruby
#!/usr/bin/env ruby

class MegaGreeter
  attr_accessor :names

  # Create the object
  def initialize(names = "World")
    @names = names
  end

  # Say hi to everybody
  def say_hi
    if @names.nil?
      puts "..."
    elsif @names.respond_to?("each")
      # @names is a list of some kind, iterate!
      @names.each do |name|
        puts "Hello #{name}!"
      end
    else
      puts "Hello #{@names}!"
    end
  end

  # Say bye to everybody
  def say_bye
    if @names.nil?
      puts "..."
    elsif @names.respond_to?("join")
      # Join the list elements with commas
      puts "Goodbye #{@names.join(", ")}.  Come back soon!"
    else
      puts "Goodbye #{@names}.  Come back soon!"
    end
  end
end


if __FILE__ == $0
  mg = MegaGreeter.new
  mg.say_hi
  mg.say_bye

  # Change name to be "Zeke"
  mg.names = "Zeke"
  mg.say_hi
  mg.say_bye

  # Change the name to an array of names
  mg.names = ["Albert", "Brenda", "Charles",
              "Dave", "Engelbert"]
  mg.say_hi
  mg.say_bye

  # Change to nil
  mg.names = nil
  mg.say_hi
  mg.say_bye
end

```

--------------------------------

### Install Ruby with pacman (Arch Linux)

Source: https://www.ruby-lang.org/en/documentation/installation

Command to install Ruby using pacman on Arch Linux.

```bash
$ sudo pacman -S ruby
```

--------------------------------

### Install Ruby with yum (CentOS/Fedora/RHEL)

Source: https://www.ruby-lang.org/en/documentation/installation

Command to install Ruby using yum on CentOS, Fedora, or RHEL.

```bash
$ sudo yum install ruby
```

--------------------------------

### Protected Method Example

Source: https://www.ruby-lang.org/en/documentation/faq/7

Shows an example of a protected method used for comparison.

```ruby
def <=>(other)
  age <=> other.age
end

```

--------------------------------

### Install Ruby on Windows using Chocolatey

Source: https://www.ruby-lang.org/en/documentation/installation

Installs Ruby on Windows using the Chocolatey Package Manager. It may reuse existing msys2 or install its own for a complete development environment.

```powershell
> choco install ruby
```

--------------------------------

### C-style for loop

Source: https://www.ruby-lang.org/en/documentation/quickstart/4

An example of a traditional C-style for loop for comparison with Ruby's iteration.

```c
for (i=0; i<number_of_elements; i++)
{
  do_something_with(element[i]);
}
```

--------------------------------

### Compiling Ruby under Unix

Source: https://www.ruby-lang.org/en/documentation/faq/3

Steps to configure, build, test, and install Ruby from a distribution using the autoconf system.

```bash
$ ./configure [configure options]
$ make
$ make test
$ make install

```

--------------------------------

### Configuring Ruby with library paths

Source: https://www.ruby-lang.org/en/documentation/faq/3

Example of using the --with-xxx-yyy=DIR option to specify library paths during Ruby configuration.

```bash
$ ./configure --with-xxx-yyy=DIR

```

--------------------------------

### Implementing Post-Test Loops with `begin...end until`

Source: https://www.ruby-lang.org/en/documentation/faq/6

Provides an example of how to simulate a post-test loop using Ruby's `begin...end` construct with statement modifiers.

```ruby
i = 0
begin
  puts "i = #{i}"
  i += 1
end until i > 4
```

--------------------------------

### Module function example 1

Source: https://www.ruby-lang.org/en/documentation/faq/8

Demonstrates calling a module function using the Module.method notation.

```ruby
Math.sqrt(2)  # => 1.414213562
```

--------------------------------

### Using accessor methods to get and set the name

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

Shows how to create a new Greeter object and use the newly defined `name` and `name=` methods to access and modify the instance variable.

```Ruby
irb(main):047:0> greeter = Greeter.new("Andy")
=> #<Greeter:0x3c9b0 @name="Andy">
irb(main):048:0> greeter.respond_to?("name")
=> true
irb(main):049:0> greeter.respond_to?("name=")
=> true
irb(main):050:0> greeter.say_hi
Hi Andy!
=> nil
irb(main):051:0> greeter.name="Betty"
=> "Betty"
irb(main):052:0> greeter
=> #<Greeter:0x3c9b0 @name="Betty">
irb(main):053:0> greeter.name
=> "Betty"
irb(main):054:0> greeter.say_hi
Hi Betty!
=> nil
```

--------------------------------

### Keyword arguments in Ruby

Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages

Example of defining and calling a method with keyword arguments, similar to Python.

```Ruby
def deliver(from: "A", to: nil, via: "mail")
  "Sending from #{from} to #{to} via #{via}."
end

deliver(to: "B")
# => "Sending from A to B via mail."
deliver(via: "Pony Express", from: "B", to: "A")
# => "Sending from B to A via Pony Express."
```

--------------------------------

### Simple Producer/Consumer with Continuations

Source: https://www.ruby-lang.org/en/documentation/faq/11

An example demonstrating the use of continuations in Ruby to implement a simple producer/consumer pattern. This allows for complex control structures by representing and returning to specific points in a program.

```ruby
# --------------------------------------------------------------------
# Simple Producer/Consumer
# --------------------------------------------------------------------
# Connect a simple counting task and a printing task together using
# continuations.
#
# Usage:  count(limit)

def count_task(count, consumer)
  (1..count).each do |i|
    callcc {|cc| consumer.call cc, i }
  end
  nil
end

def print_task()
  producer, i = callcc { |cc| return cc }
  print "#{i} "
  callcc { |cc| producer.call }
end

def count(limit)
  count_task(limit, print_task())
  print "\n"
end
```

--------------------------------

### Control flow with 'or'

Source: https://www.ruby-lang.org/en/documentation/faq/6

Example of using the 'or' keyword for control flow in Ruby.

```ruby
do_something  or raise "some error!"
```

--------------------------------

### Module function example 2

Source: https://www.ruby-lang.org/en/documentation/faq/8

Demonstrates calling a module function after including the module, making it available without the prefix.

```ruby
include Math
sqrt(2)  # => 1.414213562
```

--------------------------------

### Everything has a value example

Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages

Demonstrates that all expressions in Ruby have a value, including conditional statements.

```Ruby
x = 10
y = 11
z = if x < y
      true
    else
      false
    end
z # => true
```

--------------------------------

### Array iteration with `each` and `{...}` block

Source: https://www.ruby-lang.org/en/documentation/faq/5

Shows the equivalent of the previous example using curly braces `{...}` for the block.

```ruby
data = [1, 2, 3]
data.each { |i|
  puts i
}

```

--------------------------------

### Annotating Ruby code with results

Source: https://www.ruby-lang.org/en/documentation/faq/1

Example of annotating Ruby code with the results of executing each statement as a comment.

```ruby
str = "Billy" + " Bob"           # => "Billy Bob"
str[0,1] + str[2,1] + str[-2,2]  # => "Blob"
```

--------------------------------

### Filtering Out Multiples with Continuations

Source: https://www.ruby-lang.org/en/documentation/faq/11

This example extends the continuation-based producer/consumer pattern to filter out multiples of a given number. It shows how to insert a filter task between a producer and a consumer.

```ruby
# --------------------------------------------------------------------
# Filtering Out Multiples of a Given Number
# --------------------------------------------------------------------
# Create a filter that is both a consumer and producer. Insert it
# between the counting task and the printing task.
#
# Usage:  omit(2, limit)

def filter_task(factor, consumer)
  producer, i = callcc { |cc| return cc }
  if (i%factor) != 0 then
    callcc { |cc| consumer.call cc, i }
  end
  producer.call
end

def omit(factor, limit)
  printer = print_task()
  filter = filter_task(factor, printer)
  count_task(limit, filter)
  print "\n"
end
```

--------------------------------

### Iteration with blocks

Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages

Example of using Ruby's 'each' iterator with a block to process items in a list.

```Ruby
some_list.each do |this_item|
  # We're inside the block.
  # deal with this_item.
end
```

--------------------------------

### IRB as a Calculator

Source: https://www.ruby-lang.org/en/documentation/quickstart

Examples of using IRB for basic arithmetic operations like addition, multiplication, and exponentiation.

```ruby
irb(main):003:0> 3+2
=> 5
```

```ruby
irb(main):004:0> 3*2
=> 6
```

```ruby
irb(main):005:0> 3**2
=> 9
```

--------------------------------

### Class Instance Variables Example

Source: https://www.ruby-lang.org/en/documentation/faq/8

Illustrates the use of class instance variables (@) in Ruby, showing how they are managed at the class level and accessed via class methods.

```ruby
class Entity

  @instances = 0

  class << self
    attr_accessor :instances  # provide class methods for reading/writing
  end

  def initialize
    self.class.instances += 1
    @number = self.class.instances
  end

  def who_am_i
   "I'm #{@number} of #{self.class.instances}"
  end

  def self.total
    @instances
  end
end

entities = Array.new(9) { Entity.new }

entities[6].who_am_i  # => "I'm 7 of 9"
Entity.instances      # => 9
Entity.total          # => 9

```

--------------------------------

### Class Variables Example

Source: https://www.ruby-lang.org/en/documentation/faq/8

Demonstrates the usage of class variables (@@) in Ruby, including initialization, incrementing, and accessing them through instance and class methods.

```ruby
class Entity

  @@instances = 0

  def initialize
    @@instances += 1
    @number = @@instances
  end

  def who_am_i
   "I'm #{@number} of #{@@instances}"
  end

  def self.total
    @@instances
  end
end

entities = Array.new(9) { Entity.new }

entities[6].who_am_i  # => "I'm 7 of 9"
Entity.total          # => 9

```

--------------------------------

### Operator Overloading Example

Source: https://www.ruby-lang.org/en/documentation/faq/7

Illustrates how operators like `+` and `-` are actually method calls and can be overloaded. It also shows how to define methods for unary `+` and `-` using `+@` and `-@`.

```ruby
class MyString < String
  def -(other)
    self[0...other.size]  # self truncated to other's size
  end
end

```

```ruby
class Test
  def attribute=(val)
    @attribute = val
  end
end

t = Test.new
t.attribute = 1

```

--------------------------------

### Running iterators in parallel using threads

Source: https://www.ruby-lang.org/en/documentation/faq/5

An example demonstrating how to run multiple iterators concurrently using Ruby's `Thread` and `SizedQueue`.

```ruby
require "thread"

def combine(*iterators)
  queues = []
  threads = []

  iterators.each do |it|
    queue = SizedQueue.new(1)
    th = Thread.new(it, queue) do |i, q|
           send(i) {|x| q << x }
         end
    queues  << queue
    threads << th
  end

  loop do
    ary = []
    queues.each {|q| ary << q.pop }
    yield ary

    iterators.size.times do |i|
      return if !threads[i].status && queues[i].empty?
    end
  end
end

def it1
  yield 1; yield 2; yield 3
end

def it2
  yield 4; yield 5; yield 6
end

combine(:it1, :it2) do |x|
  # x is [1, 4], then [2, 5], then [3, 6]
end

```

--------------------------------

### Prime Number Generator with Continuations

Source: https://www.ruby-lang.org/en/documentation/faq/11

This example demonstrates how to create a prime number generator using continuations. It dynamically adds multiple filters to the chain as new prime numbers are discovered.

```ruby
# --------------------------------------------------------------------
# Prime Number Generator
# --------------------------------------------------------------------
# Create a prime number generator. When a new prime number is
# discovered, dynamically add a new multiple filter to the chain of
# producers and consumers.
#
# Usage:  primes(limit)

def prime_task(consumer)
  producer, i = callcc { |cc| return cc }
  if i >= 2 then
    callcc { |cc| consumer.call cc, i }
    consumer = filter_task(i, consumer)
  end
  producer.call
end

def primes(limit)
  printer = print_task()
  primes = prime_task(printer)
  count_task(limit, primes)
  print "\n"
end
```

--------------------------------

### Creating and using a Greeter object

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

Demonstrates instantiation of a Greeter object and calling its methods.

```Ruby
irb(main):035:0> greeter = Greeter.new("Pat")
=> #<Greeter:0x16cac @name="Pat">
irb(main):036:0> greeter.say_hi
Hi Pat!
=> nil
irb(main):037:0> greeter.say_bye
Bye Pat, come back soon.
=> nil
```

--------------------------------

### Printing Hello World

Source: https://www.ruby-lang.org/en/documentation/quickstart

Demonstrates how to print 'Hello World' using the 'puts' command in IRB and shows the return value.

```ruby
irb(main):001:0> "Hello World"
=> "Hello World"
```

```ruby
irb(main):002:0> puts "Hello World"
Hello World
=> nil
```

--------------------------------

### Listing all instance methods

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

Retrieves a list of all instance methods available for Greeter objects, including inherited ones.

```Ruby
irb(main):039:0> Greeter.instance_methods
=> [:say_hi, :say_bye, :instance_of?, :public_send,
    :instance_variable_get, :instance_variable_set,
    :instance_variable_defined?, :remove_instance_variable,
    :private_methods, :kind_of?, :instance_variables, :tap,
    :is_a?, :extend, :define_singleton_method, :to_enum,
    :enum_for, :<=>, :===, :=~, :!~, :eql?, :respond_to?,
    :freeze, :inspect, :display, :send, :object_id, :to_s,
    :method, :public_method, :singleton_method, :nil?, :hash,
    :class, :singleton_class, :clone, :dup, :itself, :taint,
    :tainted?, :untaint, :untrust, :trust, :untrusted?,
    :methods, :protected_methods, :frozen?, :public_methods,
    :singleton_methods, :!, :==, :!=, :__send__, :equal?,
    :instance_eval, :instance_exec, :__id__]
```

--------------------------------

### Using less to display program output

Source: https://www.ruby-lang.org/en/documentation/faq/9

Illustrates how to pipe program output to the `less` command, showing the incorrect and correct ways to ensure output is displayed.

```ruby
open("|less", "w").puts "abc"

```

```ruby
open("|less", "w") {|f| f.puts "abc" }

```

--------------------------------

### '*' operator in multiple assignment

Source: https://www.ruby-lang.org/en/documentation/faq/4

Examples of using the '*' operator for capturing remaining elements in multiple assignments.

```Ruby
x, *y = [7, 8, 9]
x                  # => 7
y                  # => [8, 9]
x,    = [7, 8, 9]
x                  # => 7
x     = [7, 8, 9]
x                  # => [7, 8, 9]
```

--------------------------------

### Calling a method

Source: https://www.ruby-lang.org/en/documentation/quickstart/2

Demonstrates calling the previously defined 'hi' method, both with and without parentheses.

```ruby
irb(main):013:0> hi
Hello World!
=> nil
irb(main):014:0> hi()
Hello World!
=> nil
```

--------------------------------

### Defining a class with methods

Source: https://www.ruby-lang.org/en/documentation/quickstart/2

Defines a 'Greeter' class with an initializer and methods to say hi and bye, using an instance variable.

```ruby
irb(main):024:0> class Greeter
irb(main):025:1>   def initialize(name = "World")
irb(main):026:2>     @name = name
irb(main):027:2>   end
irb(main):028:1>   def say_hi
irb(main):029:2>     puts "Hi #{@name}!"
irb(main):030:2>   end
irb(main):031:1>   def say_bye
irb(main):032:2>     puts "Bye #{@name}, come back soon."
irb(main):033:2>   end
irb(main):034:1> end
=> :say_bye
```

--------------------------------

### Defining a simple method

Source: https://www.ruby-lang.org/en/documentation/quickstart/2

This snippet shows how to define a method named 'hi' that prints 'Hello World!' to the console.

```ruby
irb(main):010:0> def hi
irb(main):011:1> puts "Hello World!"
irb(main):012:1> end
=> :hi
```

--------------------------------

### Destructive Method Example

Source: https://www.ruby-lang.org/en/documentation/faq/7

Demonstrates how a destructive method modifies the object in place, affecting all variables referencing it.

```ruby
def foo(str)
  str.sub!(/foo/, "baz")
end

obj = "foo"
foo(obj)     # => "baz"
obj          # => "baz"

```

--------------------------------

### Setter method syntax

Source: https://www.ruby-lang.org/en/documentation/faq/6

Demonstrates the correct way to define and call a setter method in Ruby.

```ruby
def pos=(val)
  @pos = val
  puts @pos
end
```

--------------------------------

### Local variable scope example

Source: https://www.ruby-lang.org/en/documentation/faq/4

Demonstrates how scope affects local variables within top-level, class, and method definitions.

```ruby
var = 1         # (1)
class Demo
  var = 2       # (2)
  def method
    var = 3     # (3)
    puts "in method: var = #{var}"
  end
  puts "in class: var = #{var}"
end
puts "at top level: var = #{var}"
Demo.new.method
```

--------------------------------

### Checking out the current source tree using CVS

Source: https://www.ruby-lang.org/en/documentation/faq/3

Instructions for checking out the Ruby source tree using a CVS client.

```bash
$ cvs -d :pserver:anonymous@cvs.netlab.co.jp:/home/cvs login
(Logging in to anonymous@cvs.netlab.co.jp)
CVS password: guest
$ cvs -d :pserver:anonymous@cvs.netlab.co.jp:/home/cvs co ruby

```

--------------------------------

### Exception handling structure

Source: https://www.ruby-lang.org/en/documentation/faq/6

Demonstrates the basic structure of exception handling in Ruby using begin, rescue, and ensure.

```ruby
begin
  statements which may raise exceptions
rescue [exception class names]
  statements when an exception occurred
rescue [exception class names]
  statements when an exception occurred
ensure
  statements that will always run
end
```

--------------------------------

### Method argument modification example

Source: https://www.ruby-lang.org/en/documentation/faq/4

Demonstrates how modifying a mutable object passed as an argument within a method affects the original object.

```Ruby
def add_one(number)
  number += 1
end

a = 1
add_one(a)  # => 2
a           # => 1
```

--------------------------------

### Singleton Method Creation

Source: https://www.ruby-lang.org/en/documentation/faq/7

Demonstrates the creation and usage of a singleton method, which is an instance method associated with a single specific object.

```ruby
class Foo; end

foo = Foo.new
bar = Foo.new

def foo.hello
  puts "Hello"
end

foo.hello
bar.hello

```

--------------------------------

### Animal class with Comparable mixin

Source: https://www.ruby-lang.org/en/documentation/faq/8

An example of a class that mixes in the Comparable module to provide comparison operators based on a custom attribute.

```ruby
class Animal
  include Comparable

  attr_reader :legs

  def initialize(name, legs)
    @name, @legs = name, legs
  end

  def <=>(other)
    legs <=> other.legs
  end

  def inspect
    @name
  end
end

c = Animal.new("cat", 4)
s = Animal.new("snake", 0)
p = Animal.new("parrot", 2)

c < s             # => false
s < c             # => true
p >= s            # => true
p.between?(s, c)  # => true
[p, s, c].sort    # => [snake, parrot, cat]
```

--------------------------------

### Reopening a class and adding accessor methods

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

Demonstrates reopening the Greeter class to add `attr_accessor` for the 'name' instance variable.

```Ruby
irb(main):044:0> class Greeter
irb(main):045:1>   attr_accessor :name
irb(main):046:1> end
=> [:name, :name=]
```

--------------------------------

### Method Invocation Order

Source: https://www.ruby-lang.org/en/documentation/faq/7

Demonstrates how Ruby searches for methods, including singleton methods, class methods, and module inclusions. It also shows how `prepend` can be used to override existing methods.

```ruby
module Emphasizable
  def emphasize
    "**#{self}**"
  end
end

class String
  include Emphasizable
end

String.ancestors
  # => [String, Emphasizable, Comparable, Object, Kernel, BasicObject]

"Wow!".emphasize  # => "**Wow!**"

```

```ruby
module PrettyCapitalize
  def capitalize
    "**#{super}**"
  end
end

class String
  prepend PrettyCapitalize
end

String.ancestors
  # => [PrettyCapitalize, String, Comparable, Object, Kernel, BasicObject]

"hello".capitalize  # => "**Hello**"

```

--------------------------------

### Accessing Symbol Value via `Object#method`

Source: https://www.ruby-lang.org/en/documentation/faq/6

Demonstrates using `Object#method` to get a `Method` object from a symbol and then calling it.

```ruby
m = demo.method(:hello)  # => #<Method: Demo#hello>
m.call                   # => "Hello, world"
```

--------------------------------

### Correct file copying after writing

Source: https://www.ruby-lang.org/en/documentation/faq/9

Demonstrates the correct way to copy a file by ensuring the file is closed after writing and before copying.

```ruby
require "fileutils"

File.open("file", "w") {|f| f.puts "This is a file." }
FileUtils.cp("file", "newfile")

```

--------------------------------

### Method with default parameter and string capitalization

Source: https://www.ruby-lang.org/en/documentation/quickstart/2

Shows a method with an optional parameter and uses .capitalize to format the output. Also demonstrates calling methods without parentheses.

```ruby
irb(main):019:0> def hi(name = "World")
irb(main):020:1> puts "Hello #{name.capitalize}!"
irb(main):021:1> end
=> :hi
irb(main):022:0> hi "chris"
Hello Chris!
=> nil
irb(main):023:0> hi
Hello World!
=> nil
```

--------------------------------

### Getting the current line number and file name

Source: https://www.ruby-lang.org/en/documentation/faq/9

Shows how to access the current line number and file name while processing input files using ARGF.

```ruby
while gets
  print $_
end

```

```ruby
ARGF.file.lineno

```

```ruby
ARGF.file.path

```

--------------------------------

### Marshal dump and load

Source: https://www.ruby-lang.org/en/documentation/faq/9

Shows how to use `Marshal.dump` to serialize an object into a file or string and `Marshal.load` to reconstitute it.

```ruby
Marshal.dump( obj [, io ] [, lev] )
```

```ruby
obj = Marshal.load(io)
# or
obj = Marshal.load(str)
```

--------------------------------

### Accessing Symbol Value via String Conversion

Source: https://www.ruby-lang.org/en/documentation/faq/6

Illustrates how to get the string representation of a symbol and use it to access a variable's content via `eval`.

```ruby
a = "This is the content of `a'"
b = eval("#{:a}")
a.object_id == b.object_id  # => true
```

--------------------------------

### HP-UX specific compilation with native compiler

Source: https://www.ruby-lang.org/en/documentation/faq/3

Recommended command for compiling Ruby on HP-UX using the native compiler and GNU sed.

```bash
$ CC="cc -Ae" CFLAGS=-O ./configure --prefix=/opt/gnu

```

--------------------------------

### Iterating over names

Source: https://www.ruby-lang.org/en/documentation/quickstart/4

Demonstrates how to iterate over a list using the `each` method in Ruby.

```ruby
@names.each do |name|
  puts "Hello #{name}!"
end
```

--------------------------------

### Sorting people by age by defining a comparison method

Source: https://www.ruby-lang.org/en/documentation/faq/1

This example demonstrates an alternative way to sort `Person` objects by adding a spaceship operator (`<=>`) method to the `Person` class, which allows `sort` to work directly on the array.

```Ruby
class Person
  def <=>(other)
    age <=> other.age
  end
end
people.sort  # => [Elmo (4), Zoe (7), Bert (8), Ernie (8), Cookie (11)]

```

--------------------------------

### Interactive Ruby Shell (irb)

Source: https://www.ruby-lang.org/en/documentation/faq/10

Instructions on how to set up and use the irb interactive shell.

```shell
ruby -r eval -e0

```

--------------------------------

### Checking object's response to methods

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

Verifies which methods a greeter object can respond to.

```Ruby
irb(main):041:0> greeter.respond_to?("name")
=> false
irb(main):042:0> greeter.respond_to?("say_hi")
=> true
irb(main):043:0> greeter.respond_to?("to_s")
=> true
```

--------------------------------

### Listing methods defined specifically for Greeter

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

Retrieves a list of instance methods defined directly within the Greeter class, excluding inherited methods.

```Ruby
irb(main):040:0> Greeter.instance_methods(false)
=> [:say_hi, :say_bye]
```

--------------------------------

### Processing a file and updating its contents using the -i option

Source: https://www.ruby-lang.org/en/documentation/faq/9

Illustrates how to use the command-line option -i to process and update a file in place, with an option to create a backup.

```shell
$ ruby -i -ne 'print "#$.: #$_"' example

```

```shell
$ ruby -i.bak -ne 'print "#$.: #$_"' example

```

--------------------------------

### Expected Output

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

The expected output when running the ri20min.rb script.

```text
Hello World!
Goodbye World.  Come back soon!
Hello Zeke!
Goodbye Zeke.  Come back soon!
Hello Albert!
Hello Brenda!
Hello Charles!
Hello Dave!
Hello Engelbert!
Goodbye Albert, Brenda, Charles, Dave, Engelbert.  Come
back soon!
...
...

```

--------------------------------

### Attempting direct instance variable access

Source: https://www.ruby-lang.org/en/documentation/quickstart/3

Shows that direct access to instance variables is not allowed.

```Ruby
irb(main):038:0> greeter.@name
SyntaxError: (irb):38: syntax error, unexpected tIVAR, expecting '('
```

--------------------------------

### Ruby Version Command

Source: https://www.ruby-lang.org/en/documentation/faq/1

When asking for help, include the output of the `ruby -v` command.

```bash
ruby -v
```

--------------------------------

### Symbol Hash Keys

Source: https://www.ruby-lang.org/en/documentation/faq/6

Demonstrates the use of symbols as hash keys, including the alternate syntax for hash literals.

```ruby
person_1 = { :name => "John", :age => 42 }
person_2 = { name: "Jane", age: 24 }        # alternate syntax
```

--------------------------------

### Updating a file with line numbers

Source: https://www.ruby-lang.org/en/documentation/faq/9

Shows the correct way to read a file, modify its lines by prepending line numbers, and write the changes back to the file.

```ruby
File.open("example", "r+") do |f|
  lines = f.readlines
  lines.each_with_index {|line, i| line[0,0] = "#{i+1}: " }
  f.rewind
  f.puts lines
end

```

--------------------------------

### Singleton Class Customization

Source: https://www.ruby-lang.org/en/documentation/faq/8

Demonstrates how to add custom methods and attributes to a specific object instance by defining a singleton class for it.

```ruby
class Foo
  def hello
    "hello"
  end
end

foo = Foo.new
foo.hello  # => "hello"

class << foo
  attr_accessor :name

  def hello
    "hello, I'm #{name}"
  end
end

foo.name = "Tom"
foo.hello         # => "hello, I'm Tom"
Foo.new.hello     # => "hello"

```

--------------------------------

### Difference between `sub` and `sub!`

Source: https://www.ruby-lang.org/en/documentation/faq/9

Illustrates the difference between the `sub` and `sub!` methods, highlighting that `sub` returns a new string while `sub!` modifies the receiver destructively.

```ruby
def foo(str)
  str.sub(/foo/, "baz")
end

obj = "foo"
foo(obj)  # => "baz"
obj       # => "foo"

def foo(str)
  str.sub!(/foo/, "baz")
end

foo(obj)  # => "baz"
obj       # => "baz"
```

--------------------------------

### Changing Method Visibility

Source: https://www.ruby-lang.org/en/documentation/faq/7

Demonstrates how to change method visibility using private.

```ruby
class Foo
  def test
    puts "hello"
  end
  private :test
end

foo = Foo.new
foo.test

```

--------------------------------

### Counting lines in a file

Source: https://www.ruby-lang.org/en/documentation/faq/11

This code snippet demonstrates a concise way to count the number of lines in a file using Ruby.

```ruby
File.readlines("example").size  # => 3
```

--------------------------------

### Defining a method with a parameter

Source: https://www.ruby-lang.org/en/documentation/quickstart/2

Redefines the 'hi' method to accept a 'name' parameter and prints a personalized greeting.

```ruby
irb(main):015:0> def hi(name)
irb(main):016:1> puts "Hello #{name}!"
irb(main):017:1> end
=> :hi
irb(main):018:0> hi("Matz")
Hello Matz!
=> nil
```

--------------------------------

### Vim configuration for Ruby code annotation

Source: https://www.ruby-lang.org/en/documentation/faq/1

Vim mapping to integrate Ruby's xmp utility for annotating code regions.

```vim
map <M-F10> :!ruby -r xmp -n -e 'xmp($_, "\%l\t\t\# \%r\n")'<CR>
```

--------------------------------

### Instance Variable Accessors

Source: https://www.ruby-lang.org/en/documentation/faq/7

Demonstrates how to use attr_reader and attr_accessor to control access to instance variables.

```ruby
class Person
  attr_reader   :name           # read only
  attr_accessor :wearing_a_hat  # read/write

  def initialize(name)
    @name = name
  end
end

p = Person.new("Dave")
p.name           # => "Dave"
p.wearing_a_hat  # => nil
p.wearing_a_hat = true
p.wearing_a_hat  # => true

```

--------------------------------

### Message passing in Ruby

Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages

Illustrates that method calls in Ruby are essentially message passing, showing equivalent syntax.

```ruby
# This
1 + 2
# Is the same as this ...
1.+(2)
# Which is the same as this:
1.send "+", 2
```

--------------------------------

### Populating an array of people from a file

Source: https://www.ruby-lang.org/en/documentation/faq/1

This code demonstrates how to read lines from a file named `ages`, parse each line using regular expressions to extract a name and age, create `Person` objects, and add them to an array called `people`.

```Ruby
people = Array.new

File.foreach("ages") do |line|
  people << Person.new($1, $2) if line =~ /(.*):\s+(\d+)/
end

people  # => [Bert (8), Cookie (11), Elmo (4), Ernie (8), Zoe (7)]

```
Tokens:
Raw