An Incredibly Brief Introduction to Ruby: Appendix A - Learning Rails

Sometimes a variable should hold more than just one value. It needs to contain a list, a list of lists, or even a collection where values are connected to names. Ruby supports these needs with arrays, which are simple lists, and hashes, which are collections of named data.

Arrays start out simple. While you can create arrays more programmatically with the Array object, it’s easiest to create an array by surrounding a comma-separated list of values with square brackets:

myArray = [1, 2, 'tweet']

The values can be any Ruby expression. This one happens to mix two numbers and a string. You can reference specific items by number. For example, you might redefine the index method to look like:

def index
  myArray = [1, 2, 'tweet']
  @result = myArray[2]
end

If you’ve done a lot of programming, you might not be surprised that the @result variable ends up containing tweet. Why? Because Ruby counts arrays from zero, not from one. myArray[0] is 1, myArray[1] is 2, and, of course, myArray[2] is tweet.

Sometimes you’ll want to have lists containing lists. Ruby supports this by letting you put arrays inside of arrays:

myNestedArray= [ [1, 2, 'tweet'], [3, 4, 'woof'], [5, 6, 'meow'] ]

If you wanted to reach the meow, you’d go to item 2 of the overall array, and then item 2 of the array inside of item 2, as in:

def index
  myNestedArray= [ [1, 2, 'tweet'], [3, 4, 'woof'], [5, 6, 'meow'] ]
  @result = myNestedArray[2][2]
end

Hashes are just a little more complicated. Hashes, also called maps or associative arrays, contain keys and values. Keys are effectively names that correspond to values. Within a given hash, all of the keys have to be unique. (Values can duplicate as necessary, though.) The easiest way to create a hash is with a hash literal:

myHash={ 'one' => 1, 'two' => 2, 'three' => 'tweet' }

To retrieve items from the hash, just call for them by name, as in:

def index
 myHash={ 'one' => 1, 'two' => 2, 'three' => 'tweet' }
    @result = myHash['two']
  end

In this case, @result will contain 2, as that corresponds to the name two. As with arrays, you can also create hashes through the Hash object and its methods.

Both the key and the value can have any type: you can use numbers, or strings, or, as Rails often does, especially in method calls, symbols.

Rails uses symbols—names preceded by a colon, like :courses or :students—practically everywhere. They get used like variables, to refer to models. They get used as labels for options in method calls. When you’re first starting out in Rails, your best option is to study the examples and see where symbols are used and where other kinds of variables are used. Then, just follow the established pattern.

Why does Rails use symbols? The short answer is efficiency. Ruby handles symbols with less processing than strings. The long answer is a lot more complicated than that, involving the metaprogramming glue that holds the framework together. When you’re ready to extend the Rails framework yourself, you’ll need to learn the details. Until then, you don’t need a deep understanding.

Because of the way Rails routing works, the addThem method is currently exposed to the public—though there isn’t a view for it, it won’t get useful arguments, and so on. Fortunately, Ruby offers a way to hide such methods from public view while keeping them accessible to other methods in the same class. Just add the keyword private before addThem is defined:

class TestbedController < ApplicationController
  def index
    @result = addThem (1, 2)
 end

 private

 def addThem (firstNumber, secondNumber)
  return firstNumber + secondNumber
 end
end

Methods that follow the private are still available to the other methods in the class, but can no longer be called from outside of it.

The methods explicitly listed in the TestbedController class are only a subset of the methods the class actually contains, because of the opening declaration:

class TestbedController < ApplicationController

All of the methods that are defined in ApplicationController will also be available in TestbedController. If you want some different behavior in TestbedController, you can override methods—defining new methods with the same name and arguments.

Chapter 8, Improving Formsshows how overriding methods can work, but there’s frequently one small problem. As often as not, the new method wants to do what the old method did, plus something additional. For example, this was a method overriding the text_field method from ActionView::Helpers::FormBuilder:

class TidyFormBuilder < ActionView::Helpers::FormBuilder
....
def text_field(method, options={})
    label_for(method, options) + super(method, options)
end

The text_field method here wants to create a label, and then call the original method that it was overriding. The call to super isn’t to a method called super—it’s to the text_field method specified in the ActionView::Helpers::FormBuilder class. This is a common technique when you need to tweak the functionality the framework provides.

While you probably won’t be writing methods as sophisticated as the ones in the Rails framework itself for a little while, there are a few techniques you should understand for calling those methods.

The first, simpler one, is Rails’ frequent use of methods that take an options hash as an argument. While reading the Rails API documentation, you might encounter something like:

text_field_tag(name, value = nil, options = {})

The method name is text_field_tag, and it takes a name argument and a value argument which has a default value of nil. But what is options = {}, especially since most calls to text_field_tag don’t even use { and }?

options = {} provides a way for methods to accept named parameters, taking hash with named values specified elsewhere in the documentation. In a more formal world, the named parameters would form a hash literal inside of { and }, but Ruby doesn’t require that level of formality. You could write:

text_field_tag 'Name', 'Jim', {:maxlength => 15, :disabled => true}

But more typically you’ll see:

text_field_tag 'Name', 'Jim', :maxlength => 15, :disabled => true

In general, named parameters go at the end of the method call, and the curly braces are optional. There are times, however, when the braces are necessary, as noted in the section called “Creating Checkboxes” ” section in Chapter 6, Presenting Models with Forms.

The second, harder one, is Rails’ use of methods that take an unnamed block of code as an argument. This happens frequently with the helper methods listed in Appendix D, A Catalog of Helper Methods, as well as in the migration code explored in Chapter 10, Managing Databases with Migrations, but it’s a pattern that can appear anywhere. Sometimes, as in the layout issues discussed in Chapter 2, Rails on the Web, the block-passing is just a quiet part of the framework, and you only notice it because of a yield call.

The key to recognizing a method that takes a block as an argument is the &proc or pair of curly braces at the end of the list of arguments, and examples that show the method wrapping around other code, usually with do. The typical form looks pretty similar, whether in straight Ruby code or in ERb view markup. For example, create_table in a migration looks like:

create_table :awards do |t|
    t.string :name
    t.integer :year
    t.integer :student_id
end

A form_for call, meanwhile, looks like:

<% form_for([@student, @award]) do |f| %>
  <%= f.error_messages %>
  <p>
    <%= f.label :name %><br />
    <%= f.text_field :name %>
  </p>
  <p>
    <%= f.label :year %><br />
    <%= f.text_field :year %>
  </p>
  <p><%= f.submit "Create" %></p>
<% end %>

Each of these calls does something when it is first called. create_table orders the creation of a database table, while form_for creates an HTML form element. They don’t just complete and disappear, however—they create a context, using do, that applies until the end statement. The t variable and the f variable provide information that makes it possible for the calls inside of the do to be much shorter (and much less repetitive) than would otherwise be necessary.

Rails uses blocks for other purposes as well. Chapter 2, Rails on the Web explains how the yield statement lets a method execute code passed to it as a block when it seems convenient, and Appendix D, A Catalog of Helper Methods lists some helper methods (notably benchmark and cache) that use blocks for their own purposes.

The while and until methods let you create loops that run until the specified condition is true (while) or false (until). Both of these take a do...end block that will be run until the loop decides to stop. A simple example that demonstrates this is counting. With while, counting from 1 to 10 might look like:

def index
  count=1
  @result =' '
  while count <= 10 do
    @result = @result + count.to_s + " "
    count= count + 1
  end
end

The first time through the loop, count starts out with a value of one, and the condition count <= 10 evaluates to true, so Ruby proceeds into the loop. The string value of count gets tacked onto the end of @result, with a space for clarity, and then the value of count is increased by one. When the end corresponding to the do is reached, the loop goes back to its start at while and evaluates the condition. If the condition is still true, it goes through the loop again; if not, it ends the loop and goes forward. In this case it hits the end at the end of the index method, and we’re done. The view reports @result, which is “1 2 3 4 5 6 7 8 9 10.”

You could write the same thing with until, except that the condition would be reversed:

def index
  count=1
  @result =' '
  until count > 10 do
    @result = @result + count.to_s + " "
    count= count + 1
  end
end

You will doubtless have more exciting conditions than incrementing variables, but remember: Rails can do many things for you, but it won’t protect you from an infinite loop. If your conditions aren’t met (or refused for until), your code will go on and on until you halt it or it runs out of resources. Always make sure that the loop will come to a halt by itself, no matter what you feed it.

If you know how many times you want something to go around in a loop, you can use the times method on any numeric variable. times takes a block, marked with {}, which it will run that many times. For example:

def index
  count=3
  @result =''
  count.times {
    @result = @result + "count "
  }
end

will produce "count count count" as the loop goes around three times.

A for loop takes a variable and a collection. In its simplest counting approach, the collection is a range, specified with a starting value, then two periods (..), and then an end value. The variable will be set to a value from the range as the loop proceeds, and will advance one step every time the loop hits end until it’s done:

def index
  count=13
  @result =' '
  for i in 1..count
    @result = @result + i.to_s + " "
  end
end

Of course, like most things Ruby, the for loop has greater powers than just this. You can use it to iterate over an array:

def index
my_array= [5, 4, 3, 2, 1]
@result =' '
  for i in myArray
    @result = @result + i.to_s + " "
  end
end

The loop will go through the array to produce “5 4 3 2 1.” You can do even fancier things with hashes, extracting both the key and the value:

def index
my_hash= { 'one' => 1, 'two' => 2, 'three' => 3, 'four' => 4 }
@result =' '
  for key,value in my_hash
   @result = @result + "key: " + key + " - value: " + value.to_s + "<br />"
  end
end

As always, don’t expect the hash to be reported in any given order. Ruby reserves the right to present hashes however it wants. You’ll see a result something like:

key: three - value: 3
key: two - value: 2
key: one - value: 1
key: four - value: 4

These are a few of the simpler ways to use loops in Ruby. There’s much more to explore.