Welcome to Ruby

To get started you're going to need some basics. I'm going to assume here that you have a copy of Ruby, a terminal, and a text editor of some description. You'll need access to irb, the interactive ruby interpreter.

The following things need to be true:

1. You can get up a command line or terminal of some description, ideally bash or similar.
2. If you type ruby at the command line, this needs to work and not throw an error
3. If you type irb at a command line, this too needs to work (type exit to get back out again)

If these things are not all true for you, please see me.

Hello IRB

IRB is the interactive ruby interpreter. If you have access to a command line and a copy of Ruby, you will have IRB. It's a testbed. It lets you try ideas out quickly. Here we're going to use it to write our first Ruby program.

At a command line, type

to enter interactive Ruby. Got it up? Good. Now type:

Now press enter. See what you did there? Puts stands for put string. It just appends a string to the current output stream, which here is the terminal. Notice as well what you didn't do. You typed no semi-colons and no braces.

Now lets go a step further

In IRB, type:

See what happened? Multiplication works on strings. This might seem odd at first, but it's actually consistent with the way that Ruby treats operators as methods. We'll come to this later.

IRB is tremendously useful for trying things out. Because Ruby is so expressive, you can do a huge amount just on one line. Ruby loves it when you write clean, concise, and above all, expressive code, and IRB can help you do this. You can tackle many of the exercises in this book using IRB.

Variables and Constants

Let's talk about Variables. I'll assume here that you know what a variable is. Compared to some languages, Ruby is very free and easy about variables, it cuts you a lot of slack and assumes for the most part that you know what you are doing.

Variables are duck typed

Variables in Ruby are duck typed. If the contents of a variable can quack like a duck, it will be allowed to swim on the pond. The interpreter will not do any type checking for you in advance. This might upset people coming from a .Net, C++ or Java background, and it's one of the reasons Ruby is suited to small teams of crack developers, since you can't enforce an interface, and can't easily prevent people from passing silly parameters to your methods.

You just have to trust to your basic intelligence. Scary?

It's also one of the reasons that Ruby is so fabulously productive, since you don't need to interact with the type system. Polymorphism is assumed. You don't need to do any work to enable it. Productivity wise, this is an enormous win, provided you can trust yourself and your co-workers.

Declaring variables

Variables come into existence when they are first declared. There is no need to define them.

For example:

This is pretty sensible. A variable can hold anything you like, and the same variable can be re-purposed to hold something else entirely:

A little best practice: naming conventions

There are naming conventions governing variable names in Ruby. These conventions are not enforced, but you should stick by them if you want people to like you, since Ruby is case sensitive.

Variable names

Variable names always start with a lower case letter. By convention they are all lower case with optional underscores (snake case) eg:

Constants

Constants start with an upper case letter and by convention are CAPITALISED_SNAKE_CASE:

Note that constants are not actually constant, you can redefine them if you really, really need to. You'll get a warning, but it won't break. Ruby is like this, it assumes you're clever. Yes, Ruby is a language that gives you the respect you DESERVE.

Clever Tricks

There are lots of little tricks you can do with variables that are useful, and can help a lot when trying to appear clever.

Assignment chaining

Assignments can be chained saving typing eg:

This works because the output of the assignment is the value that is being defined, so the output of z = 4 is 4.

Parallel assignment

Ruby also supports parallel assignment allowing you to assign multiple different variables on one line, eg:

You can exploit this to swap the values of two variables in one line:

Integers (Fixnums)

Everything in Ruby is an object including integers, or Fixnums as they are known in Ruby. Integers therefore have methods.

Basic Maths

You can do all the maths you would like with integers. It all works as you would expect:

You also have the common maths shortcuts you find in other languages. Again, these work as you would expect:

Use ** for exponentiation should you feel that way inclined:

Looping with Integers

Remember how everything in Ruby is an object? This lets us do some reasonably clever things. For example, we can it to perform looping, like so:

This might look strange. The little bit of code between the curly brackets {puts "hello"} is called a block. A block is an inline function. We are actually passing this block (or function) to the Fixnum times method, which is then executing it 5 times. This may seem a little odd at first, but it's actually really rather good and will soon become second nature, as we shall see when we reach the section on blocks.

Comparison

As you would expect, greater than or less than signs to do comparison. == tests for equality.

The Spaceship Operator

A tremendously useful one this, the spaceship operator returns 1, 0 or-1 depending on whether the first operand is larger, the same as or smaller than the second. This is excellent, as this type of comparison forms the basis of all known sorting algorithms.

To make any class sortable, all you need to do is to implement the spaceship operator on it. Telling a custom class how to respond to an operator is called operator overloading. More on operator overloading later.

4 <=> 3
  => 1

4 <=> 4
  => 0

2 <=> 10
  => -1

Large integers

Underscores can be included in integers to make them more legible. We don’t do this often, but it’s a fun trick to know:

Floats

Ruby also has floating point numbers. Floats are useful for dealing with very large numbers, or high precision numbers.

Declare a float just by including a decimal point, like so:

You can convert integers to floats using the to_f method like so:

Integers are not implicitly converted to floats, so:

rather than 1.5

However, if one of the operands is already a float, the output will be a float so:

Infinity

Floats have the rather handy ability of extending to infinity, like so:

If you need to say that something, say a stack, can contain an unlimited number of values, you might find a use for infinity.

Strings

Ruby has an unusually rich and detailed String manipulation toolkit. String creation is similar to other languages

You are free to use single or double quotes around your string.

Strings are Objects

Strings are real objects and have methods:

String Literals are allowed

As you might expect, you can create strings, and call methods on them directly.

Embedding Variables right in Strings

Use double quotes and the #{} syntax if you want Ruby to look for variables embedded in a string:

Nice, simple, inline, readable.

Escaping with \

You can include escape characters in your string with a backslash:

String concatenation

Add two strings together using simple arithmetic:

More likely you will want to do a join on an array, something more like this:

Conversion to other types

Strings can be converted to lots of other types using the casting methods. There are lots of these built in, but feel free to write your own as well. The "to_i" method converts to an integer.

Conversion from other types

Strings can be created from any other type using the to_s method. For example, if you have an integer, and you need it to be a string, do it like this:

Functions

Functions are declared using the def keyword:

Accepting parameters

Functions can accept parameters as you would expect. We pass them like this:

Optional braces

When calling a function, the braces are optional.

This is a really nice syntax, and comes into it's own when we start writing methods.

Returning a Value

Functions can return a value. We pass back a value using the return statement, like so:

get_greeting_for "dave" evaluates to the string "hello dave". This string is received by puts, which then outputs it to the screen.

Optional return statements

The return statement is also optional. If it's omitted the function will return the last evaluated expression, so:

This is a clean and useful syntax for short methods such as getters.

Default Values

We can set the default value of an argument, so if no value is passed, our function will still work:

Note that if we have several arguments, and some are missing, they will be filled in from left to right, so the last ones will take their default values.

Upshot

• Functions in Ruby are created using the def keyword (short for define).
• Functions that exist in an object are typically called methods.
• Functions and methods are the same, except one belongs to an object.
• Objects are created from classes using the .new method

Flow Control

Ruby loves it when you tell it what to do.

if/elsif/else/end

If statements are present. They work as you'd expect. Notice that no braces are required.

unless

The unless keyword is the opposite of the if keyword. It's equivalent to !if (not if). It can make your code more readable.

Statement Modifiers

Ruby loves it when you write things concisely. The if and unless keywords can also be placed after the line of code you may or may not want to execute. When used in this way they are called statement modifiers:

The Ternary operator

Like most languages Ruby includes a ternary operator. It works as you'd expect. If the first portion evaluates to true the first result is given, otherwise the second result is given:

This is equivalent to:

Booleans, Logic, nil and undefined

Booleans in Ruby are logical and clear

What counts as false?

Only Nil and False are false in Ruby. If it exists it's true. That includes zeros, empty strings, etc. This is because 0 is an object in Ruby, as is the empty string ""

We can test this with a short function, that determines if the parameter evaluates to true or false, like so:

A variable is nil if the variable has been declared but doesn't point to anything (remember Ruby is fully object oriented so all variables are pointers to objects)

Nil

A variable is nil if it has been declared, but holds no value. Nil exists as a type, and has methods. For example:

Nil is a very useful thing to be able to return. It means "no value".

Undefined

A variable is undefined if it has not been declared. You can test for this using the defined? operator.

Boolean Algebra

You can do all the standard things using Boolean algebra.

are all supported.

Special uses for logical OR ||

There are useful things that can be done with the OR || command. The second part is only evaluated if the first part returns false (nil or false evaluate to false), and the return value is the last value calculated. Rails exploits this letting you do neat things like this:

Here we have a default value. If name is nil, anonymous coward will be used instead.

Case Statements

Of course Ruby also has case statements. You almost never see these in the wild as case statements are a bit, well, 1990s, but if you should decide you need one, here's how they work.

A case statement will break automatically if you hit a matching term, you don't need to tell it to break as with some other languages.

Blocks Rock

A Block is an unnamed function, a lambda, which is received by a function, and which can tell it what to do.

Blocks are where the fun really starts. A block in Ruby is a sort of unnamed function that can be passed to a method using a special syntax. It can be as long or as complicated as we like, and can span many lines. Here's a simple example:

The block here is the bit of code: puts "Ruby Ruby". This piece of code is passed to the times method. We use blocks for everything in Ruby, most notably when looping, but in plenty of other ways too. Come with me now as we enter the world of loops…

Why is this cool?

This is super great because it means that the number 5 knows in itself how to iterate up to itself. We have perfect encapsulation. We don't need a for loop. We don't need to make any assumptions about implementation. It's all hidden under the surface.

Passing parameters to a block

We can have our function pass parameters to it's block. We do this using the | | "chute" syntax. For example:

Here the times method passes a number to the block, which is available in the variable i. This is one of the many ways in which we do iteration in Ruby.

Blocks are better than loops

One of the most common and programmer friendly applications of blocks is in looping. Many objects, most notably, Arrays and Hashes will accept a block then apply that block to each of their members in turn. All the looping code is encapsulated, meaning we don't need to worry about the internal structure of the array.

As we saw earlier, the Fixnum.times method works in a similar way:

If we wanted to iterate over some specific numbers, we might use the upto method to create an Enumerable object, and then iterate over that. Observe:

We could also iterate over a Range object. more on Ranges shortly:

The most common use of a loop, iterating over an array is totally covered, and in fact, when writing Ruby code, we almost never write the sort of looping constructs you might be used to. Blocks have them covered

each_with_index

If for some reason we need t get the index of an array, we can do this too using Array.each_with_index.

This method accepts a block with two parameters, the value and an index. We can use it like so:

Short and Curlies

We can declare a block in two ways. We can use the curly braces syntax, or the do/end syntax.

The difference between them is that the curly braces syntax can only take a single line of code, whereas the do/end syntax can take as much code as you like, even an entire web page template if needed.

Here is an example of the curly braces syntax:

And here is an example of the do/end syntax. Notice the code is more spread out. This is more readable for large blocks of code.

RSpec

There are many test harnesses for Ruby. RSpec is the most popular. It has inspired many imitators such as Jasmine for JavaScript and PHPSpec for PHP.

Getting RSpec

Install rspec using

or if you prefer add it to your Gemfile and bundle.

You now have a new terminal command, rspec. Type:

in a terminal to test your installation.

Writing a spec

RSpec is very easy to setup. Create a folder called spec in the same directory as your code. This is where your specs will live.

In the spec folder create a file called test_spec.rb. Place the following code in it:

run your specs with:

You should see a message like this, telling you the specs have passed:

Testing some actual code

Let's write an alarm clock function to wake us up in the morning. When we call it it's going to give us a message: "Beep beep beep". This will help us wake up.

Save this in a file called clock.rb

Now let's write a spec for it. First we need to import our clock, then we call the code, then we say what the result should be:

Run this and verify it works

Test First

This is all well and good, but what about Test Driven Development (TDD). In this methodology we write the test first, watch it fail, then write code to make it pass.

Some-days I feel sleepy and I'd like to be woken with more force. I'd like my alarm clock to accept an optional parameter and wake me up more strongly.

First we write the spec

Now we run the spec and we see red:

Notice it's telling us exactly what and where the problem is. Let's write code to make our test pass.

Run the test again and success, we have a passing test.

Many developers say they live for these moments of green. You may or may not love testing as much as this but regardless, a good suite of passing tests can give you piece of mind at the weekend and help you sleep better at night, knowing you have done a good job.

Arrays

Like most languages Ruby allows you to create Arrays to hold multiple values. Arrays in Ruby are one dimensional, though you can declare an array of arrays if you feel the need.

Creating Arrays

Create an array using square brackets like so:

Access an array using square brackets:

Zero Indexed

Arrays are zero indexed, so 0 is the first element.

Polymorphic

As you might expect from Ruby, arrays can hold any type of element. This is allowed:

Manipulating arrays

Arrays can be manipulated in a huge variety of ways For example:

Adding

Subtracting

Appending

Multiplication

Handy dandy array API

There are also a raft of array methods we can use, such as:

You might notice here that this method name has a question mark in it? This is a Ruby convention. Methods with a question mark return true or false.

Array splitting

Parallel assignment works when pulling values out of a array.

We can also pull the first element, and return the rest of the array should we wish to:

This is a clever trick to know as it impresses people and make you look brainy.

Creating an array using the to_a method

The to_a method allows many objects to be converted to arrays. For example an array can be created from a range as follows

Ranges

Ranges are useful objects that can be used to represent a sequence. Ranges are defined using the .. or … syntax. For example:

represents the sequence of numbers between 1 and 10.

represents a range that excludes the high value. In this case the numbers 1 to 9

Ranges in Memory

Ranges are compact. Every value in the range is not held in memory, so for example the range:

…takes up the same amount of memory as the range:

Conversion to arrays

Ranges can be converted to arrays using to_a like so

Note we need to put braces around the range here to disambiguate the dots.

Character Arrays

We can also declare arrays of characters like this:

Testing if a range contains a value.

We can use the equality === operator to test if a range contains a value. For example:

Sorting an Array Using a Block

By default array.sort will sort any array of values using the <=> spaceship method of the value. This method as we have seen returns -1, 0 or 1 depending on whether the value is lower, equivalent or greater than another value. The String class implements the <=> method by comparing the two values alphabetically, so by default array.sort sorts an array of strings alphabetically like so:

If we want to override this, there are two easy ways to do it. First we can override the spaceship operator (coming soon). Alternately, we can pass Array.sort a block which can be used instead. For example the following code sorts an array in order of the second letter:

Nice and Simple.

Modifying each element of an array with map

Map is an insanely useful array function that lets you modify each element of an array using a block.

Say you have an array of strings:

Lets say you want to convert this to an array of symbols, you could do something like

Hashes and Symbols

Hashes are a big deal in Ruby. We use them a lot, particularly when passing bits of data around. Symbols are tiny lightweight Ruby placeholder objects. They are often used in conjunction with hashes. In this section we will look at hashes, symbols, and some of their common uses.

Symbols are not magic runes

Symbols often seem like magic runes to Ruby newcomers. In fact they’re just little objects that have some special features and syntax surrounding them to make them a little easier to use and a little lighter on the computers memory.

Symbol syntax

Symbols are defined using the colon operator or the to_sym method:

Features of Symbols

• Symbols are tiny little objects
• Symbols don’t have a value, they are placeholders, not variables.
• There can only ever be one symbol with a particular name, this is managed by Ruby. Because of this they are not processor or memory intensive.
• Symbols can potentially represent a memory leak if you create a lot of them.

There can only be one

A symbol will only exist once in memory, no matter how many times it is used. If for example, you create two symbols in different places both called :name for example, only one object would be created. This object would persist for as long as the Ruby interpreter was running.

Uses of Symbols

Symbols are most commonly used as placeholders in Hashes. We have used symbols already in Rails, for example the Rails params hash associates any the values of any parameters passed in by the user (from a form or in the url) with a symbol representing the name of that value.

Hashes

Hashes are objects that associate lists of arbitrary objects with each other. For example:

Hash Assignment Shorthand

Setting Default Values in a Hash

A hash will return nil if it can't find any matching keys. You can set a default value that a hash will return in this instance should you so desire.

You can also set this value using the Hash.default method

Any Objects can be used as a key

Any Object can be used as a key. Here we use the number 45 as a key, and store the root directory of the local file system as a value:

Functions that receive a Hash

A function can receive a hash of values. This is tremendously useful, and we do this all the time.

Here our function receives a parameter we've called args. The default value of the args parameter is an empty hash. Any key value pairs we pass will go into args, and can be pulled out.

On the second line we do this:

Here we set the value of name to be either the value stored in args under the :name key, or if this evaluates to nil (and therefore false) we set it to anonymous. This is tremendously useful, since we can create functions that accept multiple arguments, in any order, with any defaults that make sense.

You should get used to writing configurable, extensible methods that receive a hash. This is a real rubyism.

Review

• Symbols are singleton strings. They are very lightweight, and can be used anywhere you need a unique object, such as in a hash.
• Hashes are dictionary objects, sometimes called hash tables. They associate keys with values.
• You can use any object as a key, and store any object as a value.
• We commonly use symbols as keys in hashes
• A special syntax exists which lets us pass a hash to a function.

Classes and Objects

Ruby is Object Oriented. Many languages claim to be object oriented, but most fall short in some area or another. When Ruby says it's object oriented, it really, really means it.

We have used lots of Ruby objects so far, when we have done things like:

and

Lets look now at how we can define our own objects.

Classes

Ruby has a class based object model. This means we define classes, then use them to stamp out as many objects as we like. Of course, this being Ruby, classes are objects and have methods in their own right, but we'll get to this soon enough.

We define a class like so:

Here we have defined a very simple class, called Pet. By convention, classes in Ruby always start with a capital letter. Now lets create a pet:

This is great, we have created a new instance of the Pet class. Flopsy is an instance of Pet.

Note that all objects get a new method for free. This they inherit from the Object superclass. More on inheritance in a bit.

Finding the class of an object

We can go in reverse, to find the class of an instance like this

Ruby doesn't shy away from introspection, it comes baked in, as we shall see later.

Methods - Giving Flopsy Abilities

This is all very nice, but flopsy is not very interesting, she can't walk the tightrope or play chess, or really do anything much. To make Flopsy more interesting, we need a method:

Here see now. We have added a play chess method to flopsy. We can now write:

…and she will, after a fashion. She is only a housepet after all.

Naming Conventions

There are a few things to bear in mind when naming methods in Ruby if you want to appear cool and down with the kids.

First, use snake case for all function names, like this.

Second, if your method returns a boolean, and is a question, frame it as such. Use a question mark, like so:

Third, if your method modifies the original object in place, rather than returning a new object, and is therefore destructive, indicate this with an exclamation mark, like so:

Instance variables - Giving flopsy some superpowers

Flopsy is still a little dull. It would be great to be able to store some data about her, maybe give her some custom attributes.

In Ruby we save an instance variable using the @ syntax. Instance variables are @ variables. All instance variables are private, so to get at them, we need to write methods called getters and setters to access them. Lets have a look now:

Here we have given flopsy two methods, a getter and a setter. The first is a setter. The super_powers= method receives a parameter and stores it in an instance variable called @super_powers.

The second is a getter. It simply returns the @super_powers instance variable that was previously set.

We can now set flopsy's super power like this:

and retrieve it like this:

Note we don't have to declare the @super_powers variable anywhere. We can just set it, and that's fine.

This is great because…

Getters and setters give us a clean way to provide an interface onto our object. It insulates us from implementation details. We are free to store the data in any way we wish, as a variable, as a file, in a database, in an encrypted hash, or as a combination of other variables.

This is how active record works when using Rails. Values can be got from the database as though we were accessing object attributes.

Just like Flopsy, the boundary between attributes and methods is far more fuzzy than in most languages. This is partly because of Ruby's optional parentheses, which make it look as though we are accessing attributes, when in fact we are always accessing methods.

We can have read only attributes by only creating a getter, and write only attributes by only creating a setter. An example of a write only attribute would be a password, which might get set, and then encrypted with a one way hash, never to be read again.

The attr method

Since class variables are so common, ruby defines shortcuts for creating them and their associated getters and setters. The attr method creates an attribute and its associated getter. If the second parameter is true a setter is created too. The attr_reader and attr_writer methods create getters and setters independently.

Initialising flopsy using the initialize method.

The initialize method is called by the new method and it is here that we put any code we need to initialize the object.

When flopsy's sidekick mopsy was first created, she didn't have any powers at all, observe:

Poor mopsy. We can remedy this situation by giving mopsy a basic superpower when she is initialised. Lets do this now.

Now when we recreate mopsy, she comes already tooled up

We can also do this:

If you need to see a list of all mopsy's attributes you can do so using inspect like so:

Upshot

• Functions in Ruby are created using the def keyword (short for define).
• Functions that exist in an object are typically called methods.
• Functions and methods are the same, except one belongs to an object.
• Objects are created from classes using the .new method

Monkey Patching for Great Justice

Because Ruby is an interpreted language objects are open and can be modified at runtime. Classes can be reopened at any time.

We can give mopsy new methods, even after she has already been created. Observe:

Mopsy can still play chess. The Pet class was added to, not overwritten

Modifying an Existing Class

As we've mentioned before existing classes can be extended. This includes built in Ruby classes. This is a feature that can be used both for good, and for evil:

For good

For Evil

Yes, Ruby lets you do this. Be careful and do things and your code will read like liquid sunlight.

Monkey Patching

Reopening code in this way is often known as monkey patching. We can modify or extend any existing class at runtime, even built in classes like strings and arrays. This can be used to great effect, for example Rails Fixnum date extensions, which allow you to type things like:

Here Fixnum has been monkey patched with an function that allows it to work with dates and times. This is a nice syntax, although it makes some people cross as it appears to break encapsulation.

Monkey patching is fun, but use it with care, otherwise you'll end up with a twisted mess on the floor.

Metaprogramming

Monkey patching is the first step towards meta-programming - writing code which writes code. More on this soon.

Operator Overloading

Did I mention that in Ruby everything is an object? This extends to operators, such as +, -, * and /. Operators in Ruby are actually methods, and we can define and redefine them, like so:

Here we have defined a plus method that receives another pet. This simply creates a new pet with the combined superpowers of it's two parents and returns it. Observe the offspring of Mopsy and Flopsy:

Inheritance

Rails supports single object inheritance. This means a class can have one parent class and will inherit all the methods and attributes belonging to that class. We define inheritance relationships using the < operator.

For example, let's say we'd like to define a particular type of pet, say a small and fluffy kitten. Let's create a kitten class that can inherit from our Pet class:

Our kitten now has all the attributes of a pet. It can shoot fire from it's eyes, and play some good chess, but in addition it can also play tennis:

Eigenclasses (Static Methods)

In Ruby, all methods exist within a class. When you create an object, the methods for that object exist within it's class. Methods can be public, private or protected, but there is no concept of a static method. Instead, we have singleton classes, commonly referred to as eigenclasses.

No static methods

Static methods are class methods. they belong to the class, not the instance. This would break Ruby's simple object structure, since classes are instances of class Class, adding methods to Class, would make them available everywhere, which is not what we want.

Singletons

Instead, Ruby lets us define an unnamed singleton class that sits in the inheritance tree directly above any object. Lets do this now and create a static method.

The class « Kitten syntax opens up the eigenclass and pops the max_size method within it. We can then access it like this

Notice that we are talking to the Kitten class as an object here.

Shorthand

We use the class « self syntax to explicitly open an object's eigenclass. We can accomplish the same thing using the shorthand syntax:

This adds a method to the Kitten eigenclass. We can also add a method to the eigenclass of any other object, like so:

Here we have added a method to popsy's eigenclass, allowing her to deploy wheels.

Eigenclasses in the Inheritance Hierarchy

The eigenclass sits directly above the object in the inheritance hierarcy, below the class of the object. It provides a handy place to put methods hat we want to apply directly to the object, rather than to every instance of that object. It feels technical, but once you get it, it's actually rather nice.

Modules (Mixins)

Modules can be used to add reusable functionality to a class. They are sometimes known as Mixins. A module consists of a whole bunch of methods. By importing it into a class, we gain access to all those methods. This is a handy way to get around the restrictions of single object inheritance, since we may import as many modules as we like.

Defining Shared Functionality

Lets teach flopsy how to make an omelette. Then she will be able to help out in the kitchen. It would be nice if our omelette could accept a few options, so lets allow that too.

Now include the mixin in the Pet class.

All our pets can now make delicious omelettes. Observe:

Module Inheritance

Including a mixin in a class adds those methods to that class as though they had been defined within that class.

Methods added to a class by a module are inherited by subclasses of that class. For example, by including the CookOmelette mixin in the Pet class the Kitten subclass and all its instances also gain that method.

Extend vs. Include

Include and Extend allow us to take methods from a module and add them to an object. They work slightly differently from each other though. Let's take a look...

Extend adds methods directly to an object

Extend adds methods to an object. It extends that object by adding new features to it.

If you extend a class, you create a class method.

If you extend an instance of a class, you create an instance method, but only on that instance. You can extend any object like this.

You can call extend on any object to add methods to that object alone.

Include adds instance methods to a class

Include takes a more traditional approach. If you include a module in a class, the methods in the module will be added as instance methods, and will be available to all instances of that class.

Upshot

Extend will add methods to an object, and only to that object. If we extend a class we get class methods.

Include will include methods from a module into a class, those methods become instance methods for objects of that type.

Exception Handling

Exception handling in Ruby is very similar to other languages.

Raising an Exception

Raising an exception in Ruby is trivially easy. We use raise.

This will raise the default RuntimeException.

Raising a Specific Exception

We can also raise a specific type of exception:

Rescuing Exceptions

We can rescue exceptions easily. Put the code that might raise an exception in a begin, rescue end block. If an exception occurs, control will be passed to the rescue section.

Rescuing Specific Exceptions

We can rescue different types of exceptions

The Ruby Exception Hierarchy

Here are the built in exceptions available in Ruby:

Defining Your Own Exception

You can define your own exceptions like so:

You can then raise your new exception as you see fit.

Writing methods which accept blocks

So how does a method yield control to a block? Well, we use a keyword called yield. For example, the following (very simple and not terribly useful) function accepts a block of code and then simply runs it once:

You can call yield as many times as you like. This is how the Array.each method works, by iterating over the array and calling yield for each item, passing the item as a parameter. Here's a silly example:

Passing Parameters to a Block

A block is an unnamed function and you can easily pass parameters to it. The following example accepts an array of names and for each one sends a greeting to the block. The block in this case just puts the greeting to the screen.

Upshot

We can tell our function to receive a block in two ways:

1. Explicitly, by simply receiving a block parameter
2. Implicitly, by calling yield within our block

We can check if a block was passed in using the block_given? method.

Re-implement the Fixnum#times method Exercises

This calls the block a specified number of times. It allows you to write code like this:

Recreate this method in your own words.

Extend it so you can call it like this:

Re-implement the Array#each_with_index method.

This method calls its block once for each element in an array. You call it like this:

Further Exercise - Real world block code

Check out the Rails link_to method. Like many helpers it receives an optional block.

Read through the codebase and see if you can see how it does it:

https://github.com/rails/rails/blob/433ad334fa46623f4b218d3bb34e3f63d5481c18/actionview/lib/action_view/helpers/url_helper.rb#L135

Creating a Gem

A gem is a zip file containing code, typically, though not always Ruby code, plus a little metadata to help RubyGems and Bundler to manage it nicely. Gems contain a gemspec manifest file, which contains metadata, and usually a lib directory containing the code itself.

Because a gem contains Ruby code, it can do whatever you like. It can monkeypatch Rails. It can delare new modules and classes. It can extend existing objects, etc.

A gem can be stored locally, or on a gem host like rubygems.org. If you publish your gem to rubygems it will be available for anyone to download and use. If you keep it in your project, you can still use bundler, you just provide a path.

http://asciicasts.com/episodes/245-new-gem-with-bundler

In this section we're going to create a simple gem using Bundler.

Creating a gem using Bundler

We are going to create a summarise gem which will extend the string class with methods to create a summary, and to check whether the string can be summarised, like so:

first of all create the gem:

We now have a new summarize directory containing a lib directory for code, a gemspec file for metadata, and a few other files.

We also have an empty git repository initialised for us.

Gemspec

The gemspec file is the heart of your gem, it contains all the metadata about your gem. Your generated gemspec will look something like this:

Notice how spec.files is set by getting the files currently included in git.

Also notice how the version is taken from the Summarize::VERSION constant. This is defined in lib/summarise/version.rb. The version can be updated by editing this file.

Gem Contents

We now define the gem in the lib directory.

lib/sumarise.rb

This file simply imports the rest of the code.

lib/summarise/string_extensions.rb

This declares the methods we want to add.

lib/summarise/string.rb

This extends the String class.

Building the gem

Because the gemspec uses Git to discover which files to include, we must first commit your updated files.

Build the gem using the gem build command:

You will create a file called something like: summarise-0.0.1.gem

Local Private Gems

If you want to keep your gem private, you can deploy it directly into your vendor/gems directory, like so:

First unpack it into vendor/gems:

Now declare it in your Gemfile:

Finally install it into Gemfile.lock

This is a good way to develop a gem, as you can deploy it locally and work on it in situ.

Uploading your gem to RubyGems.org

If you'd like to share your gem with the community, you can also push it to RubyGems.org

You'll need a RubyGems account:

https://rubygems.org/users/new

Now simply push the packaged gem:

Send

Send allows you to call a method identified by a symbol.

My app has classes for people and events. Each class has different attributes.

I also have a module which sets up the objects.

Define Method

We use define method to create a method on the fly given a string as a name.

Method Missing

Trying to call a method that doesn't exist in Ruby is an exception rather than a language error. We can catch it, or we can simply implement a method_missing function which will be called when no matching method is found.

Instance_Eval

We use instance eval to evaluate a block in the context of a Ruby object.

We can use this to construct a DSL (Domain specific language, like this:)