Essential Ruby

By Melchior Brislinger and Peter Cooper

ABOUT RUBY

Ruby is an easy-to-learn, dynamic, object-oriented programming language with dynamic typing and automatic memory management. While object-oriented at heart, it provides facilities for procedural and functional programming as well as extensive support for introspection and meta-programming. Ruby's core API, extensive standard library, and thousands of high-quality external libraries make it suitable for many different programming tasks in multiple disciplines (key examples being network programming, Web applications, shell scripts, data processing, and text manipulation).

Ruby is already installed on Mac OS X and many Linux distributions. For Windows the easiest way to install everything necessary is the Ruby Installer (http://rubyinstaller.rubyforge.org).

and many important API functions for quick lookup.

RUBY LANGUAGE OVERVIEW

Ruby is considered to be a "pure" object-oriented language because almost every concept within Ruby is object-oriented in some sense. Yukihiro "Matz" Matsumoto, Ruby's creator, wanted to develop a language that operated on the "principle of least surprise" meaning that code should behave in a nonconfusing manner and be reasonably self-explanatory (beyond the basic syntax). Matz also wanted Ruby to be a pleasurable language with which to program, and not make unnecessary demands upon the programmer.

Ruby is considered a "reflective" language because it's possible for a Ruby program to analyze itself (in terms of its make-up), make adjustments to the way it works, and even overwrite its own code with other code. It's also considered to be "dynamically typed" because you don't need to specify what type of objects can be associated with certain variables. Objects are considered prime in Ruby and whether you're passing around a string, a number, a regular expression, or even a class, you're just dealing with an object from Ruby's point of view.

Ruby will seem reasonably familiar to Python and Perl programmers (and to a lesser extent C# and JavaScript developers) as Ruby was heavily inspired by Perl in certain areas (as was Python). Ruby is less similar to languages like C, C++ or Java because these languages are compiled (not interpreted), statically typed, and focused on performance rather than flexibility and conciseness.

SIMPLE RUBY EXAMPLES

Despite being an object-oriented language, it is not necessary to use explicitly object-oriented syntax within a basic Ruby program. While everything works on objects (and methods called upon those objects) behind the scenes, you can write a program as simply as this:

def fib(i)
	if i.zero?
		0
	elsif i == 1
		1
	else
		fib(i - 2) + fib(i - 1)
	end
end
puts fib(10)

This script prints to screen the 10th number in the Fibonacci sequence. It defines a method called fib that returns the relevant result from a simple if/elsif/else expression. Note the use of standard equality syntax (==), addition (+), subtraction (-), and method calling (fib(10)), but also note the possibility of using methods in somewhat idiomatic ways (i.zero? rather than i == 0—though the latter would also work). The use of i.zero? demonstrates calling a method upon an object (where i is the object, and zero? is the method).

Developing a program with "true" object-oriented syntax is not significantly different. For example:

class Person
	attr_accessor :name, :age
	
	def full_info
		return "#{@name} is #{@age} years old"
	end
end
fred = Person.new
fred.name = "Fred"
fred.age = 45
puts fred.full_info

In this example, a class (Person) is defined, and attributes (name and age) and a method (full_info) are defined upon that class. Below the class definition, we then create an instance of the Person class and assign it to a variable, fred, before assigning values to its attributes, and then calling that instance's full_info method (which, in turn, uses instance variables—prefixed with @-to create its output).

Earlier we called Ruby a "reflective" language because it offers functionality to programs to change, extend, and otherwise inspect themselves. We can look at a key Ruby idiom and reflective feature—class reopening—by changing the Fibonacci example from earlier to the following:

class Integer
	def fib
		if self.zero?
			0
		elsif self == 1
			1
		else
			(self - 2).fib + (self - 1).fib
		end
	end
end

puts 10.fib

Note this time that in order to get the Fibonacci number, we're no longer calling a global fib method, but a method that works directly upon the number 10 itself (remember, everything is an object—even the number 10!). The way this is achieved is by "reopening" a standard Ruby class—Integer—and defining a new method called fib within it. This then makes the fib method available to all objects of class Integer in Ruby! Note that the content of the integer object itself (the number we need to use) is obtained with the self keyword. self, in this case, returns a representation of the current object in its native form. In this sense, Ruby is very similar to Python.

IRB

IRB (short for "Interactive Ruby") is an interactive prompt or "Read-Eval-Print-Loop" (REPL) that uses the Ruby interpreter. Anything you type is evaluated by Ruby and the response printed to screen. IRB can be invoked by running "irb" from the command. A demonstrative session shows the usage:

irb(main):001:0> 3 + 5
=> 8

irb(main):002:0> "hello there " * 3
=> "hello there hello there hello there "

irb(main):001:0> "A String".class
=> String

irb(main):002:0> "A String".methods.sort
=> ["%", "*", "+", "<", "<<", "<=", "<=>", "==",
"===", "=~", ">", ">=", "[]", "[]=", "__id__", "__
send__", "all?", ...

irb(main):003:0> "A String".class.methods.sort
=> ["<", "<=", "<=>", "==", "===", "=~", ">", ">=",
"__id__", "__send__", "allocate", "ancestors",
"autoload", ...

IRB is most commonly used when learning the Ruby programming language, and also as a handy "sand box" to try out new programming tricks and techniques quickly. IRB can be used to interactively explore classes, test pieces of code and is also used as a console to inspect and manipulate running programs, for example, in Web applications.

RUBYGEMS

RubyGems is the official Ruby package manager (though, notably, it is not included with default Ruby 1.8 releases by default— although it is present within Ruby 1.9 and on the OS X version of Ruby 1.8). It allows developers and users to easily search, install and update Ruby libraries and their dependencies and works in a similar fashion to other package management tools (such as yum and apt-get).

Gems are installed by running "gem install" and the name of the gem (e.g. gem install rails). Running "gem update" updates all installed gems to their latest official versions.

A selection of popular Ruby gems/libraries:

Information about RubyGems can be found at: http://www.rubygems.org

RUBY LANGUAGE REFERENCE TABLES

The following reference tables provide a quick look at many elements of Ruby's syntax. These can be used as a comparison to other languages in order to see how the syntax differs. Ruby's syntax is often rather different to that of, say, Java or C#.

Types

Literals

Variables

if condition
...
end

if condition
...
elsif condition
...
else
...
end

unless condition
...
else
...
end

... if condition

... unless condition

condition ? ... : ... (a ternary operator)

case ...
when condition
...
else
...
end

while condition
...
end

until condition
...
end

do
...
while condition

do
...
until condition

for object in enumerable
...
end

break
next
redo
retry

yield arguments

Modules & Classes

module Name
...
end

class Name < Super
...
end

class << SomeClass
...
end

include Module

def name(arguments)
...
end

def Class.name(arguments)
...
end
def self.name(arguments)
...
end

public
protected
private

public symbol
protected symbol
private symbol

attr symbols
attr_accessor symbols
attr_reader symbols
attr_writer symbols

Constants

Exceptions

begin
...
rescue exception => variable
...
else
...
ensure
...
end

Figure 1 shows the Exception hierarchy.

Ruby Tools

Ruby Interpreter Arguments

Regular Expressions

Ruby Core API

Figure 2 shows important Core API classes and their inheritance tree.

The following is a selection of important Ruby Core API objects and methods. Instance methods are written .method and called object.method while class methods are written #method and called Class.method.

Object

Enumerable

Array (Enumerable)

Hash (Enumerable)

String (Enumerable)

IO

File < IO

File options

Struct

Kernel

RUBY 1.9

Ruby 1.9 is the new version of Ruby considered transitional to Ruby 2.0 containing many changes to the language and libraries. It has an entirely new virtual machine and bytecode compiler, formerly known as YARV.

The new version includes support for unicode in strings, the famous Oniguruma regular expression engine as well as Operating System Threads and Fibers for lightweight concurrency.

Important syntax additions/differences to Ruby 1.8

def foo(a, b = 2, c, d = 3)
...
end

RESOURCES

About The Authors

Melchior Brislinger

Melchior Brislinger is currently a student of Visual Communication at the Bauhaus-University Weimar, Germany. He uses Ruby and other programming languages and tools to explore the possibilities of combining art, design and technology

Peter Cooper

Peter Cooper is a digital "jack of all trades" based in the north of England. He is author of Beginning Ruby-published by Apress- creator of numerous Web sites and technologies, a professional blogger who runs Ruby Inside-the most popular blog for Ruby and Rails developers-and an entrepreneur who sold two startups in 2007.

Publications

• Beginning Ruby, Apress

Projects

Ruby Inside - http://www.rubyinside.com/
Ruby Flow - http://www.rubyflow.com/
Rails Inside - http://www.railsinside.com/
SwitchPipe - http://switchpipe.org/

Blog

http://www.peterc.org/

http://twitter.com/peterc/

Homepage

http://www.petercooper.co.uk/

Recommended Book

Beginning Ruby is for every type of reader wanting to learn Ruby, from novice programmers to web developers to Ruby newcomers. It starts by explaining the principles behind object-oriented programming, builds toward creating a genuine Ruby application, then explains key Ruby principles, such as classes and objects; projects, modules, and libraries; and other aspects of Ruby such as database access.

---

BUY NOW

books.dzone.com/books/beginning-ruby