As full release of Ruby on Rails 3.0 draws near, I find myself collecting news, articles, and preparing myself for the transition. Here is what I’ve been reading so far:

• Reading material.
• Introduction.
• Approaching the upgrade.
• Getting up to speed.
• Upgrading to Rails 3.
• Automating a portion of the Rails 3 upgrade process with the rails-upgrade gem.
• Revamped Routes.
• Render Options.
• Active Record Query Interface.
• Understanding the ActionMailer API.
• Generic Actions.
• The Rails Module.
• Discovering Rails 3 generators.
• Validations.
• I18n changes.
• Signed and Permanent cookies.
• Creating new apps with the Rails 3 beta.
• Gem and Plugin Compatibility Checker.

I’m sure I’ll collect more as time rolls on. BTW, you can find these links and more on my Ruby page where I continue to capture useful Ruby information.

So Firefox 3.6 has been released and is ready for download. With it comes the challenge of determining whether some of your favorite extensions still work and, if not, what the alternatives are. Luckily, in my case, this version release didn’t cause too much trouble. Here are a few issues I ran into along with their solutions in case it is of interest:

1. Easy Drag and Go - I really love the ease of being able to drag links on any page and have them open in a background tab. Unfortunately, this extension no longer works. The equivalent is QuickDrag.
2. Obtrusive JavaScript Checker - I really hate obtrusive JavaScript code. It is bad coding practice, a maintenance nightmare, and truly ugly code to read. This tool helps detect and quickly flag web pages that are bad. Unfortunately, this extension has been broken for some time. The alternative is the Inline Code Finder extension for Firebug which is a much better solution overall.
3. Dust-Me Selectors - This was a cool tool for detecting what CSS code is being used or not used on a web page. I like having it around to keep my CSS code tight. The equivalent to this tool is CSS Usage (a Firebug extension).

For a list of all my favorite Firefox extensions or Firefox related info in general, check out my Firefox page.

I have a Canon PIXMA MP470 device. It’s a decent printer that doubles as a scanner. The device is perfect for my needs although I would argue that it eats printer ink a little faster than I’d like. Then again, I got it for free, so I can’t complain too much (well if you don’t calculate the long term cost of printer ink over time).

In the past, I used proprietary software that came with the device to scan documents. For printing support, I could easily detect and attach to the printer via Bonjour (as the device is plugged into an Apple Airport so all machines on the network can use it). In the case of scanning, I would have to attach the USB cable directly to my computer. There might be a way to do this via Bonjour but that eludes me at the moment.

Recently, I upgraded to Snow Leopard and discovered that I could scan documents using the native Image Capture application. Perhaps, you could do this in Leopard too? Anyway, this allowed me to no longer require installing Canon’s proprietary printer/scanner software. The only downside is that the Image Capture application doesn’t know how to combine multiple document scans into one PDF. Nor does the Preview application allow one to combine multiple PDFs into one PDF document either. Bummer.

The solution is to use Automator. I generally use Automator for quick image manipulation, resizing, etc but it also has decent PDF support. In my case, where I have several PDF files from multiple scans of a single document, I can use Automator to combine all these PDFs into one file. As part of Apple’s Automator action library, someone has already built an Automator worklfow that does exactly this. You can download the workflow and use it to combine multiple PDF files into one.

Something to think about if you are in a situation like this. It definitely does the trick for me.

I have released a simple GitHub project called MacOS Setup that makes configuring and using your MacOS easier. Here are a few highlights:

• Configures the .bash_profile file.
• Configures the .gitconfig file.
• Configures the .gitignore file.
• Configures the .irbrc file.
• Adds Looksee, Wirble, and Hirb support to your IRB and Rails consoles.

Feel free to fork the project for your own purposes if you like or simply maintain your own home files and then use this project for installation purposes.

Over a year ago, I write a post about my favorite Ruby feeds. I’ve since deleted that post in order to write about an updated set of Ruby feeds that you should be paying attention to (if not already). I read all of these feeds religiously on a daily basis and have broken them down below by general news and information followed by screencasts/tutorials. Enjoy.

News

• A Fresh Cup - My personal favorite. While you can find similar news via the links below, Mike Gunderloy does an excellent job of summing everything up in place for news, information, and new gems from the Ruby community.
• Ruby Toolbox - A great trending site for finding out what gems are hot and most popular within the Ruby community. This can save you a lot of time when you want to know which gem is the best solution for a problem that has already been solved.
• Ruby Trends - Another trending site. Useful for cross-checking against Ruby Toolbox on what is hot.
• Ruby News - Straight from the source. Find about new releases, conferences, developments, etc.
• Ruby Inside - The inside scoop on Ruby news.
• RubyFlow - A great site for picking up new resources to add to your development repertoire.
• RubyFu - Useful quick news and resource links.
• Ruby Best Practices - A great source of thoughtful discussion, including code samples, on how to write better code.
• Ruby5 - From some of the same guys who provide the Rails Envy podcast below. This is another podcast on Ruby news but in short, 5-minute, segments of usually discussing many of the new and interesting gems being developed.
• Rails Inside - Get the inside scoop on Rails news.
• Riding Rails - Learn what is happening with the Ruby on Rails team.
• Rails Spikes - A multi-authored site of Ruby developers discussing news, tips, code, etc.
• Rails Illustrated - Info on Rails, web design, and the user experience.
• Rails Notes - Another site worth checking out and picking up new learning.
• Rails Tips - As the site description goes: “One man, feverishly posting everything he learns.”
• The Rails Way - News and information dedicated to teaching best practices of Ruby on Rails.
• Ruby on Rails Security Project - A good place to read up on security issues or at least keep your mind in it.
• Giant Robots Smashing Into Other Giant Robots - Good development tips and tricks, mostly related to Rails.
• Ryan’s Scraps - Interesting news on what’s new and upcoming within the Rails code base. Includes code samples and detailed descriptions and examples of new Rails features.
• Has Many Through - Although he has a low writing frequency, the posts are enlightening.
• Rails Envy - An entertaining and informative weekly podcast dedicated to Ruby, Rails, and web framework news.
• Rails Podcasts - Ruby/Rails podcasts by Geoffrey Grosenbach of PeepCode fame.
• Rails Magazine - News, articles, and information about the Ruby on Rails framework.

Tutorials

• Railscasts - Short screen cast tutorials of Ruby on Rails code.
• Envy Casts - Produced by the same guys that host the Rails Envy podcasts. Each screen cast tutorial will set you back about $9.
• PeepCode - Screencast tutorials like Railscasts but longer in length and not free (roughly $9 per episode).
• Tekniqal - A collection of screencasts that cover some of the Ruby basics.
• Scaling Rails - A series of screencasts on detailing how to scale your Ruby on Rails application appropriately. Produced by Gregg Pollack of Envy Cast fame.
• BDD Casts - Video tutorials on all things related to Behavior Driven Development.

BTW, you can find this list and more on my Ruby page.

I have released a new Ruby on Rails template project called: Rails Setup Template. In truth, this is a renaming of the original Rails Setup project. I am planning on releasing other template projects in the future so this was cause for a little refactoring of my GitHub projects.

In addition to the original code, there are a few extra goodies including the use of the BlockUI JavaScript library for easily dealing with lengthy AJAX processes and some bug fixes. Check out the template when you have a chance, it’ll definitely make building your new Ruby on Rails projects easier. It is what I use for all new work and quick demos.

I have released a simple GitHub project called Ruby Gem Setup that makes setting up your Ruby Gems a little easier. Here are a few highlights:

• Ensures the Ruby Gem environment is at the latest version.
• Adds GitHub and Gemcutter as gem sources.
• Allows you to configure a setup.txt file that lists all your favorite gems for install.

Very handy, especially when managing gems for multiple versions of Ruby. Feel free to fork the project for your own purposes if you like or simply maintain your own setup.txt file.

For those wanting to set up a proper Ruby and Ruby on Rails development environment for your MacOS, I’ve created an OmniOutliner outline that I use. Its my personal guide to getting my development environment setup properly especially if one has erased and install the operating system from scratch.

When making the outline, I pulled heavily from the following articles (also found on my MacOS page) with a few modification here and there:

• A definitive upgrade guide
• Upgrade notes on developer tools
• A bunch of notes on getting your developer tools up and running without too much trouble
• How to get MySQL working

You can download the outline for your own use here:

• MacOS Ruby Development Setup 1.0.1

In the future, I hope to provide this outline in both original and HTML format but for now, I just have the OmniOutliner format. Apologies to those who don’t use OmniOutliner.

1. MacOS 10.6.0 (Snow Leopard Disk) - Insert the DVD, click the Utilities button, and click the Restart button. You’ll be booted into the Snow Leopard install at which point you’ll want to launch Disk Utility and format your hard drive (journaled). After you have wiped your hard drive, exit Disk Utility, and continue on with the Snow Leopard install.
2. XCode Tools (Snow Leopard Disk)
3. MacOS X 10.6.x Combo Patch (download)
4. Canon Printer Drivers/Utilities (download)
5. PathFinder (download)
6. OmniFocus (download)
7. OmniOutliner (download)
8. OmniGraffle (download)
9. Firefox (download)
10. Opera (download)
11. FileZilla (download)
12. Vienna (download)
13. 1Password (download)
14. Jing (download)
15. VLC (download)
16. Caffeine (download)
17. Coconut Battery (download)
18. iStat Menus (download)
19. TextMate (download)
20. VMWare Fusion (download)
21. Billings (download)
22. MoneyWell (download)
23. Delicious Library (download)
24. OpenOffice (download)
25. Skype (download)
26. Tweetie (download)
27. Lorem Ipsum widget (download)
28. Logitech Harmony 890 remote software (download)
29. Startup Sound
30. Carbon Copy Cloner (download)
31. Software Updates (via the Apple icon, requires a couple reboots)

You can learn more about some of these apps on my Applications page. Also, since I’m one of those who likes organization, I wrote a post on data management a while back that sheds further light on how I manage my apps and the data related to them in case it is of interest (Note: even though the post was originally written for Windows some of the concepts still apply for the MacOS).

A new version of the REST 1.1.0 gem has been released. Here are the highlights:

• Clarified the readme documentation.
• Updated the JavaScript code so that events are bound for current and future instances instead of just once.
• Fixed a JavaScript bug where deleting nested inputs on a new form would cause an exception.
• Updated the JavaScript code so that new records are initially hidden.
• Updated the JavaScript code so the last record of a form is not deleted. Contents will be cleared and hidden (if last element).
• Applied fade in/out effects when adding/destroying input forms.
• Removed the hiding of the delete link via the various resource helpers.
• Modified the JavaScript incrementNumber(string, position) function for better handling of complex nested Rails model forms.
• Renamed all forms of the “new” action UJS classes to a single “new” class. Use the data-type attribute to distinguish type.
• Applied “group” and “record” classes to distinguish between a group of records and a single record. Very handy for creating and/or destroying form elements.
• Renamed the various resource helpers to be aware of input elements (this affects the destroy helpers mostly).
• Added default option support for the Will Paginate gem requirement (use config/initializers/pagination.rb to change settings).
• Renamed all “show_” helpers to “render_” helpers.
• Added a render_show_link helper.
• Added a render_new_link helper.
• Added a render_edit_link helper.
• Added icons for show, new, edit, and destroy actions. All corresponding helpers default to these icons.
• Changed the rendering of partials to templates for all REST actions.
• Added the ability to supply an index template if you wish to override the default index action behavior.
• Added basic AJAX handling for the destroy action so that a response can be sent back to the JavaScript caller.
• Moved all JavaScript REST functionality into a proper jQuery plugin.
• Renamed the “ujs_setup” generator to “rest_setup”.

These same notes can be also be found by viewing the CHANGELOG. I also recommend viewing the OmniGraffle design document on how the form layouts are to used by the unobtrusive jQuery code when creating your views.

The initial version release of my Acts as Commentable gem is available for use. Here are the highlights.

• Wanted a gem, couldn’t find one, built my own with the notion that I’ll probably be adding more to this in the future.
• Supports an auto label feature in case you find that handy.
• It doesn’t get any simpler than this (for a gem that is).

Visit the GitHub page to learn more.

Sometimes, when working with IRB or the Rails console, you might need a list of methods on a particular class or object. You don’t necessarily need to consult the doc because it is one of those situations where you would know the method if you saw it. So what do you do? Well, one trick is to use the select method (passed via a block) on a collection of methods. You can always start by asking the class for its methods by typing the following:

Hash.methods

Which yields:

["require_dependency", "decode_b", "write_inheritable_hash", "model_name", "breakpoint", "require", "delegate", "taguri", "const_missing", "new", "class_inheritable_hash", "suppress", "methods", "andand", "method", "allocate", "attr_internal_reader", "protected_instance_methods", "deprecate", "taguri=", "subclasses", "cattr_accessor", "include?", "daemonize", "taint", "present?", "class_eval", "alias_method_chain", "instance_variable_defined?", "yaml_tag_class_name", "name", "find_hidden_method", "reset_inheritable_attributes", "metaclass", "autoload", "to_yaml_style", "class_variables", "parent", "inheritable_attributes", "__id__", "singleton_methods", "synchronize", "dclone", "private_instance_methods", "object_id", "subclasses_of", "respond_to?", "nil?", "ancestors", "yaml_tag_read_class", "parent_name", "tap", "__send__", "require_library_or_gem", "protected_methods", "require_or_load", "me", "tainted?", "attr_internal_writer", "remove_class", "class_inheritable_reader", "untaint", "instance_of?", "autoload?", "b64encode", "included_in_classes", "equal?", "method_defined?", "with_options", "const_missing_without_dependencies", "display", "class_variable_defined?", "private_methods", "hash", "instance_method", "send", "constants", "deprecation_horizon", "instance_values", "`", "attr_internal_accessor", "yaml_tag_subclasses?", "class_inheritable_writer", "kind_of?", "enable_warnings", "freeze", "eql?", "public_method_defined?", "to_json", "id", "returning", "parents", "write_inheritable_attribute", "dont", "acts_like?", "require_association", "public_methods", "instance_eval", "superclass_delegating_reader", "instance_variable_names", "attr_internal", "const_get", "to_enum", "class_inheritable_array_writer", "is_a?", "silence_stderr", "private_method_defined?", "cattr_reader", "type", "const_missing_with_dependencies", "local_constants", "superclass", "write_inheritable_array", "instance_variables", "frozen?", "blank?", "attr_internal_naming_format", "const_set", "copy_instance_variables_from", "enum_for", "class_inheritable_hash_writer", "silence_stream", "to_a", "to_param", "mattr_reader", "protected_method_defined?", "attr_internal_naming_format=", "extended_by", "silence_warnings", "class", "public_class_method", "encode64", "from_xml", "instance_variable_get", "<=>", "to_yaml", "load_with_new_constant_marking", "==", "superclass_delegating_writer", "method_added", "class_inheritable_accessor", "===", "duplicable?", "extend", "to_s", "to_query", "alias_attribute", "instance_methods", ">=", "remove_subclasses", "extend_with_included_modules_from", "mattr_writer", "<=", "cattr_writer", "local_constant_names", "clone", "private_class_method", "decode64", "read_inheritable_attribute", "const_defined?", "yaml_as", "included_modules", "debugger", "=~", "instance_variable_set", "<", "superclass_delegating_accessor", "deprecated_method_warning", "attr_accessor_with_default", ">", "class_inheritable_array", "inspect", "[]“, “remove_subclasses_of”, “instance_exec”, “try”, “mattr_accessor”, “public_instance_methods”, “as_load_path”, “to_yaml_properties”, “unloadable”, “dup”, “module_eval”]

OK, yeah, that’s a bit overkill. How about we narrow it down to the types of methods (using the select method with a regular expression):

Hash.methods {|m| m.select =~ /methods/}

Which yields:

["methods", "protected_instance_methods", "singleton_methods", "private_instance_methods", "protected_methods", "private_methods", "public_methods", "instance_methods", "public_instance_methods"]

Ah, much better. …but I’m not quite there yet. Lets say I know it’s an instance method and it is a type of “to” method. I could then type the following:

Hash.instance_methods {|m| m.select =~ /to_/}

Which yields:

["to_yaml_style", "to_hash", "to_set", "to_xml", "to_json", "to_enum", "to_options", "to_a", "to_param", "to_yaml", "to_options!", "to_s", "to_query", "to_yaml_properties"]

OK, now I remember, it was the “to_yaml” method that I was looking for!

This, of course, is a contrived example. However, if you know what type of method you are looking for and part of its name, then this is a quick and effective way of getting back a subset of methods from which you can gauge what it is that you’re looking for.

Where I tend use this most (as of late) is with Rails models that accept nested attributes (i.e. accepts_nested_attributes_for). For example:

Recipe.instance_methods {|m| m.select =~ /attributes/}

["update_attributes!", "comments_attributes=", "reject_new_nested_attributes_procs", "attributes", "attributes=", "time_zone_aware_attributes", "respond_to_without_attributes?", "update_attributes", "skip_time_zone_conversion_for_attributes", "user_recipe_attributes=", "ingredient_groups_attributes=", "attributes_before_type_cast", "instructions_attributes=", "sources_attributes="]

So there you have it, in case it is of help.

If you have the unfortunate experience of having to deal with Oracle databases you might run into an interesting problem with default scopes where Oracle spits back the following error:

ORA-00933: SQL command not properly ended: UPDATE post SET post_gid = NULL WHERE ((post_gid = 2060)) ORDER BY name

The problem, if you guessed it, is that you can’t add an ORDER clause to the end of an UPDATE statement in SQL. It is invalid syntax. This happens because you might have done something like this in your Post model:

class Post < ActiveRecord::Base
# Named Scopes
default_scope :order => "name"
end

I really like to use default_scope on my models when apt. However, with Oracle, you might as well forget about that until Rails is patched (which I suppose I should do once this aggravates me more). The workaround is to not use default scopes but, instead, used named scopes, define them as conditions to your finds (usually index actions), and/or has_many associations. For example:

Named Scope

class Post < ActiveRecord::Base
# Named Scopes
named_scope :default, :order => "name"
end

This will work nicely but if you need to pass additional conditions, you’ll still need to do the following:

Post.default.all(:conditions => {:name => "Once Upon a Time"})

Index Action

Post.all :order => "name"

Has Many Association

class User < ActiveRecord::Base
# Associations
has_many :posts, :order => "name"
end

Obviously, not as elegant as defining them in one location but it’ll get you by.

(click to view)

By clicking Tweetie’s sidebar you can quickly jump from tweets you have composed, see replies, direct messages, and search. You can also use global keyboard shortcut to enter tweets. In my case I use CTRL+OPTION+COMMAND+T often to bring up a dialog to enter a quick tweet:

(click to view)

Notice that you can also use keyboard shortcuts to quickly convert long URLs to short ones. The only downside to using the keyboard shortcut is that the dialog only pops up in the Leopard Space from which you originally launched Tweetie (focus is switched to that Leopard Space as well). I was expecting the OmniFocus QuickEntry dialog behavior which works from any Leopard Space. I messaged the developer about this and the response was that it is not easy to do but is looking into it. If that can get fixed, I would be tempted to buy the app even though the ad-supported, free version is not that annoying.

If you are like me, writing the same code over and over for the seven REST actions in a Ruby on Rails RESTful controller gets old really fast. In order to circumvent this monotony, I’ve released a REST gem to make life easier.

This means you can write code like this:

class Posts < ApplicationController
include Rest
end

…and you get the following working actions for free:

• index
• show
• new
• edit
• create
• update
• destroy

Not too shabby, eh? It can also handle nested resources and namespaces too. Oh, and it gets better, as there is a ujs_setup generator included in the gem in case you want to drop the default Prototype/Scriptaculous libraries and start using unobtrusive jQuery. You don’t even need to worry about bypassing forgery security within your controllers for AJAX requests. I’ve taken care of all of that for you.

So what are you waiting for, grab the gem and run the ujs_setup generator. If you want to get really fancy with jQuery support then run my rails_setup template before adding this gem into a new or existing Ruby on Rails project.

I won’t tell anyone that you built your app in less than 5 minutes. I’m a slacker too.

Have you ever wanted to do more with the Ruby on Rails select helper in your form views? Well, now you can make use of the full HTML spec for options with in a select element with my new enhanced_select gem.

To install, use the following command line:

sudo gem install aeonscope-enhanced_select

Then you can write code like this:

@schools = [{:value => 1, :class => "private", :text => "Goldbugs"}, {:value => 2, :class => "public", :text => "Falcons"}]
<%= form.enhanced_select :id, @schools, :include_blank => "-select-" %>

…which yields the following your view:

<select id="<auto filled>" name="<auto filled>">
<option value="">-select-</option>
<option value="1" class="private">Goldbugs</option>
<option value="2" class="public">Falcons</option>
</select>

Check out the GitHub page to learn more.

So I have become a GitHub fan (powered by Git, obviously). It is free to use if you are developing open source code or you can pay various service fees to have GitHub host your private code. As for me, I’m working on a few open source projects. Three, of which, are live now.

…but I learned a few lessons along the way. I thought I’d share what I learned in case you might be curious.

Make everything a gem when apt

They are easy to develop and manage. Plus they are version controlled and simple to configure within a Ruby on Rails app. I made the mistake of developing Ruby on Rails plug-ins initially and have finally converted all my plug-ins to gems now. Plug-ins, it seems, are going the way of the Dodo.

Be wary of your user account.

When you register with GitHub, pick a user account that you want to stick with as all software associated with your username will be prefixed to your code (this is especially critical with gems). In my case, I use “aeonscope” which yields the following gem install command line: sudo gem install aeonscope-XXX. The installed gems will also show up on your file system with the same “aeonscope-” prefix. You don’t, however, have to name your libraries in this manner which means that your Rails configurations will not match. Lets take a closer look:

• GitHub Login: aeonscope
• GitHub Project: rest
• GitHub Project Path: http://github.com/aeonscope/rest
• Gem Install Command: sudo gem install aeonscope-rest
• Ruby on Rails Configuration (via environment.rb): config.gem "aeonscope-rest", :lib => "rest"

Notice when you configure my gem in Rails, you must specify “rest” instead of “aeonscope-rest” for the library. This is because I don’t want to namespace my Rails code with “aeonscope”. I debated as to whether this was wise and, in the end, decided it was lame to force namespaces. I like the fact that gems are installed and stored on your local file system with the namespace but once you configure the gem in Rails you then specify the library without the GitHub login prefix.

Know your tools

Save yourself some setup time by using Jeweler to craft your gems. Once you have released your new gem, you can check if it has built. The rest is a just a matter of reading the GitHub docs and learning about Git in general.

With that in mind, I was playing with a Firebug extension called Firebug UJS. I really enjoyed this tool because it allowed you to see UJS behavior within the DOM while investigating code in Firebug. Cool! Only problem is that it totally hosed most of my jQuery enabled pages. In fact, if you install this plugin and try to view the jQuery UI demos, you’ll be in a world of hurt.

While the extension is a nifty idea, I would recommend saving yourself time and frustration by not installing this. If you want a list of extensions you might want to be using, then check out my Firefox page for more info.

Overview

The following a guide to configuring Phusion Passenger on Ubuntu for serving up your Ruby on Rails applications.

Requirements

It is assumed that you are familiar Ruby, Ruby on Rails, Apache, Phusion Passenger, and Ubuntu. It is also assumed that you have a Ubuntu Server or VM setup and configured with a proper server stack that includes Apache, MySQL, Ruby, Ruby on Rails, etc. You can learn how to setup and configure a fresh Ubuntu Server by reading my Ubuntu page before preceding.

Setup

Phusion Passenger will warn you of missing software but lets go ahead and beat Phusion Passenger to the punch by executing the following commands from the command line:

1. sudo apt-get install libopenssl-ruby
2. sudo apt-get install apache2-prefork-dev

Now we can install Phusion Passenger:

1. sudo gem install passenger
2. sudo passenger-install-apache2-module

 
Apache Configuration
 
Edit the /etc/apache2/httpd.conf or /etc/apache2/apache2.conf file (depending on how your server is setup, use one or the other but not both) by adding the following to the end of the file:

• LoadModule passenger_module /usr/lib/ruby/gems/1.8/gems/passenger-2.0.6/ext/apache2/mod_passenger.so
• PassengerRoot /usr/lib/ruby/gems/1.8/gems/passenger-2.0.6
• PassengerRuby /usr/bin/ruby1.8
• PassengerDefaultUser www-data

NOTE: Be mindful of the Phusion Passenger version as you might need to adjust the version numbers for your particular release. Otherwise, just use the notes provided for you during the Phusion Passenger install.

Finally, execute the the following commands from the command line:

1. sudo usermod -a -G www-data <your user login>
2. sudo a2enmod ssl

The first command ensures the default www-data user group is group to your primary user account owning the server files. Otherwise, Phusion Passenger will assume to run the Rails app as root which might cause problems. The last command tells Apache to enable SSL support (you might or might not want this).

Apache Non-Secure Virtual Hosts

Edit your virtual host file (example: /etc/apache2/sites-available/example) so that the following is used:

NameVirtualHost *:80
<VirtualHost *:80>
ServerName one.example.com
DocumentRoot /web/one/public

<Directory /web/one/public/ />
Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all
</Directory>
</VirtualHost>

Repeat the <VirtualHost/> block for each Rails site you want to setup.
Restart Apache to pick up the new changes by executing the following command line: sudo /etc/init.d/apache2 restart

Apache Secure Virtual Hosts

Edit your virtual host file (example: /etc/apache2/sites-available/example-ssl) so that the following is used:

NameVirtualHost *:443
   <VirtualHost *:443>
      ServerName www.yourhost.com
      DocumentRoot /somewhere/public

SSLEngine on 
      SSLCertificateFile    /etc/ssl/certs/<your server name>.crt
      SSLCertificateKeyFile /etc/ssl/private/<your server name>.key
   </VirtualHost>

Repeat the <VirtualHost/> block for each Rails site you want to setup.

NOTE: While this setup will allow you to host multiple secure Rails sites it will not allow you to use a different SSL certificate for each as that is impossible. Even if you change the SSL certificate for each virtual host only the first one defined will be used.

Restart Apache to pick up the new changes by executing the following command line: sudo /etc/init.d/apache2 restart

How to Generate Your Own SSL Certificates

Run the following commands to create a temporary SSL key and certificate for testing with your applications:

1. openssl genrsa -des3 -out server.key 1024
2. openssl req -new -x509 -nodes -sha1 -days 365 -key server.key -out server.crt

Make sure to copy these files to the appropriate location by executing the following commands:

• mv server.crt /etc/ssl/certs/<your server name>.crt
• mv server.key /etc/ssl/private/<your server name>.key
• chmod 400 /etc/ssl/certs/<your server name>.crt
• chmod 400 /etc/ssl/private/<your server name>.key

The files names and paths need to match as to what you entered in your virtual host file for port 443 (as mentioned above).

NOTE: To get up and running quickly without creating your own SSL keys and certificates, simply use the snake oil files as listed in the /etc/apache2/sites-available/default-ssl Apache configuration file.
 
Resources

• PeepCode Phusion Passenger Screencast
• Apache SSL FAQs
• How to Create a Self-Signed SSL
• A Day in the Life of Apache

Introduction

Ruby on Rails is a web framework built on top of the Ruby programming language that focuses on convention over configuration to get things done. It was originally developed by David Heinemeier Hansson at 37signals for the Basecamp application. Eventually, the framework was extracted from Basecamp, open sourced, and is now known as Ruby on Rails. It is also a total pleasure to work with.

Requirements

It is assumed that you have knowledge of the Ruby language and a working development environment in order to make use of this post. Read my Intro to Ruby article series if you need further instruction.

Literature

1. Build Your Own Ruby on Rails Web Applications by Patrick Lenz - This was the first book that I read on the Rails framework that walks you through building a simple web application from start to finish. Something to consider but you might enjoy the book listed below better.
2. Agile Web Development with Rails, Third Edition - Have not read this book myself as of yet but have heard very good things about it.
3. RESTful Rails - A free PDF available for download. While knowing the REST architecture is not a prerequisite to developing Ruby on Rails applications, I would strongly recommend that you take time to understand how to use it. You’ll be glad you did.

API

Good bookmarks to have on hand are:

• API Doc - Provides quick keyword search capabilities as well as community comments for Ruby and Ruby on Rails. My personal favorite.
• Got API - An alternative to API Doc but not as easy on the eyes. Depends on your temperament, of course.

News

The following feeds are worth adding to your feed reader in order to stay connected with the community:

• Rails Inside - Get the inside scoop on Rails news.
• Riding Rails - Learn what is happening with the Ruby on Rails team.
• Rails Spikes - A multi-authored site of Ruby developers discussing news, tips, code, etc.
• Rails Illustrated - Info on Rails, web design, and the user experience.
• Ruby on Rails Security Project - A good place to read up on security issues or at least keep your mind in it.
• Giant Robots Smashing Into Other Giant Robots - Good development tips and tricks, mostly related to Rails.
• Rails Envy - An entertaining and informative weekly podcast dedicated to Ruby, Rails, and web framework news.
• Rails Podcasts - Ruby/Rails podcasts by Geoffrey Grosenbach of PeepCode fame.

Tools

Using a simple text editor like TextEdit (MacOS) or Notepad (Windows) will do just fine for starters. However, you might consider the following tools as better alternatives to simple text editors:

• TextMate - Lightweight, fast, and costs $30. For the MacOS platform only.
• NetBeans - Developed by Sun and free to use. Works on multiple platforms.
• Aptana - Adds Ruby on Rails support to the Eclipse IDE. Visit the software update site to install directly into Eclipse.

I am a MacOS guy, so TextMate is my development tool of choice when writing Ruby code. However, if you are not on the MacOS I would recommend Netbeans as it is less buggy than Eclipse (although I do like the Eclipse UI better).

In addition to the tools mentioned above, you might consider installing the SQLite Manager Firefox add-on for quick and easy access to your SQLite3 database. You can find this and other recommended plugins for Firefox on my Firefox page.

Installation

Installation and setup is as simple as installing a few Ruby gems. Execute the following commands from a command line in the following order:

1. sudo gem install rails
2. sudo gem install mongrel
3. sudo gem install sqlite3-ruby

When you generate a rails app it will default to using the SQLite3 database. Feel free to install MySQL or some other database for your development needs. The Mongrel gem installs a web server stack for running your Rails application. By default, you can run Rails on WEBrick but I recommend using Mongrel instead.

Creating a Rails App

To create your first Rails app, open a terminal window in a working directory of your choice. Then execute the following command:

rails MySpiffyApp

This will create a new folder in your working directory called “MySpiffyApp”. Inside this directory you will have set of files and folders that represent the default Rails web application structure. Make sure to read the README file located in the root of “MySpiffyApp” directory to make sense of the file and folder structure.

Running Your Rails App

Right, so now you have a Rails app but how do you run it? While still in your terminal window, change to the root of your Example project folder and type:

script/server -u

This will launch your Rails app with debugger support enabled (i.e. the “-u” option). To view your app, just plug this address in your web browser: http://localhost:3000

Congratulations, you have successfully installed Rails, built a Rails app, and seen it running!

Next Steps

I will be releasing various bits of code in the future that will make building your Ruby on Rails apps easier. Stay tuned if you want to learn more and don’t be afraid to send me some feedback as comments are always welcome.