Modules

Modules in Ruby define a grouping of common classes or methods which can later be mixed into other modules or classes.

A module is defined by using the module...end block.

Modules are included in classes or other modules by using the include directive.

Classes

Classes in Ruby act as object templates like they do in other OO languages. However, Classes too are objects in Ruby.

Ponder that one: A ruby class is an object representing a class of objects.

Classes are defined using the class...end block. They are not required to be named. In fact, anonymous classes are the key to ruby's object model. For more on the ruby object model, see the official ruby documentation, or Dave Thomas's screen cast series on "The Ruby Object Model and Metaprogramming."

Example

module Talker
  def say_hello
    puts "Hello"	
  end
end

class MyClass
  include Talker
end

m = MyClass.new
m.say_hello # => "Hello"

class MyClass
  # I've reopened the class MyClass now, so I can change it!

  # self.method_name changes the scope to make this a class method!
  def self.say_world
    puts "World"
  end
end

MyClass.say_world # => "World"

Purpose/Language Domain

Created by Yukihiro "matz" Matsumoto, Ruby is a dynamic, reflective, general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features.

Ruby supports multiple programming paradigms, including functional, object oriented, imperative and reflective. It also has a strong, dynamic type system, and automatic memory management / garbage collection; it is therefore similar in varying respects to Python, Perl, Lisp, Dylan, and CLU.

Matsumoto has said that Ruby is designed for programmer productivity and fun, following the principles of good user interface design. He stresses that systems design needs to emphasize human, rather than computer, needs.

“Often people, especially computer engineers, focus on the machines. They think, "By doing this, the machine will run faster. By doing this, the machine will run more effectively. By doing this, the machine will something something something." They are focusing on machines. But in fact we need to focus on humans, on how humans care about doing programming or operating the application of the machines. We are the masters. They are the slaves."

However, while being a general purpose programming language Ruby has grown in prominence as a language for web applications and developement, especially with the addition of the Rails framework, which was created in 2003.

“Ruby on Rails is a breakthrough in lowering the barriers of entry to programming. Powerful web applications that formerly might have taken weeks or months to develop can be produced in a matter of days.” -Tim O'Reilly, Founder of O'Reilly Media

Reserved Words

alias   and     BEGIN   begin   break   case    class   def     defined 
do      else    elsif   END     end     ensure  false   for     if 
in      module  next    nil     not     or      redo    rescue  retry 
return  self    super   then    true    undef   unless  until   when 
while   yield

History

Ruby is a language of careful balance. Its creator, Yukihiro "matz" Matsumoto, blended parts of his favorite languages (Perl, Smalltalk, Eiffel, Ada, and Lisp) to form a new language that balanced functional programming with imperative programming.

He has often said that he is "trying to make Ruby natural, not simple," in a way that mirrors life.

Building on this, he adds:

"Ruby is simple in appearance, but is very complex inside, just like our human body."

Ruby was conceived on February 24, 1993. Matsumoto wished to create a new language that balanced functional programming with imperative programming. According to Matsumoto he "wanted a scripting language that was more powerful than Perl, and more object-oriented than Python. That's why I decided to design my own language".

The standard 1.8.6 (stable) implementation is written in C, as a single-pass interpreted language. There is currently no specification of the Ruby language, so the original implementation is considered to be the de facto reference. As of 2008, there are a number of complete or upcoming alternative implementations of the Ruby language, including YARV, JRuby, Rubinius, IronRuby, and MacRuby, each of which takes a different approach, with JRuby and IronRuby providing just-in-time compilation. The official 1.9 branch uses YARV, as will 2.0 (development), and will eventually supersede the slower Ruby MRI.

Some important dates to note:

• Ruby is in public – release 21 December 1995 – ruby-0.95
• 22 Septempber 1997: an article was published on Ruby – the first article on the web about Ruby.
• 7 December 1998: Ruby home page was in English, but very simple.
• 27 October 1999: Matz and Keiju’s book is published, the first Ruby book

Online References

• Official Ruby Web Site
• Official Ruby Quick Start Guide
• Official Ruby Help & Documentation
• Interactive Ruby Tutorial
• Why’s Poignant Guide to Ruby
• Screencasts teaching Metaprogramming with Ruby

Identifiers

Identifiers in Ruby consist of letters, digits, and the underscore character.
Identifiers may start with either letters or an underscore, not a number.
There is no restriction on length.
Ruby is case sensitive so Awesome is not the same as awesome

Examples:

foobar 
ruby_is_simple
__ruby
ruby_
twenty5

Common naming conventions are as follows:

ClassNames
method_names and variable_names
methods_asking_a_question?
slightly_dangerous_methods!
@instance_variables
$global_variables
SOME_CONSTANTS or OtherConstant

Example taken from Jim Weirich

Data Types

Everything in Ruby is an object. Everything has a class. This also means that there are no primitives. Here's some code that illustrates that point:

h = { "hash?" => "yep, a hash!", "the answer to everything" => 42 }
puts "This is a string!".class
puts 1.class
puts nil.class
puts h.class
puts :symbol.class

String
Fixnum
NilClass
Hash
Symbol

As you can see every object has a method called class that returns that object's class. You can call methods on pretty much anything you want.

Constants

Constants are very simple in Ruby. There are two things to remember.

1. Constants begin with a capital letter. So A_CONSTANT or Constant is considered a constant but constant is not.
2. You can change the value of a constant. However, Ruby will give you a warning.

Symbols

As stated earlier everything in Ruby is an object. This is great because we can call methods on pretty much anything. Even numbers if we want. However, it comes with a cost. Lots and lots of objects make our code slower. Symbols are the answer to this problem. A symbol is something that you use to represent names and strings. Anytime we type a string Ruby will make a new object from that string even if it's the same exact string as one we've typed earlier. A couple lines of code illustrate this nicely in irb.

>>"i'm a string".object_id
=> 1789460
>>"i'm a string".object_id
=> 1786670

As you can see from the difference in addresses, Ruby is creating a new object regardless of whether or not the string is identical to the one before it. If we use symbols instead, we get a better result.

>>:a_symbol.object_id
=> 199138
>>:a_symbol.object_id
=> 199138

Problem solved. Note that symbols are declared with a colon in front of word like :this_is_a_symbol.

Instance and Class variables

Instance variables are those whose name begins with '@' such as @instance_variable. An instance variable belongs to the object itself.

Class variables are those whose name begins with '@@' such as @@class_variable.

Hashes

Hashes are pretty cool. You declare hashes by using curly braces like h = {} The Hash is probably the most famous data structure especially when it comes to Ruby on Rails programming. The best way to illustrate these is to just show you what they look like.

hash = { :ben => 869403, :taylor => 378293, :brad => 234898 }

# We can insert a key value pair
hash[:bjork] = 2374908

# We can delete a key value pair
hash.delete(:bjork)

# We can even get all the keys in the hash
hash.keys

# And get the values
hash.values

You may notice that symbols are the preferred keys in this case instead of strings. As explained earlier we do this so that less memory is spent when working with the hash.

Arrays

Arrays are straightforward and not picky in Ruby. They behave similarly to our friends in the C family with a little more flexibility. I say not picky because it doesn't matter what you put into them. They can accommodate diverse object types. They are declared like a hash but with brackets like a = []

my_array = ["cool", :sweet, 324]

# We can access or change elements in an array
my_array[0] = "awesome"

# We can can access a range of elements
my_array[0..1]

# We can even concatenate arrays
my_array + ["excellent", "tubular"]

Strings

Strings are written in quotes like this "string" or this 'another string'. You can do some pretty nifty things with strings. Here are a few examples:

# Outputs 50183810
"A String!".hash

# Outputs "concatenate"
"concat" + "enate"

# Outputs "Massachusetts"
"massachusetts".capitalize

# Outputs "uppercase"
"UPPERCASE".downcase

# Outputs "LOWERCASE"
"lowercase".upcase

# Outputs "Henry VII"
"Henry VIII".chop

# Outputs "rorriM"
"Mirror".reverse

# Outputs 1847
"characters added up".sum

Regular Expressions

Regular expressions are available to be used in Ruby. Much like Perl, regular expressions or a Regex object are generally surrounded by forward slashes rather than double quotes. They have an efficient expressive power that can save you time and many lines of code whenever you need to do pattern matching and/or searching strings. The most common string methods that use regular expressions are the sub, sub!, gsub and gsub! methods. sub replaces the first occurance of the word or regular expression specified. gsub replaces all occurances of the word or regular expression.

You might recall earlier that the exclamation point is a naming convention for slightly dangerous methods. For instance, sub would only return a copy of the modified string where as sub! would return the actual modified string. Here are a couple examples showing regular expressions in these methods.

phone = "2004-959-559 # This is Phone Number"

# Delete Ruby-style comments
phone = phone.sub!(/#.*$/, "")   
puts "Phone Num : #{phone}"

# Remove anything other than digits
phone = phone.gsub!(/\D/, "")    
puts "Phone Num : #{phone}"

text = "I like the color 0xFF9900 and the color 0xafD930"

# Put blank space instead of hex values
puts text.sub(/0(x|X)(\d|[a-f]|[A-F])+/, "___________")

puts text.gsub(/0(x|X)(\d|[a-f]|[A-F])+/, "___________")


### Output
Phone Number : 2004-959-559 
Phone Number : 2004959559
I like the color ___________ and the color 0xafD930
I like the color ___________ and the color ___________

Another place regular expressions are used in Ruby is to test if a string contains a string. =~ is a matching operator that returns the position of where the match to the regular expression was found or returns nil if there was no string found. Here is an example:

line1 = "Cats are smarter than dogs";
line2 = "Cats also like meat";

# tests to see if line1 contains a d
if ( line1 =~ /d/ )
  puts "line1 contains a 'd'"
else
  puts "line1 does not contain a 'd'"
end

# tests to see if line2 contains a d
if ( line2 =~ /d/ )
  puts "line2 contains a 'd'"
else
  puts "line2 does not contain a 'd'"
end

### Output
line1 contains a 'd'
line2 does not contain a 'd'

Recall that a number will evaluate as true where as nil will evaluate as false.

Examples and some text taken from:
Mark Slagell
Tutorials Point
http://en.wikibooks.org/wiki/Ruby_Programming/Data_types

Data Structures

Ranges:

A range is two values surrounded by parentheses and separated by an ellipsis (in the form of two or three dots).

(1..5)

Array:

The class Array holds a collection of object references. Each object reference occupies a position in the array, identified by a non-negative integer index.

You can create arrays using literals or by explicitly creating an Array object. A literal array is simply a list of objects between square brackets.

a = [ 3.14159, "pie", 99 ]
a.type 	
»  Array
a.length
»  3
a[0]
»  3.14159
a[1]
»  "pie"
a[2]
»  99
a[3]
»  nil
b = Array.new
b.type
»  Array
b.length
»  0
b[0] = "second"
b[1] = "array"
b
»  ["second", "array"]

Hash:

Hashes (sometimes known as associative arrays or dictionaries) are similar to arrays, in that they are indexed collectives of object references.

However, while you index arrays with integers, you can index a hash with objects of any type: strings, regular expressions, and so on. When you store a value in a hash, you actually supply two objects---the key and the value. You can subsequently retrieve the value by indexing the hash with the same key. The values in a hash can be any objects of any type. The example that follows uses hash literals: a list of key => value pairs between braces.

h = { 'dog' => 'canine', 'cat' => 'feline', 'donkey' => 'asinine' }
h.length
»  3
h['dog']
»  "canine"
h['cow'] = 'bovine'
h[12]    = 'dodecine'
h['cat'] = 99
h
»  {"cow"=>"bovine", "cat"=>99, 12=>"dodecine",
 				"donkey"=>"asinine", "dog"=>"canine"}

Compared with arrays, hashes have one significant advantage: they can use any object as an index. However, they also have a significant disadvantage: their elements are not ordered, so you cannot easily use a hash as a stack or a queue.

Set:

Set implements a collection of unordered values with no duplicates. This is a hybrid of Array‘s intuitive inter-operation facilities and Hash‘s fast lookup.

Several methods accept any Enumerable object (implementing each) for greater flexibility: new, replace, merge, subtract, |, &, -, ^.

The equality of each couple of elements is determined according to Object#eql? and Object#hash, since Set uses Hash as storage.

Finally, if you are using class Set, you can also use Enumerable#to_set for convenience.

Example

  require 'set'
  s1 = Set.new [1, 2]            # -> #
  s2 = [1, 2].to_set             # -> #
  s1 == s2                       # -> true
  s1.add("foo")                  # -> #
  s1.merge([2, 6])               # -> #
  s1.subset? s2                  # -> false
  s2.subset? s1                  # -> true

SortedSet implements a set which elements are sorted in order.

Struct

A Struct is a convenient way to bundle a number of attributes together, using accessor methods, without having to write an explicit class.

# Create a structure with a name in Struct
Struct.new("Customer", :name, :address)
=> Struct::Customer

Struct::Customer.new("Dave", "123 Main")
=> #< Struct::Customer name="Dave", address="123 Main">

# Create a structure named by its constant
Customer = Struct.new(:name, :address)
=> Customer

Customer.new("Dave", "123 Main")
=> #< struct Customer name="Dave", address="123 Main">

Expressions

Expressions in Ruby are pretty much the same as the C family or most other common programming languages. Here are some examples:

true
a_number = (22 + 4) * 4 / 9

Here is a list of operators in order of highest to lowest precedence:

Control Structures

Conditional Branches

Ruby can control the execution of code using Conditional branches. A conditional Branch takes the result of a test expression and executes a block of code depending whether the test expression is true or false. If the test expression evaluates to the constant false or nil, the test is false; otherwise, it is true. Note that the number zero is considered true, whereas many other programming languages consider it false.

In many popular programming languages, conditional branches are statements. They can affect which code is executed, but they do not result in values themselves. In Ruby, however, conditional branches are expressions. They evaluate to values, just like other expressions do. An if expression, for example, not only determines whether a subordinate block of code will execute, but also results in a value itself. For instance, the following if expression evaluates to 3:

if true
  3
end			

Conditional branch examples:

a = 5
if a == 4
  a = 7
end
puts a # will print 5 since the if-block isn't executed

These are all equivalent. Notice the statement may be put on the same line as the expression, the equivalence of "then" and ":", and the the third example as an alternate form of the first two.

if a == 4 then a = 7 end

if a == 4: a = 7 end

a = 7 if a == 4

The unless-expression is the opposite of the if-expression, the code-block it contains will only be executed if the test expression is false.

Example:

a = 5
unless a == 4
  a = 7
end
puts a # will print 7 since the if-block is executed

if-elsif-else expression

The elsif (note that it's elsif and not elseif) and else blocks give you further control of your scripts by providing the option to accommodate additional tests. The elsif and else blocks are considered only if the if test is false. You can have any number of elsif blocks but only one if and one else block.

Syntax:

if expression
  ...code block...
elsif another expression
  ...code block...
elsif another expression
  ...code block...
else
  ...code block...
end

case expression

An alternative to the if-elsif-else expression (above) is the case expression. Case in Ruby supports a number of syntaxes. For example, suppose we want to determine the relationship of a number (given by the variable a) to 5. We could say:

a = 1
case 
  when a < 5 then puts "#{a} less than 5"    
  when a == 5 then puts "#{a} equals 5"   
  when a > 5 then puts "#{a} greater than 5" 
end

A more concise syntax for case is to imply the comparision:

case a
  when 0..4 then puts "#{a} less than 5"    
  when 5 then puts "#{a} equals 5" 
  when 5..10 then puts "#{a} greater than 5" 
  else puts "unexpected value #{a}"       
end

while loop

No surprises here, the while statement in Ruby is very similar syntactically to if and to other languages' while loops:

while 
  <...code block...>
end

for loop

Ruby's for loop has some flexibility in structure. The loop below runs once for each element in a collection (array, hash, numeric sequence, etc.), but doesn't make the programmer think about indices:

for each in collection
  # ... each refers to an element of the collection
end

The collection can be a range of values (this is what most people mean when they talk about a for loop):

for num in (4..6)
    puts num
end
4
5
6
=> 4..6

And yet another form to construct a for loop:

>> arr = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
>> arr.each {|element|
?> puts element}
1
2
3
4
5
=> [1, 2, 3, 4, 5]

Regarding Looping...

There are four ways to interrupt the progress of a loop from inside. First, break means to escape from the loop entirely. Second, next skips to the beginning of the next iteration of the loop. Third, ruby has redo, which restarts the current iteration. And the last way to get out of a loop from the inside is return. An evaluation of return causes escape not only from a loop but from the method that contains the loop. If an argument is given, it will be returned from the method call, otherwise nil is returned.

Writing Scripts

Use gedit on the linux workstations, because its light and has ruby syntax highlighting.

you can run stuff like this:

ruby script.rb

#! /usr/bin/ruby
puts "Hello World!"


./script.rb

Input/Output

Ruby provides a whole set of I/O related methods. All of the I/O methods are derived from the class IO. This class provides basic input/output methods such as read, write, gets, puts, readline, getc and printf.

Console I/O

Most input and output with the console are done through the puts, print, and gets methods. The puts method displays the value stored in the variable. It adds a new line after every line it writes. The print method does the same thing as puts without the newline. The gets method is to take any input from the user. The following code illustrates all 3 methods.

# prints "Enter Your Name: " and stays on the same line
print "Enter Your Name: "

# name is assigned to whatever the user inputs before pressing enter
name = gets

# prints "Hello" + name with a new line.
puts "Hello #{name}"

# another way to write this would be
puts "Hello" + name

File I/O

The same methods above are available for file objects. However, Ruby gives us a few more tools when working with files. Files are opened and closed using the File object. Once a file is opened and the mode is specified (either r, r+, w, w+, a, a+) we can edit the file to our liking then close the file. The following illustrates reading a file then printing its contents.

# open an existing file named "index.html" in read-only mode
f = File.open("index.html", "r")  

# make a new array called file_data which contains each line of the file
file_data = f.readlines

# iterate through the array and print each line
file_data.each do |line|
	puts line
end 

#close the file
f.close

For more examples go to tutorialspoint.com

Interactive Ruby (IRB)

Interactive Ruby Shell (IRB) is a shell for programming in the object-oriented scripting language Ruby. IRB is run from the command line and allows the programmer to experiment with code in real time. It allows you to enter Ruby commands at the prompt and have the interpreter respond immediately.

To start the Interactive Ruby Shell from most Linux/Unix machines with Ruby installed, simply type "irb" at the command line. For Windows machines run the executable from the start menu.

# Terminal Session	
home$ irb
>> 

You may define functions and classes directly within irb or you can load previously written ones by using the load command.

load "function.rb"

For an example of and tutorial using the IRB, check out the Interactive Ruby Tutorial found on the Online References page.

Threading

Though we're not closely covering Threading, we though it was worth mentioning that Ruby does support it and below is an example of a Threaded and Unthreaded version of a set of functions. Both versions will display the amount of time to run completely in order to roughly compare efficiency.

Two functions that will run concurrently (Threaded):

def func1
  i = 0
  while i <= 5
    puts "func1 at: #{Time.now}"
    sleep(2)
    i = i + 1
  end
end
def func2
  i = 0
  while i <= 5
    puts "func2 at: #{Time.now}"
    sleep(1)
    i = i + 1
  end
end

puts "Start at: #{start = Time.now}"
t1 = Thread.new{func1()}
t2 = Thread.new{func2()}
t1.join
t2.join
puts "End at: #{stop = Time.now}"
puts "Total time: #{stop-start}"

Two functions run sequentially (Unthreaded):

def func1
  i = 0
  while i <= 5
    puts "func1 at: #{Time.now}"
    sleep(2)
    i = i + 1
  end
end
def func2
  i = 0
  while i <= 5
    puts "func2 at: #{Time.now}"
    sleep(1)
    i = i + 1
  end
end

puts "Start at: #{start = Time.now}"
func1
func2
puts "End at: #{stop = Time.now}"
puts "Total time: #{stop-start}"

Exception Handling

We enclose code that could raise an exceptions in a begin/end block and use a rescue clause to tell Ruby what types of exceptions we want to handle. If we want to make sure that a block of code is executed regardless of whether or not an exception was raised we use ensure. The else clause is similar to ensure except that the body of the else clause is executed only if there were no exceptions raised. Here are a few examples:

# capturing built in exceptions
begin
  eval string
rescue SyntaxError, NameError => boom
  print "String doesn't compile: " + boom
rescue StandardError => bang
  print "Error running script: " + bang
end

# one way of raising your own exception. 
# This would go in the begin/end block of your code.
raise "bad mp3 encoding"	
	
# the rescue clause handles the error 
# the ensure clause executes no matter what
f = File.open("testfile")
begin
  # .. process
rescue Exception
  # .. handle error
ensure
  f.close unless f.nil?
end

# here the else clause only executes if no exceptions are raised
f = File.open("testfile")
begin
  # .. process
rescue Exception
  # .. handle error
else
  puts "Congratulations-- no errors!"
ensure
  f.close unless f.nil?
end

Metaprogramming

One of the places where Ruby truly shines is in the realm of metaprogramming. Metaprogramming is best defined as "writing code that writes code." The crux of metaprogramming in ruby boils down to two methods: define_method, and eval.

define_method

define_method is available to modules and classes, and takes two parameters:

1. the name of the method
2. a block, serving as the body of the method to be defined

Example 1 - define_method

class Multiplier
  def self.create_multiplier(n)
    define_method("times_#{n}") do |val|
      val * n
    end
  end

  10.times { |i| create_multiplier(i) }
end

Example taken from "The Ruby Object Model and Metaprogramming" - Episode 3 by Dave Thomas.

Here, we see that the class method create_multiplier(n) of the class Multiplier uses define_method to create a method which is dynamically named, based on the value of n. This new method accepts one parameter, returning the result of that parameter * n.

At the end of the class Multiplier, we see the power of metaprogramming is harnessed to programmatically generate 10 methods on the class with a single line of code. Multiplier now has the methods: times_0(val)...times_9(val)

eval

eval is available in all contexts, and takes one string parameter. This string will be evaluated as ruby code, and the result is returned.

Example 2 - eval

>> eval("myclass = Class.new")
=> #<Class:0x5f10a4>
>> myclass
=> #<Class:0x5f10a4>