Ruby Notes

puts "Oregon".object_id       # (string)
puts "Oregon".object_id       # (different string!)
puts :state.object_id         # symbol
puts :state.object_id         # (yup, it's the same thing)
string = "Oregon"             # here's the string "Oregon"
puts string.to_sym            # make it a symbol
puts string.to_sym.object_id  # get its object id
puts string.object_id         # and its string object id

4621300
4621120
163048
163048

Oregon
455788
16883940

french_hashmap = { 'dog' => "chien", 'cat' => "chat", 'ant' => "fourmie" }
puts french_hashmap[ 'dog' ]

chien

french_hashmap = { :dog => "chien", :cat => "chat", :ant => "fourmie" }
puts french_hashmap[ :cat ]

chat

french_hashmap = { dog: "chien", cat: "chat", :ant: "fourmie" }
puts french_hashmap[ :ant ]

fourmie

args.rb:

first, second, third = ARGV

puts "The script is called: #{$0}"
puts "Your first variable is: #{first}"
puts "Your second variable is: #{second}"
puts "Your third variable is: #{third}"

$ ruby args.rb 1st 2nd 3rd
The script is called: args.rb
Your first variable is: 1st
Your second variable is: 2nd
Your third variable is: 3rd

methods-and-args.rb:

# this one is like your scripts with argv
def puts_two( *args )
  arg1, arg2 = args
  puts "arg1: #{arg1}, arg2: #{arg2}"
end

# ok, that *args is actually pointless, we can just do this
def puts_two_again( arg1, arg2 )
  puts "arg1: #{arg1}, arg2: #{arg2}"
end

# this just takes one argument
def puts_one( arg1 )
  puts "arg1: #{arg1}"
end

# this one takes no arguments
def puts_none()
  puts "I got nothin'."
end

puts_two( "Zed","Shaw" )
puts_two_again( "Zed","Shaw" )
puts_one( "First!" )
puts_none()

$ ruby methods-and-args.rb
arg1: Zed, arg2: Shaw
arg1: Zed, arg2: Shaw
arg1: First!
I got nothin'.

two-returns.rb:

def return_two_things
  return true, false
end

two_things = return_two_things
puts two_things[ 0 ]
puts two_things[ 1 ]

$ ruby methods-and-args.rb
true
false

people = 20
cats = 30
dogs = 15

if people < cats
  puts "Too many cats! The world is doomed!"
end

if people > cats
  puts "Not many cats! The world is saved!"
end

if people < dogs
  puts "The world is drooled on!"
end

if people > dogs
  puts "The world is dry!"
end

dogs += 5

if people >= dogs
  puts "People are greater than or equal to dogs."
end

if people <= dogs
  puts "People are less than or equal to dogs."
end

if people == dogs
  puts "People are dogs."
end

if( people == dogs )             # added parens just to see if it works.)
  puts "My parens work."
end

Too many cats! The world is doomed!
The world is dry!
People are greater than or equal to dogs.
People are less than or equal to dogs.
People are dogs.
My parens work.

people = 30
cars = 40
buses = 15

if cars > people
  puts "We should take the cars."
elsif cars < people
  puts "We should not take the cars."
else
  puts "We can't decide."
end

if buses > cars
  puts "That's too many buses."
elsif buses < cars
  puts "Maybe we could take the buses."
else
  puts "We still can't decide."
end

if people > buses
  puts "Alright, let's just take the buses."
else
  puts "Fine, let's stay home then."
end

We should take the cars.
Maybe we could take the buses.
Alright, let's just take the buses.

found = false
if found
  puts "Found!"
else
  puts "Not found!"
end

irb(main):001:0> if found
irb(main):002:1> puts "Found!"
irb(main):003:1> else
irb(main):004:1* puts "Not found!"
irb(main):005:1> end
Not found!
=> nil

found = false
if found ; puts "Found!"; else; puts "Not found!"; end

irb(main):006:0> if found ; puts "Found!" ; else ; puts "Not found!" ; end
Not found!
=> nil

the_count = [ 1, 2, 3, 4, 5 ]
fruits = [ 'apples', 'oranges', 'pears', 'apricots' ]
change = [ 1, 'pennies', 2, 'dimes', 3, 'quarters' ]

# this first kind of for-loop goes through an array
for number in the_count
  puts "This is count #{number}"
end

# same as above, but using a block instead
fruits.each do |fruit|
  puts "A fruit of type: #{fruit}"
end

# also we can go through mixed arrays too
for i in change
  puts "I got #{i}"
end

# we can also build arrays, first start with an empty one
elements = []

# then use a range object to do 0 to 5 counts
for i in ( 0..5 )
  puts "Adding #{i} to the list."
  # push is a function that arrays understand
  elements.push( i )
end

# now we can puts them out too
for i in elements
  puts "Element was: #{i}"
end

This is count 1
This is count 2
This is count 3
This is count 4
This is count 5
A fruit of type: apples
A fruit of type: oranges
A fruit of type: pears
A fruit of type: apricots
I got 1
I got pennies
I got 2
I got dimes
I got 3
I got quarters
Adding 0 to the list.
Adding 1 to the list.
Adding 2 to the list.
Adding 3 to the list.
Adding 4 to the list.
Adding 5 to the list.
Element was: 0
Element was: 1
Element was: 2
Element was: 3
Element was: 4
Element was: 5

i = 0
numbers = []

while i < 6
  puts "At the top i is #{i}"
  numbers.push( i )

  i = i + 1
  puts "Numbers now: #{numbers}"
  puts "At the bottom i is #{i}"
end

puts "The numbers: "

for num in numbers
  puts num
end

At the top i is 0
Numbers now: [0]
At the bottom i is 1
At the top i is 1
Numbers now: [0, 1]
At the bottom i is 2
At the top i is 2
Numbers now: [0, 1, 2]
At the bottom i is 3
At the top i is 3
Numbers now: [0, 1, 2, 3]
At the bottom i is 4
At the top i is 4
Numbers now: [0, 1, 2, 3, 4]
At the bottom i is 5
At the top i is 5
Numbers now: [0, 1, 2, 3, 4, 5]
At the bottom i is 6
The numbers:
0
1
2
3
4
5

# create a mapping of state to abbreviation
states =
{
    'Oregon'     => 'OR',
    'Florida'    => 'FL',
    'California' => 'CA',
    'New York'   => 'NY',
    'Michigan'   => 'MI'
}

# create a basic set of states and some cities in them
cities =
{
    'CA' => 'San Francisco',
    'MI' => 'Detroit',
    'FL' => 'Jacksonville'
}

# add some more cities
cities['NY'] = 'New York'
cities['OR'] = 'Portland'

# puts out some cities
puts '-' * 10
puts "NY State has: ", cities[ 'NY' ]
puts "OR State has: ", cities[ 'OR' ]

# puts some states
puts '-' * 10
puts "Michigan's abbreviation is: ", states[ 'Michigan' ]
puts "Florida's abbreviation is: ", states[ 'Florida' ]

# do it by using the state then cities dictionary
puts '-' * 10
puts "Michigan has: ", cities[ states[ 'Michigan' ] ]
puts "Florida has: ", cities[ states[ 'Florida' ] ]

# puts every state abbreviation
puts '-' * 10
for state, abbrev in states
    puts "%s is abbreviated %s" % [ state, abbrev ]
end

# puts every city in state
puts '-' * 10
for abbrev, city in cities
    puts "%s has the city %s" % [ abbrev, city ]
end

# now do both at the same time
puts '-' * 10
for state, abbrev in states
    puts "%s state is abbreviated %s and has city %s" % [
        state, abbrev, cities[ abbrev ] ]
end

puts '-' * 10
# if it's not there you get nil
state = states[ 'Texas' ]

if not state
    puts "Sorry, no Texas."
end

# get a city with a default value
city = cities[ 'TX' ] || 'Does Not Exist'
puts "The city for the state 'TX' is: %s" % city

----------
NY State has:
New York
OR State has:
Portland
----------
Michigan's abbreviation is:
MI
Florida's abbreviation is:
FL
----------
Michigan has:
Detroit
Florida has:
Jacksonville
----------
Oregon is abbreviated OR
Florida is abbreviated FL
California is abbreviated CA
New York is abbreviated NY
Michigan is abbreviated MI
----------
CA has the city San Francisco
MI has the city Detroit
FL has the city Jacksonville
NY has the city New York
OR has the city Portland
----------
Oregon state is abbreviated OR and has city Portland
Florida state is abbreviated FL and has city Jacksonville
California state is abbreviated CA and has city San Francisco
New York state is abbreviated NY and has city New York
Michigan state is abbreviated MI and has city Detroit
----------
Sorry, no Texas.
The city for the state 'TX' is: Does Not Exist

class Song
    def initialize( lyrics )
        @lyrics = lyrics
    end

    def sing_me_a_song()
        for line in @lyrics
            puts line
        end
    end
end

happy_bday = Song.new( [ "Happy birthday to you",
                   "I don't want to get sued",
                   "So I'll stop right there" ] )

bulls_on_parade = Song.new( [ "They rally around the family",
                        "With pockets full of shells" ] )

happy_bday.sing_me_a_song()

bulls_on_parade.sing_me_a_song()

Happy birthday to you
I don't want to get sued
So I'll stop right there
They rally around the family
With pockets full of shells

class Parent
    def implicit()
        puts "PARENT implicit()"
    end
end

class Child < Parent
end

dad = Parent.new()
son = Child.new()

dad.implicit()
son.implicit()

PARENT implicit()
PARENT implicit()

class Parent
    def override()
        puts "PARENT override()"
    end
end

class Child < Parent
    def override()
        puts "CHILD override()"
    end
end

dad = Parent.new()
son = Child.new()

dad.override()
son.override()

PARENT override()
CHILD override()

class Parent
    def altered()
        puts "PARENT altered()"
    end
end

class Child < Parent
    def altered()
        puts "CHILD, BEFORE PARENT altered()"
        super()
        puts "CHILD, AFTER PARENT altered()"
    end

end

dad = Parent.new()
son = Child.new()

dad.altered()
son.altered()

PARENT altered()
CHILD, BEFORE PARENT altered()
PARENT altered()
CHILD, AFTER PARENT altered()

class Parent
    def override()
        puts "PARENT override()"
    end

    def implicit()
        puts "PARENT implicit()"
    end

    def altered()
        puts "PARENT altered()"
    end
end

class Child < Parent
    def override()
        puts "CHILD override()"
    end

    def altered()
        puts "CHILD, BEFORE PARENT altered()"
        super()
        puts "CHILD, AFTER PARENT altered()"
    end
end

dad = Parent.new()
son = Child.new()

dad.implicit()
son.implicit()

dad.override()
son.override()

dad.altered()
son.altered()

PARENT implicit()
PARENT implicit()
PARENT override()
CHILD override()
PARENT altered()
CHILD, BEFORE PARENT altered()
PARENT altered()
CHILD, AFTER PARENT altered()

class Other
    def override()
        puts "OTHER override()"
    end

    def implicit()
        puts "OTHER implicit()"
    end

    def altered()
        puts "OTHER altered()"
    end
end

class Child
    def initialize()
        @other = Other.new()
    end

    def implicit()
        @other.implicit()
    end

    def override()
        puts "CHILD override()"
    end

    def altered()
        puts "CHILD, BEFORE OTHER altered()"
        @other.altered()
        puts "CHILD, AFTER OTHER altered()"
    end
end

son = Child.new()

son.implicit()
son.override()
son.altered()

OTHER implicit()
CHILD override()
CHILD, BEFORE OTHER altered()
OTHER altered()
CHILD, AFTER OTHER altered()

projects/lexicon/lib/lexicon.rb:

class Lexicon
  attr_accessor :lexicon, :dictionary

  def initialize()
    @dictionary =
    {
      :north    => :direction,
      :south    => :direction,
      :east     => :direction,
      :west     => :direction,
      :go       => :verb,
      :kill     => :verb,
      :eat      => :verb,
      :bear     => :noun,
      :princess => :noun,
      :the      => :stop,
      :in       => :stop,
      :of       => :stop,
    }
  end

  Pair = Struct.new( :qualifier, :value )

  def scan(list)
    pairs = []
    list.split.map do | value |
      puts value
      if value.match( /^[0-9]+$/ )
        pairs.push( Pair.new( :number, value.to_i ) )
      elsif qualifier = @dictionary[ value.intern ]
        pairs.push( Pair.new( qualifier, value ) )
      else
        pairs.push( Pair.new( :error, value.to_s ) )
      end
    end
    pairs
  end
end

projects/lexicon/test/test_lexicon.rb:

require 'test/unit'
require_relative "../lib/lexicon/lexicon"

class LexiconTests < Test::Unit::TestCase

  Pair = Lexicon::Pair
  @@lexicon = Lexicon.new()

  def test_directions()
    assert_equal( [ Pair.new( :direction, 'north' ) ], @@lexicon.scan( "north" ) )
    result = @@lexicon.scan( "north south east" )
    assert_equal( result, [ Pair.new( :direction, 'north' ),
                  Pair.new( :direction, 'south' ),
                  Pair.new( :direction, 'east' ) ] )
  end

  def test_verbs()
    assert_equal( @@lexicon.scan("go"), [Pair.new(:verb, 'go' ) ] )
    result = @@lexicon.scan( "go kill eat" )
    assert_equal( result, [ Pair.new( :verb, 'go' ),
                  Pair.new( :verb, 'kill' ),
                  Pair.new( :verb, 'eat' ) ] )
  end

  def test_stops()
    assert_equal( @@lexicon.scan( "the" ), [Pair.new(:stop, 'the' ) ] )
    result = @@lexicon.scan( "the in of" )
    assert_equal( result, [ Pair.new( :stop, 'the' ),
                  Pair.new( :stop, 'in' ),
                  Pair.new( :stop, 'of' ) ] )
  end

  def test_nouns()
    assert_equal( @@lexicon.scan( "bear" ), [Pair.new(:noun, 'bear' ) ] )
    result = @@lexicon.scan( "bear princess" )
    assert_equal( result, [ Pair.new( :noun, 'bear' ),
                  Pair.new( :noun, 'princess' ) ] )
  end

  def test_numbers()
    assert_equal( @@lexicon.scan( "1234" ), [ Pair.new( :number, 1234 ) ] )
    result = @@lexicon.scan( "3 91234 " )
    assert_equal( result, [ Pair.new( :number, 3 ),
                  Pair.new( :number, 91234 ) ] )
  end

  def test_errors()
    assert_equal( @@lexicon.scan( "ASDFADFASDF" ), [ Pair.new( :error, 'ASDFADFASDF' ) ] )
    result = @@lexicon.scan( "bear IAS princess" )
    assert_equal( result, [ Pair.new( :noun, 'bear' ),
                  Pair.new( :error, 'IAS' ),
                  Pair.new( :noun, 'princess' ) ] )
  end
end

$ ruby test_lexicon.rb
Run options:

# Running tests:

north
north
south
east
.ASDFADFASDF
bear
IAS
princess
.bear
bear
princess
.1234
3
91234
.the
the
in
of
.go
go
kill
eat
.

Finished tests in 0.000920s, 6519.4432 tests/s, 13038.8863 assertions/s.

6 tests, 12 assertions, 0 failures, 0 errors, 0 skips

formatter = "%s %s %s %s"

puts formatter % [ 1, 2, 3, 4 ]
puts formatter % [ "one", "two", "three", "four" ]
puts formatter % [ true, false, false, true ]
puts formatter % [ formatter, formatter, formatter, formatter ]
puts formatter % [
    "I had this thing.",
    "That you could type up right.",
    "But it didn't sing.",
    "So I said goodnight."
]

1 2 3 4
one two three four
true false false true
%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s
I had this thing. That you could type up right. But it didn't sing. So I said goodnight.

days   = "Mon Tue Wed Thu Fri Sat Sun"
months = "Jan\nFeb\nMar\nApr\nMay\nJun\nJul\nAug"

puts "Here are the days: ", days
puts "Here are the months: ", months

puts <<PARAGRAPH
There's something going on here.
With the PARAGRAPH thing
We'll be able to type as much as we like.
Even 4 lines if we want, or 5, or 6.
PARAGRAPH

Here are the days:
Mon Tue Wed Thu Fri Sat Sun
Here are the months:
Jan
Feb
Mar
Apr
May
Jun
Jul
Aug
There's something going on here.
With the PARAGRAPH thing
We'll be able to type as much as we like.
Even 4 lines if we want, or 5, or 6.

print "How old are you? "
age = gets.chomp()
print "How tall are you? "
height = gets.chomp()
print "How much do you weigh? "
weight = gets.chomp()

puts "So, you're #{age} years old, #{height} tall and #{weight} heavy."

How old are you? 65
How tall are you? 72
How much do you weigh? 568
So, you're 65 years old, 72 tall and 568 heavy.

user = ARGV.first
prompt = '> '

puts "Hi #{user}, I'm the #{$0} script."
puts "I'd like to ask you a few questions."
puts "Do you like me #{user}?"
print prompt
likes = STDIN.gets.chomp()

puts "Where do you live #{user}?"
print prompt
lives = STDIN.gets.chomp()

puts "What kind of computer do you have?"
print prompt
computer = STDIN.gets.chomp()

puts <<MESSAGE
Alright, so you said #{likes} about liking me.
You live in #{lives}.  Not sure where that is.
And you have a #{computer} computer.  Nice.
MESSAGE

$ ruby prompt.rb Jack in the Bean Stalk
Hi Jack, I'm the prompt.rb script.
I'd like to ask you a few questions.
Do you like me ?
> Yes
Where do you live ?
> Here
What kind of computer do you have?
> Hewlett-Packard
Alright, so you said Yes about liking me.
You live in Here.  Not sure where that is.
And you have a Hewlett-Packard computer.  Nice.

try-library.rb:

require 'open-uri'

open("http://www.ruby-lang.org/en") do |f|
  f.each_line {|line| p line}
  puts f.base_uri         # <URI::HTTP:0x40e6ef2 URL:http://www.ruby-lang.org/en/>
  puts f.content_type     # "text/html"
  puts f.charset          # "iso-8859-1"
  puts f.content_encoding # []
  puts f.last_modified    # Thu Dec 05 02:45:02 UTC 2002
end

If you're behind a firewall, this won't work.

$ export http_proxy="http://web-proxy.austin.hp.com:8080"
$ ruby try-library.rb
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\"\n"
"   \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\n"
"<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"
"  <head>\n"
"    <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\" />\n"
.
.
.

projects/fun/lib/fun.rb:

class Room
  attr_accessor :name, :description, :paths

  def initialize( name, description )
    @name = name
    @description = description
    @paths = {}
  end

  def go( direction )
    @paths[ direction ]
  end

  def add_paths( paths )
    @paths.update( paths )
  end
end

projects/fun/test/test_fun.rb:

require 'test/unit'
require_relative '../lib/fun'

class MyUnitTests < Test::Unit::TestCase

  def test_room()
    gold = Room.new( "GoldRoom",
                     """This room has gold in it you can grab. There's a
                        door to the north.""" )
    assert_equal( gold.name, "GoldRoom")
    assert_equal( gold.paths, {} )
  end

  def test_room_paths()
    center = Room.new( "Center", "Test room in the center." )
    north = Room.new( "North", "Test room in the north." )
    south = Room.new( "South", "Test room in the south." )

    center.add_paths( { :north => north, :south => south } )
    assert_equal( center.go( :north ), north )
    assert_equal( center.go( :south ), south )
  end

  def test_map()
    start = Room.new( "Start", "You can go west and down a hole." )
    west  = Room.new( "Trees", "There are trees here, you can go east." )
    down  = Room.new( "Dungeon", "It's dark down here, you can go up." )

    start.add_paths( { :west => west, :down => down } )
    west.add_paths( { :east => start } )
    down.add_paths( { :up => start } )

    assert_equal( start.go( :west ), west )
    assert_equal( start.go( :west ).go( :east ), start )
    assert_equal( start.go( :down ).go( :up ), start )
  end
end

$ ruby test_fun.rb
Run options:

# Running tests:

...

Finished tests in 0.000536s, 5599.6790 tests/s, 13065.9176 assertions/s.

3 tests, 7 assertions, 0 failures, 0 errors, 0 skips

run-ruby-file.rb:

#!/usr/bin/ruby

puts "Run a selected Ruby file..."
output = `ruby ./hello-world.rb`
puts output

hello-world.rb:

#!/usr/bin/ruby

# Some Ruby code to run...
print "Hello, World!"

$ ruby test-test.rb
Hello, World!