XML Reference Guide

When Jen Bortel, my boss here at Informit, first asked me to do some content on Ruby, I was thrilled. After all, I've been hearing just as much about Ruby, and Ruby on Rails, as you have. Maybe even more. I kept hearing a lot of talk about how easy it was, how productive you can be, how fast it is to develop in, and all of those things we programmers love to hear.

After stumbling around for a few days trying to get everything configured, I was beginning to wonder. Fortunately, the problem was me. If you read the right documentation, getting an application running in Ruby -- and particularly in Ruby on Rails -- is almost ridiculously easy. Before you finish this guide entry, you're going to see just how ridiculously easy it is.

This entry begins a series on developing with Ruby and with Ruby on Rails. In it, we're going to develop a simple survey application. We'll start with a commandline interface, and then move to the Web.

But first we have to answer these simple questions: what the heck is Ruby anyway? And why we're at it, what is Rails? And why is Ruby on it?

Let's start at the beginning.

Simply put, Ruby is an object-oriented language. It has its own syntax, which may or may not seem familiar to you based on what languages you're familiar with. It is designed to make programming easy. And in many ways, it does just that, though I'm a little skeptical of Ruby's claims that its syntax is much like speech. You can build all sorts of applications using Ruby. You can build commandline applications, window based applications, and even Web applications. You can run Ruby as a CGI application. You can use Ruby in an environment in which it acts much like PHP, with embedded commands on the page.

And you can and do all of that without Rails.

So why do you even need Rails? What is the big deal about it? What is it?

Rails, in my opinion, is the reason you're hearing so much about Ruby. Rails is an application framework that enables you to create Ruby applications for the Web in no time. Well, in almost no time.

It happened like this: David Heinemeier Hansson was working on a web application called Basecamp. Basecamp is a project management application, but the important thing is that Hansson decided that there were certain things that he had to do over and over again that had nothing to do with the actual application. For example, accessing the database. Or finding a particular object. Or creating a Web form where people could enter information.

So he did what many of us have done in the same situation; he created a framework that did a lot of the "heavy lifting" for us. The difference is that this framework is for Ruby applications, and it's now publicly available. That framework became Rails.

To sum up so far, Ruby is a new programming language, and Rails is a particular kind of application written in Ruby.

For the rest of this entry, I'm going to show you how easy it can be to get a Rails application up and running. I'll be giving specific instructions for Windows, but the Linux instructions are basically the same. (Also, I'll be ducking the whole web server issue by using the development HTTP server that comes with Rails.)

The basic process looks like this:

1. Install Ruby.
2. Install Rails.
3. Create the database tables.
4. Have Rails create the skeleton web application.
5. Start the web server
6. Configure the web application.
7. Add the code.

Installation

Let's start with installation:

1. First, you'll need to install Ruby, and Rails. Download Ruby for Windows or other platforms. (Check the Ruby Home Page for the most recent version.)
2. If you're installing on Windows, and you've downloaded the one click installer, run the installer to complete the installation. If you're installing from source, follow the directions with your distribution.
3. Download RubyGems. This is the Ruby package manager. Unpack it into your Ruby directory.
4. Install Rails by executing the following command from the commandline:

   gem install rails

   You will need to be online for this to work. Accept all of the dependencies.

Create the database

Now that you've got everything installed, let's talk about the application we're going to ultimately build. It's a simple survey application, with the ability to add new polls, each of which has one or more questions, each of which has one or more answers. We'll look at multiple ways to store this information, but for right now, we're going to use a database.

Ruby works with multiple databases, but for our purposes, we're going to use MySQL. (If you haven't already got it installed, download it from http://www.mysql.com/.) Log into the interactive console and create the following objects:

create database surveysays;

create table surveys (
   `id` INT NOT NULL AUTO_INCREMENT ,
  `title` VARCHAR( 100 ) NOT NULL ,
  PRIMARY KEY ( `id` )
);

Ultimately, we'll have tables for the questions, answers, and results, but for now, we'll use only the surveys table to keep things simple.

Create the web application

It is Rails that creates the actual web application, so open a command prompt window and change to the directory in which you want your web application to live. For example, I want my full path to be:

c:\Inetpub\Surveysays

so I change to the c:\Inetpub directory and type:

rails Surveysays

In just a moment or so, Rails creates the entire structure of the application.

Start the web server

To make things simple, Rails comes with a simple web server called Webbrick. You wouldn't want to run your production application with it, but depending on your platform, setting up a production web server for Rails can be a significant challenge.

To start the server, change to the Surveysays directory and type:

ruby script\server

To make sure it's working, open your browser and point it to:

http://localhost:3000

You should see a page something like this.

Configure the application

Rails will handle all of the database interaction for you, but you have to tell it where to find the database. To do that, use a text editor to edit the config\database.yml file so that the first section reads:

development:
  adapter: mysql
  database: surveysays
  host: localhost
  username: root
  password:

Make sure, of course, that the information is accurate for your installation.

Add the code

Even though we haven't added a single line of code yet, we are actually almost done. We're going to create a simple web application that lists all of the available surveys, and includes the ability to add, edit, and delete individual surveys.

Later, when we go into building a Rails application in detail, we'll talk about the Model-View-Controller pattern it uses as its architecture. For now, though, understand that we are linking the logic portion (the Controller) with the data portion (the Model).

Start by creating the Model and Controller by typing the following at the commandline from the Surveysays directory:

ruby script\generate model Survey
ruby script\generate controller survey

Using your text editor, open the Surveysays\app\controllers\survey_controller.rb file. Add the following:

class SurveyController < ApplicationController

   model :survey
   scaffold :survey

end

All we've done here is let the controller know what kind of object it is responsible for. The second line, the scaffold, provides everything we need for maintaining this data through the web. Point your browser at:

http://localhost:3000/survey/list

You should see something like:

We don't have any records yet, so of course nothing is displayed. But you can use the New Survey link to create a new one, and the subsequent links to edit or delete them. By just adding these two lines of code, we've created an application -- albeit a very simple one -- that enables us to manage this data.

Of course, this is not an application that we would ultimately release, and Ruby on Rails enables us to customize any aspect of the display or logic. This is just an example of how simple the process really is.

Next week, we'll talk about the actual application, and look at the basics of the Ruby language itself.