Specifically for ActiveRecord extensions you need a database and models definition to test your plugin, to do that you have to:

• Require ActiveRecord gem:

  require 'activerecord'
  

• Establish an ActiveRecord connection to a memory based sqlite3 database:

  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
  

• Define both setup_db and teardown_db:

  def setup_db
    ActiveRecord::Schema.define(:version => 1) do
      create_table :posts do |t|
        t.column :title, :string
        t.column :body, :text
        t.column :category_id, :integer
      end
      create_table :categories do |t|
        t.column :id, :integer
        t.column :name, :string
      end
    end
  end
  
  def teardown_db
    ActiveRecord::Base.connection.tables.each do |table|
      ActiveRecord::Base.connection.drop_table(table)
    end
  end
  

• Define your models:

  class Post < ActiveRecord::Base
    belongs_to :category
  end
  class Category < ActiveRecord::Base
    has_many :posts
  end
  

• Finally define both setup and teardown methods in your test class (Note that all the above should be placed before your test class definition):

    def setup
      setup_db
    end
  
    def teardown
      teardown_db
    end
  

That’s it, now you can write your tests as if you’re writing them in your Rails application unit tests. Check the following for more example tests:

• SimplySearchable test
• acts_as_tree test
• acts_as_versioned test

Almost a year ago I released SimplySearchable plugin to help me implement the filtering options of restate.ae and during this year I’ve been updating it regularly until it become something completely different so I did a quick rewrite, moved all the logic to the model, moved the repository to github and here it is.

SimplySearchable

The main goal of SimplySearchable is to make it easy to do queries on your model by auto-magically creating some named_scope methods for common conditions.

This plugin adds a method to the model named list that will find and filter records smartly.

Please submit your bugs, requests and feedback at the project’s page on Lighthouse. RDocs are available at http://ridaalbarazi.com/code/simply_searchable/.

Installation

  ./script/plugin install git://github.com/rbarazi/simply_searchable.git

And in your model:

  class Post < ActiveRecord::Base
    simply_searchable
  end

Then in your controller you can say:

  class PostsController < ApplicationController
    def index
    @posts = Post.list(params)
  end

Example:

If you have the following attributes in you posts table:

  Post
    id:integer
    title:string
    body:text
    category_id:integer
    created_at:datetime
    updated_at:datetime

And in your Model:

  class Post < ActiveRecord::Base
    has_many   :comments
    belongs_to :category
    simply_searchable
  end

This will create the following named scopes:

  named_scope where_id,         lambda {|value| { :conditions => ["id = ?", value] }}
  named_scope where_title,      lambda {|value| { :conditions => ["title like ?", "%#{value}%"] }}
  named_scope where_body,       lambda {|value| { :conditions => ["body like ?", "%#{value}%"] }}
  named_scope where_created_at, lambda {|value| { :conditions => ["created_at = ?", [*value]] }}
  named_scope where_updated_at, lambda {|value| { :conditions => ["updated_at = ?", [*value]] }}
  named_scope where_categories, lambda {|value| { :conditions => ["category_id in (?)", [*value]] }}
  named_scope where_comments,   lambda {|value| { :conditions => ["comments.ids in (?)", [*value]] }}

It will also create the method ‘list’ which you can use like:

  Post.list(:title => 'abc', :created_at => Date.today)

Which will return the posts that contain ‘abc’ in their title and created today.

By default SimplySearchable list will_paginate, you can still disable it:

  class Post < ActiveRecord::Base
    simply_searchable :will_paginate => false
  end

Or customize its settings:

  class Post < ActiveRecord::Base
    simply_searchable :per_page => 20
  end

In the new implementation there is no support for associations’ filtering yet, it will come very soon though so stay tuned. Association support has been implemented.

The Car and The New Record

Everything started when my father convinced me that we need another car for the family and here I mean my parents and brothers family as I don’t even have a girlfriend to have a family of my own yet. As I don’t have any car yet I loved the idea and left everything to my father to chose, test and negotiate (action 1).

Finally after few days we decided on a used Dodge Grand Caravan 1996, 7 seats, in a very good condition and loaded with full options. It was my first time EVER buying something (or pay a share in it) and getting it registered to my name WITHOUT EVEN SEEING IT (action 2).

The car was mine on September 5th, things were superb, at last I have a car of my own now and I’m very excited about it, but this happiness didn’t last longer than 48 hours… I hit the huge caravan trying to park it in a small space (action 3) and guess when?… I was going to Apple store to check Mac prices (action 4).

Naturally my day was awful, I hated myself, I made a new record, hitting my first owned car within 48 hours of buying it (or even seeing it), even the Mac prices weren’t any good for me, the Apple store here in UAE is not an authorized branch or reseller, it only resells the machines it buys from the official UK agent after customising it to support Arabic, their prices are higher than the regular Apple prices so my Mac dream is now suspended until further notice.

I quit Mac’ing for a while and to be more realistic I started looking for a decent laptop that fulfill my needs and I can afford, after doing my homework I ended up choosing HP Pavilion dv5242ea, a laptop with fairly good configurations compared to its price (around $1000) which is an exact fit to my budget.

The Big Day, Sept 11th

What do you expect from such a day, a catastrophic day in history and so it was for me, my computer crashed, my car failed me in the middle of my way to buy the new laptop. While doing the required homework to chose my laptop, my PC decided to take a nap and it started it by disconnecting every USB peripherals attached to it including my cable modem, after a little check I ended up with everything working but the keyboard (action 5, please don’t ask how).

Naturally I went to the store to buy the laptop and a keyboard, on my way to the store, just on the red signal, in the middle of a 6 lanes road, my car stopped and also (like my PC) decided to take a nap, a very long one to the level that it’s still not working to the moment of this post (action 6).

After two hours waiting for the towing recovery and another one to take the car to the garage, I arrived home at 12:00Am without a laptop or a keyboard to spend the rest of the night without any computer or internet connection just trying to understand how bad things can go.

And Finally…

I bought the laptop the next day, using a taxi this time, my car is still in the repair without knowing what’s wrong with it yet, anyways I got over it and whatever happens happens, I guess I had enough of bad luck for this month and I hope the rest 15 days will be better.

Thank you for reading my depressing story of Crazy September and sorry for the delay in my posts, I missed the Blog Club post of the Art Community, I missed two parts of the Rails Project Story, I didn’t even publish a single post for over 15 days, I will cover this up soon, starting with the third part of the RPS coming tomorrow evening (if nothing bad crossed my way).

If you remember last week we added another table in our db schema file which was the Users table, today we will talk about users in our application and how to make our application a more social one.

The options we have in order to have a user management setup for our applications are mainly three:

• Do it ourselves from zero.
• Use some decent plugin like Acts As Authenticated.
• Use a ready generator like Salted Hash Login Generator.

Before we choose between these three let’s see what are the main differences between them:

If we write our code from zero we will definitely learn more, we will have a better understanding of the whole process but at the same time we will be spending too much time on something became very regular and common in every web application and in some way we will be doing some not required extra work.

Acts As Authenticated and Salted Hash Login Generator are almost the same from some functionality point of view but the main difference is that the act is more dynamic and customizable because it is simpler, it let us take care about few things that we should really be responsible of while the generator take care about everything in some more advance way, so personally I prefer to go for Acts As Authenticated for its simplicity and core functionality that will help us understand how things work and allowing us to add some extra functionalities by ourselves.

Acts in rails are some sort of plugins and extensions to our framework extending it with few extra features, there are many great acts we will use in this application, some of them are completely independent from rails and some like Acts As Taggable became so common to the level they got packaged with rails itself.

Acts As Authenticated

It’s a simple system that helps us deal with users in our applications, it generate the required code to support user authentication and management starting from the regular MVC code ending with migration and tests.

Installation

To start with we have first to install the plugin on our system, to do this we have first to update our repositories index and then install the plugin.

D:\\Projects\\Book Swap\\bookswap>ruby script/plugin source http://svn.techno-weenie.net/projects/plugins
Added 1 repositories.

D:\\Projects\\Book Swap\\bookswap>ruby script/plugin install acts_as_authenticated
+ ./acts_as_authenticated/CHANGELOG
+ ./acts_as_authenticated/README
.
.
.
Consult the Acts As Authenticated wiki for more: http://technoweenie.stikipad.com/plugins/show/Acts+as+Authenticated

The Generator

After installing the plugin now we are able to generate all the required files, acts_as_authenticated have mainly two generators, one for the authentication system itself, the core functionalities and their corresponding model, views and controller. And the other generator is the mailer, the one responsible for sending notification and verification emails to our registered users.

To use:

  ./script/generate authenticated user account

This generates a basic user model, a controller, some basic views, and tests.

So to generate the authentication system we have first to decide the controller name to be generated and remember here that the controller is the one that normally appear in our URL (to deal with the books controller we had to call http://localhost:3000/books) so what will be the best controller name for our users? Account? Readers? Owners? Well personally I prefer to stick with the defaults and the classics, at the end these are our applications Users, and this is what we called the database table earlier so let’s stick to it and name it “users”:

D:\\Projects\\Book Swap\\bookswap >ruby script/generate authenticated user users
      exists  app/models/
      exists  app/controllers/
      exists  app/helpers/
      create  app/views/users
      exists  test/functional/
      exists  test/unit/
      create  app/models/user.rb
      create  app/controllers/users_controller.rb
      create  lib/authenticated_system.rb
      create  lib/authenticated_test_helper.rb
      create  test/functional/users_controller_test.rb
      create  app/helpers/users_helper.rb
      create  test/unit/user_test.rb
      create  test/fixtures/users.yml
      create  app/views/users/index.rhtml
      create  app/views/users/login.rhtml
      create  app/views/users/signup.rhtml
      create  db/migrate
      create  db/migrate/001_create_users.rb

If we examine the generated files we can see that acts_as_authenticated has generated for us the user model, users controller and its corresponding views, a helper, some unit and fixture tests and finally a migration file, as we have all these files generated it seems that BookSwap is ready now to have users, let’s see if this is true http://localhost:3000/users

It seems that it works, it already directed us to the signup method http://localhost:3000/users/signup, ok let’s give it a try and see what will happen (click to enlarge):

Oops, we have a problem, but at least we have some information that we can work with to understand what we have done wrong.

Fixing The Conflict

With the user friendly error page we should be able to catch what we’ve done wrong, it’s saying: “undefined local variable or method `crypted_password’ for #<User:0×39499b8>”, so basically the problem is in “crypted_password” and it is in the model User, we remember that the Model is the one that deals with the database, if you remember from our first part in the db schema definition we named the password column “salted_password”:

Error: Could not open schema.rb

So from where did this “crypted_password” come from?

Back to Migrations

Maybe it’s time to go back and check what’s inside the migration file that acts_as_authenticated generated for us and and check if it has anything realted:

Error: Could not open 001_create_users.rb

First let’s understand the migration process more, the migration is made to allow us move up and down in our application with a decent control over our database modification, in this case we can understand that acts_as_authenticated did create the migration file for us so we migrate to it.

Any migration file is separated into two parts, up and down. From the names “up” is the actions which will take place when we move forward in our migration like migrating from 4 to 5 for example, and “down” will hold the actions that will be executed when we move backward in our migrations like migrating from 6 to 5 for example.

The 001_create_users.rb migration file creates a table in its up method and drop it in its down method, the table it creates is the Users table which we already created earlier in our schema, it almost have all the columns, few more and some with different names, here we can find the mysterious “crypted_password” we saw in the error page, it’s the column we named as “salted_password”, so we found what’s wrong, now how to fix this conflict?

We have to write our own migration instead of using the default migration generated by acts_as_authenticated, we will tweak it to suit our needs. First we don’t need to create the Users table as it is already created, we don’t need to recreate the fields we have already created as well but we need the new fields required by acts_as_authenticated and sure we have to fix and rename the field salted_password into crypted_password. This will make “up” method like this:

Error: Could not open 001_create_users_up.rb

Instead of the create_table method we used some individual methods that deals with an existing table, add_column, remove_column and rename_column are simple methods that takes the table name as their first parameter and the column name as their second, only the rename_column method takes an extra parameter which is the new column name.

As this is the first migration file we have it got the 001 numbers at the beginning of its name automatically, from now on any new migration will get a serial prefix to its name that indicate its place among other migrations.

Whenever we do any changes or modifications to our database we have to support going back by defining the opposite actions in the “down” method of our migration as follows:

Error: Could not open 001_create_users_down.rb

So at the end our modified 001_create_users.rb file will end up like this:

Error: Could not open 001_create_users_new.rb

Logically we have solved the conflict error but there is still one step left which is migrating our application to the latest migration available and for now it is 001, to migrate our application we have to call the command “rake migrate”, if we called it without any parameter it will automatically migrate our database to the latest migration available, if we specified the “VERSION=X“ parameter it will migrate the application to migration X whether it is newer or older from our current migration level.

D:\\Projects\\Book Swap\\bookswap>rake migrate
(in G:/Projects/Book Swap/bookswap)
== CreateUsers: migrating =====================================================
-- rename_column(:users, :salted_password, :crypted_password)
   -> 0.3590s
-- add_column(:users, :salt, :string, {:limit=>40})
   -> 0.3280s
-- add_column(:users, :created_at, :datetime)
   -> 0.3600s
-- add_column(:users, :updated_at, :datetime)
   -> 0.3430s
-- add_column(:users, :remember_token, :string)
   -> 0.3440s
-- add_column(:users, :remember_token_expires_at, :datetime)
   -> 0.3600s
== CreateUsers: migrated (2.0940s) ============================================

Back to our application checking if the user system is working now, let’s try to sign up again and see what we will get (http://localhost:3000/users/signup):

“Train delayed? and what’s to say?” nice poetry after such a cool process, so we are signed up and logged in now, this is what acts_as_authenticated can give us so far and the rest is on us.

Have you noticed that the column fullname didn’t show up in the signup page? That’s because the templates generated by acts_as_authenticated plugin don’t know about it YET.

Tailoring

To be able to tailor and customize the authenticated system we have to understand the generated files and know how to deal with them and we will start with the views:

The generated templates are three, login, signup and index, they are all placed under the “users” subdirectory in our app/views directory, what we want is to allow users to add their fullnames when they signup so let’s have a quick look at the signup.rhtml template:

Error: Could not open signup_old.rhtml

It looks that we have a pattern for every property of the user object to generate its corresponding form input, if we followed the same pattern to generate the required input for the user fullname our template will look like this:

Error: Could not open signup.rhtml

This template like any other rhtml view template contains two types of code, the basic xhtml/html code and an embedded ruby code which we call ERb. To embed a ruby code in our views we have to surround it with <% and %> this will execute the ruby code but it will not show any output so it’s called “evaluation ERb block”, if we want to show the output of this code we have to add an equal sign after the introductory signs so it will be surrounded by <%= and %> and this is called “output ERb block”.

In any of the ERb block types we will deal mainly with two things, first is the ActionController methods and actions, these will help us generate the required xhtml/html, js and xml code in a dynamic smooth way.

The second thing we will deal with in our views is the instance variable received from the related action in the related controller, each view will be parsed after its corresponding action in its related controller is requested, in that particular action we set some instance variables that we can manipulate in our views, we will see that in more details soon.

How is it working?

In order to understand the code and the way it is generated in signup.rhtml let’s have a look at the parsed version of it, the html source code of the page we get in our browser when we call http://localhost:3000/users/signup:

Error: Could not open signup.html

Back to our rhtml template we notice that it starts with an output ERb block with the method error_messages_for which will output all the error messages of the user object in this form if there is any, as we don’t have any errors here we didn’t find any related html code in the parsed version.

Then comes an evaluation ERb block that opens a block by its turn, the form_for method do the required preparation to output a form fully customized to hold the information of a specific object and by ready I mean setting this form inputs names and ids to form a set of the object’s data in the post parameters. So what we do is to specify the object name we are preparing this form for, which in our case “user”, we can also specify the action this form will be directed to when it’s submitted, if we don’t specify any (like in our case) it will be submitted to itself so our form will be submitted back to the signup action of the users controller.

The form_for method prepared a form helper object for the “user” object and name it “f”, then the generating of the required inputs for each column started by simply calling their corresponding helper methods, notice that only two methods are used so far: text_field and password_field and they are called as methods of the form helper object called “f”, notice as well that these methods are called in an output ERb block so they can return their output in the parsed template.

Let me try to simplify this code by trying to write it in plain English: “Start a form for a new user then generate the required text fields and password fields for this user and then post them back to the same current page.”

The main idea of setting the names and ids of the generated inputs is to simplify the way we deal with them in our actions as post parameters, rails has a standard for this and therefore it has the ready tools to generate what’s required to follow these standards and get things faster.

After we are done with our form fields we find a submit_tag named “Sign up” then the form_for block is simply closed by an “end” and we are done. When someone signup and fill all these fields and hit the sign up button the form data will be posted to the same action “signup” where it will be handled to add a new user to the Users table accordingly, if it faced any errors it will return to the same form and show the errors at the top (as the results of the error_messages_for method), if not it will simply login to our poetry page.

Are We Logged In?

Now let’s change this literal poetry in the index.rhtml template to some code poetry, how about we change the output of this view depending on the status of the user, if he/she is logged in we show a link to logout, if not we show links to either signup or to login. I don’t think this is difficult it’s just a quick if statement:

Error: Could not open index_new.rhtml

I guess the code is self-explanatory now, I just want to note that we used the method logged_in?, in ruby whenever there is a method with a question mark “?” at the end of it will return a Boolean, True or False, so in English it’s like a simple question, is the current user logged in? this method is a part of the acts_as_authenticated plugin.

The other thing I wanted to talk about here is the link_to method, it is an ActionView helper method, it generates an anchor, takes the first parameter as the anchor name and the second as the action name we want to link to, it will automatically understand and generate the corresponding URL of the action we specify, for example when we specify the “logout” action it will know automatically that its URL is http://localhost:3000/users/logout.

So we have changed our index.rhtml file, now let’s see if it’s working and how it will look like, remember that our last state where logged in after we signed up and saw the lovely poetry:

We are logged in, that’s true, it seems that everything is really working fine and we don’t have any problems so far, how about the link to “logout”? is it working? let’s check out:

Yes it is working, we are logged out now and we have one of two options, either to login again or to signup for a new account, try logging in and out again to see how it’s working and then let’s try a new signup to see if the fullname field we have added is present or not:

Wonderful, we have a simple user authentication system now that we modified a little, so far it works for signup, login and logout, it doesn’t do anything more yet but at least it helped us understand few concepts and how things work at the backend.

More Security by Filtering

To care more about security and to get the most benefit out of the latest rails 1.1.6 security release let’s use the new method of ActionController (released in rails 1.1.6) “filter_parameter_logging”:

“ActionController#filter_parameter_logging lets you filter form data that you don’t want saved in the log. This is useful for preventing sensitive data like passwords and credit card numbers from being logged in the clear, for keeping huge pieces of data from clogging the log file, and so on.” from Filtered Parameter Logging of the Ruby on Rails official Blog.

This method job –as clarified in rails weblog- is to filter fields from being logged, in our case what we want to filter is the password fields and we will do that by adding the filter_parameter_logging line to our application controller in controllers/application.rb:

Error: Could not open application_filtered.rb

By doing this the password and password_confirmation fields will never be logged anymore and will be replaced by “[FILTERED]” in the log files, to check that yourself you can check your log/development.log file and see how the passwords of the users added to the system earlier were plainly logged while the passwords of any new users will be replaced with “[FILTERED]“.

Summary

In this part we have implemented the Acts As Authenticated plugin into our application, modified it a little and understood few backend behaviors specifically the way the view templates handle ERb code, we also had a better look at Migrations and understood how they help us have a better control over our database modifications in a very dynamic way.

During the next week I will release a sidenote post on how to checkout the project files from the subversion repository I’m using for it, I’m also working on creating packaged files for each part of the tutorial and will release it on RubyForge soon too.

In the next part we will talk about relationships, as for now we have a user system and a simple books system, we will link them together using some magic relationship mapping from ActiveRecord maybe we will do some testing as well to ensure things are working properly, so… see you next week.

It seems that I underestimated the amount of work this tutorial is going to take that’s why I’m a day late, because of that I will change the weekday each part of this series will come up from Saturday to Sunday and sorry about this delay.

If you remember our project is BookSwap, a small system based on users, it will give them the chance to exchange and swap books between each others from their online bookshelves that they create. so let’s get started:

Normally I prefer to get something up and running as soon as I can, at least to enjoy seeing results from the very beginning of my project work and this is what we are going to do with this project as well, so to start let’s decide what is the simplest database design we can start with?

Database Schema

Basically from the light definition of our project we can tell that this project includes two main things: users and books, and from here we will go, we need two tables, one to hold the users data and we will call it Users and another one for books data and we will call it Books and now let’s discuss the relationship between these two tables

Obviously every user will have many books, and many users can own the same book (I mean the same title not the same physical book), so the relationship we have here is the many-to-many relationship which requires a third table in our database called users_books, therefore our database should look like this (db model is generated using DBDesigner4):

As you can tell from the database model above, I have mentioned the common and very basic columns of each table; fullname, login, email and salted_password for the Users table and title, author, publisher and ISBN for the Books table and naturally both of them have the default ID column as well.

We will use MySQL as the database server for this application, it’s time to create the three databases we will work with on our way:

bookswap_production: This will be the database we will use when we finish our development work and ready to have a live and completely working web application, that’s why it’s called the production database, it should contain the most stable version of our database structure with the most stable version of our code that’s why we separated it from the development database.

bookswap_developmentt: As you can tell, this is the database that we will play with during our development process, whenever we need to change anything or touch anything related to the database this is the one we should be dealing with in order to keep our production database in peace.

bookswap_test: In a sooner part of this tutorial we will cover the testing of our application, we will write code that will test our code and this testing code will deal with a completely separate database from both development and production databases, it will deal with the test database as it will require a lot of data insertions and deletion while testing which we want to keep away from other live and development databases.

If you have a GUI for your MySQL server you can create the above databases from there or we can simply use the command line admin tool:

D:\\Projects>mysqladmin -–user root -–password create bookswap_production
Enter password: ********

D:\\Projects>mysqladmin -–user root –-password create bookswap_development
Enter password: ********

D:\\Projects>mysqladmin -–user root -–password create bookswap_test
Enter password: ********

We will only create the databases now, we will not create any tables or relationships yet and actually we will do all that in Ruby and Rails after we get to know the directory structure of our rails application.

Generating The Rails Application

Before we get started with generating the rails application let’s just clarify few things, we are using Rails 1.1.6 for this application which got announced only few days ago (from the date of this post), so if you have Rails installed earlier before the update please upgrade before we proceed.

To generate our rails application we have to run the rails command, personally I have created a directory called “Book Swap” where I will store everything related to this project, including the rails app itself. So all I have to do now is to run the “rails” command in my directory with the project name to get my files generated.

D:\\Project\\Book Swap>rails bookswap
      exists
      create  app/controllers
      create  app/helpers
      create  app/models
      .
      .
      .
      create  doc/README_FOR_APP
      create  log/server.log
      create  log/production.log
      create  log/development.log
      create  log/test.log

I guess you agree with me that these are a lot of files and directories that Rails has generated for us, maybe we should give them a quick scan and try to understand what they are for and what we will be dealing with more frequently:

File Structure

app

This directory is the one that will contain most of our working files, it already contains four subdirectories (controllers, helpers, models and views), that is made to support the MVC nature of Rails, in brief the MVC methodology is based on separating our code into three levels:

First we have the Model which carries the core functions and responsible for all the data handling and manipulation, then comes the Controller which normally interacts with the model to retrieve data and prepare it to be viewed by the View which by its turn is the responsible of doing all the “show” business.

As for Helpers, they are the view supporters, when we reach the level that we have too much code in the view we better go and make a helper function and use it instead, once we start writing code we will get a better understanding of all these concepts which will happen very soon.

Behind The Scenes

All of these models, controllers and views are just the children of a bigger and more general parts of Rails, actually Rails is a union of different parts for each task which makes it more understandable and customizable to fit our best needs.

ActiveRecord is the part of Rails that’s responsible of interacting with the database and lets us deal with it as a complete object oriented solution, which really sounds like the model behavior (core functions and data manipulation) which is true, normally the model classes in our models directory are subclasses of ActiveRecord where they inherit the magic powers of it and get such strong tools to deal with the database.

“Active Record objects don’t specify their attributes directly, but rather infer them from the table definition with which they’re linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.” From Rails API

Following the same path Rails also depends on ActionController for its controllers, which is the midpoint between the views and the models, it receives the web requests from one side, activate the corresponding action which will contact the model for few data objects and then render the views to show the results.

“Action Controllers are the core of a web request in Rails. They are made up of one or more actions that are executed on request and then either render a template or redirect to another action. An action is defined as a public method on the controller, which will automatically be made accessible to the web-server through Rails Routes.” From Rails API

And finally we’ve got the views which are ActionView templates, we will see how they are just normal html, js or xml pages but with embedded Ruby code inside which also known as ERb, this embedded code helps us represent the data with some behavior and have a better separation between our design and our backend code.

“Action View templates can be written in three ways. If the template file has a +.rhtml+ extension then it uses a mixture of ERb (included in Ruby) and HTML. If the template file has a +.rxml+ extension then Jim Weirich’s Builder::XmlMarkup library is used. If the template file has a +.rjs+ extension then it will use ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.” From Rails API

config

From its name, config directory is where the configurations files are stored, the database link file, routs and environments files. database.yml is the database link file, where we will setup our database connection settings, environment.rb is the file where we specify our application environment, remember when we talked about development, production and test databases; each one of those is related to one separate environment as well that we can run our application on.

Config directory include environments subdirectory too which include environments configurations files, for each environment a different file, to control all the environments we have the father file we’ve just talked about environment.rb.

Finally comes the routes.rb file which (as it’s named) take care of all the web requests routing in our application, starting from some very basics routes up to a very complicated ones, it is very helpful for making clean and meaningful URLs as well.

components

In this directory we can create and store components which are something like a small application with model, controller and view that we can use all over our website instead of repeating ourselves for some modules.

db

From its name, the db directory will store our database related files, earlier we used to store the SQL files that generate our database structure but now it will hold only ruby files. It will store the schema and migrations files that we will discuss after a while in this part.

When we first generate our rails application the db folder will be empty but as we move along it will contain the schema.rb file that stores our database schema definitions and a subdirectory named “migrations” to store the versioned migrations we will create.

lib

Sometimes but not always there are some code that we want to write and it doesn’t fit under any of the MVC hierarchy, such custom code will be stored in the lib directory.

public

An interesting fact about Rails that none of these directories we are talking about is viewable or accessable online except for “public“, it contains the cgi/fcgi dispatchers that will do all the underground work to deal with the routes and our application, it also contains the images, stylesheets and javascripts subdirectories that we will be calling in our views and layouts.

script

You will notice when go a little further that rails is full of generators and embedded scripts that help us along the road to generate and create many things and even run a tiny web server as well the script directory is where all these stuff are hidden.

test

The test directory is where all the automotive tests are stored, there are functional tests for our controllers with some fixtures to load and a couple of unit tests for our models as well.

vendor

As in any application, sometimes we don’t want to reinvent the wheel, we don’t want to do something that’s already done, rails as an open source framework have many wonderful plugins and resources available that we can use in our applications and we will do that as well in BookSwap, all these external libraries and plugins will be stored in the vendor directory.

doc, log, and tmp

These three directories we don’t interact with their files much as they are automatically generated and updated, the log directory will store the log files of our web server for each environment, tmp will store the session, cache and socket temporary generated files and finally doc will store the html documentation that we will generate for our application (we will cover this up in some later part).

Link The Database

After we had this quick overview over the file structure in Rails we have to configure our rails application to connect to the databases we have created earlier, the responsible configuration for this is config/database.yml which normally looks like (notice that the databases names are exactly like the one we’ve created as they follow the project name):

Error: Could not open original_database.yml

Now for the sake of DRY ‘ing our configuration file we will change it a little bit and add our database connection details as well to:

Error: Could not open dried_database.yml

Basically what we have done is taking all the repeated information from the three database configurations parts, collect them under one reference and call this reference back in the configurations parts, by doing this we are not only DRY ‘ing our database configuration file but we also allowed different database engines to be defined more easily.

So our Rails application is linked to its blank databases using the MySQL adapter and it’s time to implement the structure we’ve decided on earlier using the rails schema and migrations facilities.

Rails + Database = Schema + Migrations

Migration in rails is the way Rails allow us to move back and forth in our application easily without losing any data from our databases but also keeping track of all the database structure changes from version to version (something like version control for our code files).

Database schema in Rails is very first database schema our rails application will have so if we want to install it on a new machine or load our database structure in any different database server it will be ready as a schema file that gets accumulated by the migrations files to move between versions.

In this part we will deal only with the schema part and later on with our versions and modifications we will get to know migrations better and have a closer look at them, now let’s generate the schema file and see how it looks like:

D:\\Projects\\Book Swap\\bookswap>rake db_schema_dump

This command will create a new file in our db folder named schema.rb, this file will hold all the starting schema setup and definitions and as this is a fresh application it will be empty from any definitions yet:

Error: Could not open original_schema.rb

Now let’s implement the basic database schema we agreed on at the beginning of this part, three tables with few fields, after the modification our schema.rb will be like this:

Error: Could not open schema.rb

If you read the above code you can easily understand that we simply created three database tables and identified their columns accordingly but notice also that we didn’t define the id column of the users and books tables, this is because ActiveRecord will create it by default.

create_table is a simple method that generates SQL code of creating a table, we used its block form to add columns of our desired type, in the block form an instance of the table definition is created as “t” and when we call t.column it’s like if we say add_column in the regular form of the create_table method.

We have a schema file that contains our database structure, we have a rails application linked correctly to our database all we have to do now is to tell rails to import this schema to the linked database:

D:\\Projects\\Book Swap\\bookswap>rake db_schema_import
(in D:/Projects/Book Swap/bookswap)
-- create_table("users")
   -> 0.3440s
-- create_table("books")
   -> 0.1410s
-- create_table("users_books")
   -> 0.1720s

Running this command will import the database schema defined in schema.rb to our development database and that’s because the default environment of any new rails project is the development environment which can be changed and configured at anytime in config/environment.rb.

With this ruby-based database schema file we have saved ourselves from being attached to any database engine, Rails supports too many database engines like SQLite, Oracle, DB2, SQL Server and PostgreSQL, now our application can work with any of those by simply changing the connection adapter in config/database.yml file and import our schema to it using the above rake command.

This is one of the reasons why many designers or non-developers liked Ruby on Rails when they started to learn it as their first web development language and framework, Ruby has this beautiful self-explanatory code and Rails is full with Agile practices, it saved us from dealing with any SQL code and made our application cross-database-engines with Schema and Migrations.

All this read and all this steps and we didn’t see anything in action yet, maybe it’s time for us to try Scaffolding which is a quick auto-generator that we tell it about a table we want to scaffold and it will generate all the required Model, Controller and Views to connect with it and control it.

By running the following command we will be able to add, edit, delete and list all the data of our Books table:

D:\\Projects\\Book Swap\\bookswap>ruby script/generate scaffold Book Books
      exists  app/controllers/
      exists  app/helpers/
      create  app/views/books
      exists  test/functional/
  dependency  model
      exists    app/models/
      exists    test/unit/
      exists    test/fixtures/
      create    app/models/book.rb
      create    test/unit/book_test.rb
      create    test/fixtures/books.yml
      create  app/views/books/_form.rhtml
      create  app/views/books/list.rhtml
      create  app/views/books/show.rhtml
      create  app/views/books/new.rhtml
      create  app/views/books/edit.rhtml
      create  app/controllers/books_controller.rb
      create  test/functional/books_controller_test.rb
      create  app/helpers/books_helper.rb
      create  app/views/layouts/books.rhtml
      create  public/stylesheets/scaffold.css

This command will ask Ruby to run the scaffold generator to create the MVC setup for our table Books, the first parameter after “scaffold” is the Model/Table name and notice here that the table name here is not plural as we have specified it in our schema.rb, it’s Book not Books and this is because Rails will take care of this with it’s pluralization magic.

The second parameter in the scaffold command is the Controller/View name, basically it will create controller of the same name and a directory in the views directory named books with few templates for each action in the created controller.

Few other files got created too in the process, a helper and few test files, for now we will not deal with any of them but we can at least understand that for each data table of our database we can have all these structured files, a model to interact with the database and present the table data as objects, a controller which interact with these objects, filter them and prepare them to be viewed by the views which are templates with light embedded ruby code.

With this very minimum work, few commands and modifying a couple of files, we didn’t even write any code yet but we have something up and running and it’s time to have a sneak view on how it will look like.

D:\\Projects\\Book Swap\\bookswap>ruby script/server
=> Booting WEBrick...
=> Rails application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with --help for options
[2006-08-20 16:49:04] INFO  WEBrick 1.3.1
[2006-08-20 16:49:04] INFO  ruby 1.8.4 (2005-12-24) [i386-mswin32]
[2006-08-20 16:49:04] INFO  WEBrick::HTTPServer#start: pid=5652 port=3000

We don’t even need to install a webserver while developing a rails application, we can simply try it with WEBrick, the simple http server bundled with rails. It will run by default on port 3000 on the localhost server so let’s check it out http://localhost:3000.

Rails welcomes us, read this page as it has some useful information that we have discussed some and will discuss the rest (routes specifically) in depth later in other parts.

So where is the magic? We have generated a scaffold for the books table and we chose the controller/view name to be books, rails understand that and it will run everything automatically under the following mapping: servername:port/controller/action, in our case the servername is localhost running on port 3000, the controller we’ve created is named books but we don’t know any action yet but let’s try this: http://localhost:3000/books/

Great!! We have a page with the title “Listing Books”, an empty table with same headers of our columns names and finally a link that says “New book”. By clicking on this link we will see something more wonderful, a ready form, lovely and simple that allows us to add new books to our database.

Let’s try filling it out with some data and add the book, where will we go next? Back to the listing page but now it’s not empty like before, we have the new book we’ve just created listed there:

What else have we got there? Three links in same row with our recently created book, Show, Edit and Destroy.. Do we have to explain? Clicking on Show will take us to a separate page that shows only the data of this particular row, Edit will take us to a form page loaded with the information of this record, ready to be edited while Destroy will popup a warning message before it will delete this record. This is it, one line only and the scaffold generator created all this for us.

Follow the URLs of each action and see how they are very meaningful and clean, all this web requests are handled in config/routes.rb as we said above, with the default route (mapping) as /:controller/:action/:id so for example if we go to http://localhost:3000/ books/show/2 routes.rb will forward this request to the books controller to run the show action on the book with 2 as its id.

Naturally scaffolding is not made to be used on its own, it’s made just to provide us with the very basics functions in a very simple way so we can understand how things work but we have to do the rest and modify the code to what perfectly suit our needs and that is what we will discuss in the next parts.

At The End

In this part we have met Rails in a little depth, had a quick look at the file structure it generates and understood some of the migrations and schema magic as well, technically we have now a basic rails application for books where we can add, edit and delete any record at any time after we wrote a very minimum amount of code and left the rest on Rails to take care of.

In the next part we will talk about creating some more tables, discussing migrations a little further and getting a better look with a nice interface and see how to implement the design with our Rails application as well, sorry for the length of this part and see you next week…

“Art should be independent of all claptrap—should stand alone, and appeal to the artistic sense of eye or ear, without confounding this with emotions entirely foreign to it, as devotion, pity, love, patriotism and the like.” by James McNeill Whistler

This movement included both literature and fine arts at that time but a while after people start to use this concept in different forms like Science for Science’s Sake and many others considering the wide meaning of art and what it can cover under its umbrella and so is the case with programming, which is an art, art of making beautiful and useful things. (I guess there no better quote than Graham’s here):

“What hackers and painters have in common is that they’re both makers. Along with composers, architects, and writers, what hackers and painters are trying to do is make good things. They’re not doing research per se, though if in the course of trying to make good things they discover some new technique, so much the better.” Hackers and Painters by Paul Graham

Programming isn’t the same to all programmers, some consider it an art and a craft while others consider it a painful process to earn a living, that’s why I think Graham wanted to distinguish between programmers and hackers. Hackers according to Graham are the architects of the industry, the software makers who make their masterpieces with creativity and style.

Does History Repeat Itself?

One of the main factors that encouraged the art movement at the time it started was the Industrial Revolution when many crafts and work types lost their meaning and purpose because of a machine or a factory alternative, for example painting became more into an abstract art instead of being just a way to image how things looked like; specifically after Photography rise, new ways and styles of painting appeared, schools formed and being an artist got a different meaning.

This is happening now after the Digital Revolution and the rise of Information Age, many types of work lost their meaning, businesses became much easier, faster and more accurate with computers and high-tech devices, some of these crafts became an art where the rest died, products and services we used to pay a lot of money to get are much cheaper now or even available for free sometimes.

Programming is the act of making software for a computer or any other digital device, it is a result of the digital revolution and what operates it. Here we notice the difference compared to the art case in the 19th century, programming is one of the major weapons of the digital revolution, programming makes alternatives to many work types in real life so they lose their purpose for a computerized alternatives, where art used to be the victim of the industrial revolution as mentioned earlier.

Programming and Art are similar in different areas and from different aspects, it is a different scenario that may force programming to face similar destiny of art and be done for its own sake.

The New Concept of Competition

Programming itself evolved extensively during the past few years, the number of programmers grew dramatically and making software became an easier process as well, many programming languages and frameworks, many communities and methodologies and a completely different market shares for new software development companies.

The existence of communities such as the Open Source community gave programming a special feature in sharing and understanding, which caused a higher level of knowledge and a very quick development approach, programmers start to learn from each other and share their knowledge to help each other do something better or to complete the undone and has to be done.

In the other hand market giants adopted different approaches, some encouraged open source while others didn’t where in both cases as giants they had a very good position to take decisions and direct the market. The existence of the giants and open source communities made programming a high level industry in which the ability to be one of the giants isn’t affordable so programmers either wished to work for the giants or develop a product or service that gets the attention of a huge company that could possibly acquire it.

In my opinion when programming as an industry reach such a level of complexity (market and philosophy wise) it is natural to find a group of programmers who make software for the sake of it and not to compete or anything, just for enjoying what they are doing and share it with others.

What is Programming’s Sake?

Programming for Programming’s sake is when you write the code with creativity and passion, not only to serve users or to earn your living from it. It is when you make the software for the happiness and joy it brings to your heart, applying your methods and spending enough time refining your masterpiece to let it express you and the art you represent without allowing any other factors to affect your craft.

No matter if the program you are doing is already made before or how simple it may sound, when you give it the artistic quality of your mind it will be different from any other one that has ever been made.

Enjoying what we do is something that we all wish to do but sometimes we are afraid to do it or unable to do it because we don’t want or unable to give or sacrifice anything for it, we don’t want to lose our lifestyle, we don’t want to go for less but the question is: How much are we able to sacrifice for something that we really enjoy?

The Thin Line

It may sound simple but it is not, when it comes to real life it’s very difficult to be able to do what you like, do it for the sake of it and be able to live with it. In the past this has created a completely new culture of Bohemianism where bohemians didn’t care about the money or traditional life behaviours but cared the most about their own art, doing it for the joy of it and sacrificing everything in a very ignorant way in return.

It is a very thin line that one should be careful before crossing when it comes to sacrifice, life is full of responsibilities but at the end of the day it’s not important how much you are earning but how happy you are in your life, living without regrets of any sacrifices you made in the past. So I’m not saying that you should always do the programming for it’s own sake because I know how difficult this is, specially if you make your living out of it, but a parallel stream with your work will make you happier with your programming and will even make your programs more artisitc.

This whole idea may sound too bohemian and crazy to some people, but with all the craziness it has in it, I really believe in it and I believe that such concepts is a primary step in the life cycle of every craft, I know it is a very tough road to go through and the idea itself still requires some refining in my head which I will keep on posting about until I reach its best shape. If you liked the idea or disliked it go ahead, share your opinion here and let’s discuss it free and loud…

Ruby

Ruby is a pure object oriented programming language, created by Yukihiro Matsumoto from Japan around 11 years ago, first it was only in Japanese language, and then got translated into English around 5-6 years ago, where it had an exposure success and a great support.

For Windows the simplest way to install Ruby is via RubyInstaller, the latest stable release is version 1.8.2-15 but we should get version 1.8.4-17 RC2 (this will be explained later) as we are going to prepare for Mongrel as a webserver, you can use 1.8.2 if you will use Apache-FastCGI option only, but version 1.8.4 is more recommended for both cases.

Note: If you are running any previous version of Ruby and upgrading to Ruby 1.8.4 you may face a problem with your existing Rails applications: “Invalid char `\002′ in expression” this error happens because of some wrong tabs interpreting in windows, in order to solve it simply use your preferred editor (I use Notepad++) to replace all tabs by spaces as Ben Reubenstein advised.

So after you download the executable file from RubyForge, run it and don’t forget to change the setup directory to D:/Development/ruby (the directory we’ve created to host our development programs files in Part 1).

Ruby is now installed on our system, let’s try the lovely IRB that comes with it. IRB is an interactive command-line interpreter, which allows us to simply type our code lines and see the results on the spot.

Start the command line (Start->Run->cmd), simply enter the command “irb” to start, and to exit you can type “exit”.

Error: Could not open irb_test.rb

You can know more about Ruby (if you don’t already know) from Wikipedia Ruby Programming Language page, and now let’s move on to see some more Ruby goodness, let’s meet RubyGems.

RubyGems

RubyGems is the standard packaging system for Ruby, it simplify the distribution of Ruby third party libraries and projects by packing them in a standard format and then allowing us to install it in another simple way too (this is what we will do with Rails).

First download the Ruby Gems 0.8.11 zip file from RubyForge, unzip it, and then run the setup.rb file which will take care of the rest.

Installing Ruby Gems will add a new command “gem” that can be used from the command prompt to install, update and build gem packages. Now we will use it to install Rails and many other libraries by simply typing a single command line and let it take care of the rest.

Ruby on Rails

Ruby on Rails aka Rails aka RoR is the web framework of Ruby, created almost three years back by David Heinemeier Hansson as an extraction of his work on BaseCamp (a product of 37Signals), maintained now by a list of talented developers in the core team that came from different backgrounds to help Rails be the best friend of every web developer.

RoR framework implemented to demonstrate a better MVC architecture that follows the DRY concept, which to help us create better applications in less time and more solid way, personally I moved to Rails because it allowed me to spend more time on algorithms and real programming work instead of just worrying about the regular stuff that we do everyday like connecting to the database and the other
CRUD work.

We will install Rails and all its dependencies via RubyGems using “gem install” command, that will first search for the gem file locally, then attempt the remote installation from the robyforge gem repository:

D:\\development>gem install rails --include-dependencies
Attempting local installation of 'rails'
Local gem file not found: rails*.gem
Attempting remote installation of 'rails'
Updating Gem source index for: http://gems.rubyforge.org
Successfully installed rails-1.1.2

If you are not able to connect to the internet from the command line then you have to install Rails locally by downloading Rails 1.1.2 and its dependencies: ActionMailer 1.2.1, ActionPack 1.12.1, ActionWebservice 1.1.2, ActiveRecord 1.14.2 and ActiveSupport 1.3.1 as stand alone gems, place them in the directory were you want to run the gem command so it will be able to find them, let’s say inside D:\Development and see:

cd d:\\development
D:\\development>gem install activesupport
Attempting local installation of 'activesupport'
Successfully installed activesupport, version 1.3.1
Installing RDoc documentation for activesupport-1.3.1...

D:\\development>gem install actionpack
Attempting local installation of 'actionpack'
Successfully installed actionpack, version 1.12.1
Installing RDoc documentation for actionpack-1.12.1...

D:\\development>gem install actionmailer
Attempting local installation of 'actionmailer'
Successfully installed actionmailer, version 1.2.1
Installing RDoc documentation for actionmailer-1.2.1...

D:\\development>gem install activerecord
Attempting local installation of 'activerecord'
Successfully installed activerecord, version 1.14.2
Installing RDoc documentation for activerecord-1.14.2...

D:\\development>gem install actionwebservice
Attempting local installation of 'actionwebservice'
Successfully installed actionwebservice, version 1.1.2
Installing RDoc documentation for actionwebservice-1.1.2...

D:\\development>gem install rails
Attempting local installation of 'rails'
Successfully installed rails, version 1.1.2

It’s pretty simple isn’t it, so now we have Ruby and Rails installed on our machine, let’s give Rails a try, and see this quick thing that everybody is talking about, we will create a rails application in our webroot folder (the one we have created in Part 1 to be our web root).

cd D:\\webroot
D:\\webroot>rails testapp
      create
      create  app/controllers
      create  app/helpers
      .
      .
      .
      .
      create  log/production.log
      create  log/development.log
      create  log/test.log

With just this two words command we have got a complete web application hierarchy that we can start from to develop what we need, as this post is getting more longer that expected let’s just run WEBrick and see what will it look like.

WEBrick

WEBrick is a library that comes bundled with Ruby to build HTTP servers, it is commonly used as the development server for Rails applications, we will use it now to test the testapp we have just made:

D:\\webroot>cd testapp

D:\\webroot\\testapp>ruby script/server
=> Booting WEBrick...
=> Rails application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with --help for options
[2006-06-20 01:24:33] INFO  WEBrick 1.3.1
[2006-06-20 01:24:33] INFO  ruby 1.8.4 (2005-12-24) [i386-mswin32]
[2006-06-20 01:24:33] INFO  WEBrick::HTTPServer#start: pid=3668 port=3000

This will start a light webserver on port 3000, which is the default (changeable) port of WEBrick, be sure if you are running any other services that they are not using this port, how about seeing the results of two lines of work on Rails? Point your browser to http://localhost:3000 and see by yourself.

Enough for now, let’s stop WEBrick (use Ctrl+C) and install some quick gems before we configure FastCGI and Mongrel.

Extra Goodness - Ruby Libraries and Typo

Below is a quick list of some useful Ruby libraries that you may use during your development work (description taken from each project’s RubyForge page):

• RMagick: An interface to the ImageMagick and GraphicsMagick image processing libraries. Supports more than 90 image formats, including GIF, JPEG, PNG. Includes RVG, a 2D drawing API. Comprehensive HTML documentation.
  to install: “gem install RMagick-win32-1.x.x-mswin32.gem”
• LibXML: The Libxml-Ruby project provides Ruby language bindings for the GNOME Libxml2 XML toolkit. It is free software, released under the MIT License.
• RedCloth: A module for using Textile in Ruby. Textile is a text format. A very simple text format. Another stab at making readable text that can be converted to HTML.
• Net::SSH: Net::SSH is to SSH as Net::Telnet is to Telnet and Net::HTTP is to HTTP. Perform non-interactive SSH processing, purely from Ruby!
• Salted Login: Salted hash loging generator with ActionMailer integration

You can read the help of each library if you failed to install it via RubyGems, feel free to leave a comment here if you faced any problems during the installation.

Moving forward to install the Rails script we talked about earlier, we will install Typo, which is the first Rails Blogging system, quick, simple and widely used among Rails developers, as a start let’s download it from Typo Sphere, as you can see from Download page, it’s clearly mentioned that Typo 2.6 will not work with Rails 1.1 or above, so we have to download the version with frozen Rails included.

Unzip the downloaded file into the web root folder and let’s rename it to “blog” so we get Typo in D:\webroot\blog , now we have to prepare the required database for it, we will create a database and name it “blog” and insert the typo MySQL schema from D:\webroot\blog\db\schema.mysql.sql into it using the command line:

D:\\webroot\\blog>mysql --user=root --password
Enter password: ********
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 80 to server version: 5.0.21-community-nt

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> CREATE DATABASE blog
    -> ;
Query OK, 1 row affected (0.00 sec)

mysql> quit
Bye

D:\\webroot\\blog>mysql --user=root --password --database=blog\<"D:\\webroot\\blog\\db\\schema.mysql.sql"
Enter password: ********

Finally to get Typo working we have to update the YAML file responsible about connecting Typo to its database, this file is called database.yml and it’s located in D:\webroot\typo\config, all we have to do is changing the password line and place the password we used while installing MySQL in Part 2, then changing the production database from “typo” to “blog” (the line before last), save the file and let’s run WEBrick in production mode (from inside the blog folder) to see if we everything is fine or not yet..

D:\\webroot\\blog>ruby script/server -e=production

Pingo!! It’s running and asking us to complete our admin information, just complete it and have a look at the lovely admin panel and the Ajax goodness implemented inside, although I suggest that you just wait a little bit more to do the Apache or Mongrel integration, at least so you will be able to run it safely online even in production.

Apache2 and FastCGI

FastCGI with Apache is considered one of the best production environment for Rails applications, although there are many alternatives like LightTPD-FastCGI (Which is better), and Mongrel which will be explained here as well.

The first things we need are the mod_fcgi and mod_sql files that are available in the quick installer package named Ruby for Apache, it’s a straight forward installer that will ask you about the locations of both Apache and Ruby, which are both located in D:\development where we installed them earlier.

We don’t need the mod_ruby file (I even heard that it may make some conflicts too), so anyhow let’s choose mod_fcgi and mod_sql only and start editing our httpd.conf file to configure FastCGI.

Mainly there are three steps to configure FastCGI with Apache and all of them are in httpd.conf file that if you remember is located in D:\Development\Apache\conf\httpd.conf :

• First let’s load the FastCGI module by adding the following lines to the LoadModule section:

  Error: Could not open fcgi_apache_1.conf

• Secondly let’s configure FastCGI itself, preparing it for the production environment, configuring the min/max processes allowed and define the initial environment variables to lead FastCGI to the Ruby and MySQL directories.

  Error: Could not open fcgi_apache_2.conf

• And finally it’s time for the VirtualHost information to be defined. Here there are two options to think of depending on your requirements and situation, for example I have an ISP that block the port 80 (as I mentioned in Part 1) so I won’t be able to run the virtual host as another subdomain referring to my server, but I have to load it on another port and make a direction later.

  As I said, depending on your situation you should chose what best fits your needs, starting with the first option, we will create a new subdomain and refer it to our IP, you can do this simply by following the same steps mentioned in Part 1 for No-IP, and then at the bottom of httpd.conf we will add the VirtualHost details as follows:

  Error: Could not open virtual_host2.conf

  The second option (which is the one I’m using currently) is where I define a new port for my rails application and then make a quick Apache redirect toward it. First we have to tell Apache to listen to the desired port, then configure the virtual host of this port to refer to our Rails application.

  Error: Could not open virtual_host.conf

If you created the Rails application using the “rails” command on your Win32 machine then dispatch.fcgi will automatically refer to your local Ruby file, but for ready scripts like Typo for example the referred to Ruby is the default Ruby path on Linux systems and has to be changed, to do that simply edit the first line of dispatch.fcgi (located in the “public” directory of every Rails application) from:

#!/usr/bin/env ruby

to:

#!d:/development/ruby/bin/ruby

This will tell FastCGI where your ruby bin files are located and so it will run peacefully.

Note: The above information were gathered from other websites that had solved the difficulties of integrating FastCGI with Apache like Demetrius Nunes’s “Taming FastCFI+Apache on Windows” and Scott Laird’s “Apache tuning for Rails and FastCGI” and other resources too.

Mongrel

Mongrel is very to WEBrick from it’s working point of view, although it’s much faster and more suitable for productive environments than WEBrick, it also run on a specific port and now it is well supported on Windows systems, Mongrel now can be installed as a system service which makes it more stable and better configurable.

To start working with Mongrel we have to install it along with its dependencies, gratefully using RubyGems:

D:\\development>gem install mongrel_service
Attempting local installation of 'mongrel_service'
Local gem file not found: mongrel_service*.gem
Attempting remote installation of 'mongrel_service'
Updating Gem source index for: http://gems.rubyforge.org
Install required dependency gem_plugin? [Yn]  y
Install required dependency mongrel? [Yn]  y
Select which gem to install for your platform (i386-mswin32)
 1. mongrel 0.3.13 (mswin32)
 2. mongrel 0.3.13 (ruby)
 3. mongrel 0.3.12.4 (ruby)
 4. mongrel 0.3.12.4 (mswin32)
 5. Cancel installation
> 1
Install required dependency win32-service? [Yn]  y
Select which gem to install for your platform (i386-mswin32)
 1. win32-service 0.5.0 (mswin32)
 2. Cancel installation
> 1
Successfully installed mongrel_service-0.1
Successfully installed gem_plugin-0.2.1
Successfully installed mongrel-0.3.13-mswin32
Successfully installed win32-service-0.5.0-mswin32
Installing RDoc documentation for mongrel_service-0.1...
Installing RDoc documentation for gem_plugin-0.2.1...
Installing RDoc documentation for mongrel-0.3.13-mswin32...
Installing RDoc documentation for win32-service-0.5.0-mswin32...

Now that Mongrel is installed on our system, we have two commands that we have to use for every Rails application we have and want to run it using Mongrel, the first is where we install the service (check your Windows Services from Control Panel), to do this we have to change directory to the application we want to Mongrel it and then run the command:

cd D:\\webroot\\blog
D:\\webroot\\blog>mongrel_rails service::install -N blog -c D:\\webroot\\typo -p 4000 -e production
Mongrel service 'blog' installed as 'blog'.

Notice that in the above command we have specified the environment (using -e option) as production, and the port (using -p option) to be 4000 and we named the service “blog”, now the service is already installed on our Win32 system, we can run it from Control Panel -> Administrative Tools -> Services or by the command:

D:\\webroot\\blog>mongrel_rails service::start -N blog

Have a look at http://localhost:4000 now and see how it is working. You can leave Mongrel working on this specific port, or make an Apache proxy redirect to it, which is very similar to the first option we had for virtual hosts in FastCGI scenario but with two extra line:

Error: Could not open mongrel_apache.conf

This will redirect any request to “/” which is the root of the domain to the specific port 4000 at localhost where Mongrel is already running. Note that you have to enable the mod_proxy module from LoadModule section first to get this working

More information about Mongrel on Win32 systems can be found on Mongrel official website, I know this was a very long post, much longer than the previous two parts, but at the same I couldn’t help myself from pointing up some notes and important points that might save your time while preparing this setup, I hope this was useful and helpful.

Now with the end of this part, we have our local development environment ready to host any Rails application, actually it’s already hosting Typo blogging system, using Apache2 with FastCGI or Mongrel environments for a better performance, along with PHP and MySQL that we have installed in Part 2 and No-IP that we have installed in Part 1 to allow our local webserver to go live and online. In the next part (which is the last one), Subversion will be explained and installed, allowing us to collaborate better with our colleagues and friends, creating our own repositories or even using an external one, so stay tuned and hopefully it will be shorter than this one…

Now in Part two we will install MySQL as the Database server, and PHP with its integration with Apache using Apache Modules and finally we’ll install TurboDBAdmin script as the online database administration script.

MySQL Database

MySQL is a free SQL database management system, one of the most famous databases available now for open source development specially with PHP, many books have been written on both, it is also known as a key of both LAMP and WAMP the two most used open source development environments. Now let’s start the installation:

• Run the installation wizard downloaded in Part 1, and choose “Custom setup” in order to change the directory to your development path D:\development:

• “Skip Sign-UP” in the “MySQL.com Sign-Up” screen, unless you prefer to do so.
• After the installation wizard is done check the “Configure the MySQL Server Now” box in order to start the configuration wizard.
• In “MySQL Server Instance Configuration” choose “Standard Configuration”, then confirm that the “Install As Windows Service”, “Launch the MySQL Server automatically” and “Include Bin Directory in Windows PATH” options are checked.
• Now in the “Security Options”, as we have our server available online, we don’t want to allow any access to our MySQL server from outside, so we will set a password for our “root” user account and disable both anonymous account and remote access from remote machines options.

By setting the security options and finalizing the configuration wizard we have MySQL up and running on our local server, MySQL essential package doesn’t come with any graphical interface for the database system, so after we install PHP and integrate it with Apache we will install TurboDBAdmin as our graphical interface which will be available online as well.

PHP

I prefer the manual installation of PHP as it includes more extensions and it is more customizable, and luckily it is not difficult to do, just unzip the downloaded PHP compressed file (from Part 1) into your development directory D:\Development, and that’s it, PHP is there now, we only need to add it to the Windows PATH environment variables, and apply the PHP5Apache2 module.

To setup the Windows PATH variables go to Windows Control Panel -> System, and from the Advanced tab click on the “Environment Variables” button, in the System Variable section, edit the PATH variable and add your PHP path D:\development\php where php.exe exists, now wherever PHP is called it will be found.

Configuring Apache

In order to allow Apache to parse any PHP code placed in our web directory we have to load the PHP5 Apache2 Module, the module is available as a DLL file in our php directory under the name php5apache2.dll, we have to load it in Apache, add php file type and specify the PHP Ini Directory by adding the following lines to our httpd.conf file (located in D:\development\Apache2\conf\):

Error: Could not open httpd.conf

To keep your httpd.conf clean and organized insert the above lines in the DSO Support section right after the default modules loads, and don’t forget to restart Apache after saving the changes.

To test PHP let’s create a small PHP file that call the php information function in our webroot folder D:\webroot\info.php and let’s try it http://yoursubdomain.no-ip.org:8520/info.php

Error: Could not open info.php

The phpinfo() function shows all the information about PHP on the local server in a nice html markup. Now PHP is working perfectly, you can run any PHP script not only locally but online also as you have an online web server.

TurboDBAdmin

With our secure database and the ability to run PHP scripts, we will install TurboDBAdmin which is a PHP script with some lovely Ajax touches that gives a nice interface to our database, and we will secure it using .htaccess.

To run the script just unzip the downloaded TurboDBAdmin compressed file (from Part 1) to the webroot folder as D:\webroot\turbodbadmin\, and edit the configuration file D:\webroot\turbodbadmin\php\config.php to meet your database credentials, by changing the “root” password around line 10 to the one you have created earlier during MySQL configuration wizard.

Let’s try it now: http://yoursubdomain.no-ip.org:8520/trubodbadmin, it’s working and we are able to see our database system, create tables, import, export, etc… Great but this script is available online now and anybody who knows the url can mess up our database system so let’s secure this directory using http security.

Securing TurboDBAdmin

To secure our script we will use http security by creating .htaccess and htpasswd users file into the script directory, first lets create the user file:

• From the command prompt change directory to D:\development\Apache\bin\

  cd D:\\development\\Apache\\bin\\

• Use the htpasswd tool provided by Apache to create your users file with the user of your choice:

  htpasswd -c D:\\webroot\\turbodbadmin\\users admin

  It will prompt you for the password to create, and creates the file for you, if you want to add other users to your users file just use the same command without “-c” option:

  htpasswd D:\\webroot\\turbodbadmin\\users username

• Using a text editor of your choice create a new file as D:\webroot\turbodbadmin\.htaccess (notice the dot before the name):

  Error: Could not open htaccess

• Finally we have to change Apache configuration to allow AuthConfig, in httpd.conf in DocumentRoot Directory directive, you will find:

  # AllowOverride controls what directives may be placed in .htaccess files.
  # It can be "All", "None", or any combination of the keywords:
  #   Options FileInfo AuthConfig Limit
  #
      AllowOverride None
  

  Which we have to change into:

  AllowOverride AuthConfig

  Restart Apache now and check http://yoursubdomain.no-ip.org:8520/turbodbadmin/ and finally we have our script folder secured.

You can generate your own .htaccess and htpasswd files using .htaccess Tools website, it has some other nice features too.

Summary

After two parts of this article we have a complete WAMP environment, Apache 2, MySQL 5 and PHP 5 installed and working perfectly on our Win32 box, we also installed TurboDBAdmin script as our online graphical interface to administer MySQL, and secured it using Apache security.

In the next part I’ll be talking about Ruby and Rails and how to configure them on Windows as it needs a complete individual post to talk about it.

In this article I’ll share how I prepared this environment on my Windows XP system, it will cover the installation of a web server, mail server, database server, open source programming languages, version control, and some other quick tools too, all of the tools and applications used here are either open source or freeware, below are the links to download them before we start:

• Dynamic DNS: No-IP DUC (Dynamic Update Client) 2.2.1
• Web Server: Apache 2.0.55 for Windows.
• Mail Server: MailEnable Free Edition.
• Database Server: My SQL Essential 5.0.21.
• Programming Languages: PHP 5.1.4, Ruby 1.8.2-15.
• Version Control: TortoiseSVN 1.3.3 SVN 1.3.1.
• Tools: TurboDbAdmin 0.2.3, Notepad++ 3.5 and FileZilla 2.2

Just before we start let’s decide the directories we will use, I don’t recommend using the system drive for this (normally it’s Local Disk C:) in order to separate the development environment files from the system files, if you have another partition it would be much better but at the end it’s your own choice, mainly we will need two directories:

• development where we are going to place all the program files of our tools and servers.
• webroot as the web root folder where we will put our scripts and projects files.

Naturally you can use your own names and places for these folders, in this tutorial I’ll refer to them as D:\development and D:\webroot, now we have the files and the directory structure ready so let’s get to work.

No-IP Dynamic Update Client

No-IP is a dynamic/managed DNS service. Simply when you don’t have a static IP, installing the dynamic updater provided by No-IP will automatically update your dynamic IP to a given subdomain of your choice.

As a start you have to sign up for a free account, after signing up and verifying your email it’s time to setup your subdomain, to do that login to your account and from the left sidebar, under “Hosts / Redirects” choose Add:

Never simpler, in the Hostname field type a subdomain of your choice to be the address that will always redirect to your local machine, you can choose the domain on which you want your address to be, confirm that the Host Type is DNS Host (A), leave all the other options as is and Create Host.

Install the No-IP DUC that you have already downloaded earlier, choose the development path we have created D:\development to store the program files in. The first step after the installation is to enter the account details, the email address and password you signed up with, so we can reach our account window to see our hosts and activate them.

From the No-IP window go to Options, from the first tab Standard check the first and the third options that will make the dynamic updater Run on startup and Run as system service so you don’t have to worry about it anymore, if you use a proxy for your internet connection configure it from Connection -> Proxy. When you are done confirm your changes and close the Options dialog box.

Back to your No-IP window, the host you have created online is listed here with an empty checkbox next to it, checking this box will update your IP with this host, to test No-IP configurations you can either ping your subdomain from the command prompt and see if it’s replying with your IP or wait until we finish installing Apache and test your live web server.

Apache Web Server

Apache is an open-source HTTP server, Netcraft claims that more than 62.72% of the websites online uses Apache, which makes it the most commonly used web server, specially for open-source projects. It’s easy to use, secure, efficient and extensible.

Installing Apache

Run the installation file downloaded earlier (named apache_2.0.55-win32-x86-no_ssl.msi), accept the license agreement, read about Apache, and then let’s configure the server:

In this dialog box we will use the No-IP hostname that we have created few minutes ago yoursubdomain.no-ip.org for both Network domain and Server name, use your own email address as the administrator’s email and finally keep the last option on Port 80 as we will change it later.

Typical install is fine, then we have to choose the installation folder, as we have decided to keep all our development files in one directory we will choose D:\development as the path.

If you have any firewall installed (most likely Windows XP SP2) you may see some warning message after the installation is done, simply unblock and here we go, Apache is up and running and welcoming you at http://localhost.

Configuring Apache

The port, If you have such a great ISP like mine, that prevent you from enjoying the port 80, the only way to get your web server available online is by changing the port, we can do this by simply editing the httpd.conf file located inside D:\development\Apache2\conf\ folder.

Search for “Listen 80″ or simply go to line 120, now just change the port to your own, personally I use an easy to type number 8520, save and restart Apache from the system tray icon -> Open Apache Monitor -> Restart, let’s try again… http://localhost:8520 the same apache welcome page has just moved, now let’s simply test it with our online No-IP hostname and see if it will work, http://yoursubdomain.no-ip.org:8520. Pingo our server is online too.

Modules, Apache comes with the most used modules enabled already, but personally I recommend you uncomment the rewrite_module, dav_module and dav_fs_module as you may need them in your development, from httpd.conf file again simply remove the hash “#” from the beginning of each of the lines (145, 146, 164), save and restart Apache. We will add some more modules later when we will need them for our programming languages.

Document Root, You may like to change your web document root also, which is currently under the Apache2 folder with the name htdocs, to do that we have to change to paths in httpd.conf you can find them by searching for “DocumentRoot”, you will find the DocumentRoot and the Directory directives that have to be changed. (careful with the reversed slashes), we will use the one we have created earlier for this purpose D:/webroot, save and restart Apache and check the results http://localhost:8520.

You will get 403 Forbidden message as you don’t have access to the root directory, or in other words you don’t have access to the directory listing of the web root folder, as this option is important for security reasons we will not change it, you can solve it by adding a simple html page in our webroot directory and name it index.html.

More information about installing Apache on Windows platform can be found online at Apache website.

MailEnable

MailEnable Standard Edition is a freeware mail server with fully functional POP and SMTP mail services, which will allow us to send emails from our local server, mainly by connecting to a local SMTP server.

With the simplicity of its install MailEnable needs only two configuration steps during the installation process:

• Post office details, keep it simple, your name or your group name and a password, you will rarely need this.
• Domain name, DNS servers and SMTP port, the domain name is the same No-IP hostname we have created yourdomainname.no-IP.org and your DNS should be already loaded there.

Note: If the DNS details are not mentioned automatically and you don’t know them, simply go to Start -> Run -> type “cmd” and run, type the command: “ipconfig /all” and you will get all the information you need, you will see two IPs for the DNS server(s) just copy them with a comma in the middle.

Finally the SMTP port, only if your ISP blocks this port change it, otherwise it’s much better to leave the default port, if you change this port you will have to change it every time you configure any mail function in your scripts.

To be sure you got your installation right, just run the “Diagnostic Utility” (if you have an antivirus it will prompt you for a virus, just ignore it as it is part of the diagnostic test and not a real virus), check the following items in the html result file and ensure that they have all their sub-items passed the test:

• Host TCP/IP Settings
• SMTP Configuration Test
• SMTP Relay Settings
• SMTP Inbound Bindings Test
• SMTP Outbound Configuration

MailEnable is now installed successfully and any script that requires a mail server will use it as its SMTP server, it has many lovely features too, and a user friendly administration panel, you can find more about it on MailEnable - Standard Edition page online.

Summary

Now we have a local http server (Apache) and a mail server (MailEnable), available online (via No-IP) with our own hostname which we can access it from anywhere.

Part two of this article will cover the installation of a database server (MySQL), programming languages and their Apache modules, and then we are going to test them by trying some quick scripts too.