Overviews

Rails 3.0 Release Notes - RailsGuides is an invaluable resource for all Ruby on Rails developers. The Rails 3 release notes provides a great overview the api changes and new features added to the framework.

RailsPlugins.org – Find out if your plugins work in Rails 3.

Having Ruby on Rails 3 My Way - A tutorial on how to setup Rails 3 with Mongoid, Haml, jQuery, and RSpec with Factory Girl.

The Rails Module (in Rails 3) - Nick Quaranto outlines some helpful methods in the Rails module.

Rails 3 I18n changes - A quick walkthrough the changes made to I18n.

Ruby on Rails 3 Screencast series - The official Ruby on Rails site screencast series by Gregg Pollack.

ActionController / Rack

Embracing REST with mind, body and soul - José Valim introduces RESTful responders within Rails 3 controllers.

Railscasts #224 Controllers in Rails 3 – Ryan shows us what’s new with Rails 3 controllers.

Render Options in Rails 3 - Yehuda goes through the rendering options available in Rails 3.

Adding Routes for tests / specs with Rails 3 - Jeff Dean outlines how to verify routes in our specs.

32 Rack Resources to Get You Started - A great collection of links to get you familiar with rack.

ActionMailer

New ActionMailer API in Rails 3.0 - Mikel Lindsaar demonstrates how to use the new ActionMailer.

A Whole New ActionMailer - Mikel Lindsaar’s Rails Dispatch post giving a tour of the ActionMailer features.

ActiveRecord/ActiveModel

ActiveModel: Make Any Ruby Object Feel Like ActiveRecord – Yehuda writes about the modularity of ActiveModel.

Railscasts #219 Active Model - See how to include certain ActiveModel modules to tableless models.

ActiveRelation: ActiveRecord Gets a Facelift - Carl Lerche introduces the new ActiveRecord finder api.

Active Record Query Interface - Pratik gives an overview of the changes made to the ActiveRecord query interface since Rails 2.

Bundler

Gembundler.com -The official project site for Bundler that includes extensive documentation.

Library Management Gets an Update in Rails 3 - Andre Arko gives an overview about bundler for the Rails Dispatch blog.

Railscasts #201 Bundler - A Railscasts by Ryan Bates demonstrating how to use bundler with Rails 3.

AdventuresInCoding.com screencast on Bundler – Our very first screencast from last February.

Railties

Rails 3 Internals: Railtie & Creating Plugins - Ilya Grigorik goes over Railties in Rails 3.

rails-templater - A template project which generates a greenfield Rails 3 application.

Making generators for Rails 3 with Thor – A tutorial showing you how to use the new generators and how to bundle them in a gem.

Routes

The Lowdown on Routes in Rails 3 - Rizwan Reza gives us a great summary of all the different ways to create routes in Rails 3.

Rails Routing from the Outside In - RailsGuide documentation about the new router.

Plugins

Plugin Authors: Toward a Better Future - Yehuda goes through the changes for making plugins in Rails 3.

Customizing Rails Apps with Plugins - José Valim gives an overview of using responders, simple form, devise, and mail form plugins.

Devise 1.1 is out and ready to rock with Rails 3 - Outlines some new feature in Devise 1.1 including being able to authenticate a given url in the router!

Books

Beginning Rails 3 – Cloves Carneiro Jr and Rida Al Barazi bring us a great beginner Rails 3 book with examples viewable in gists.

The Rails 3 Way - The ultimate Ruby on Rails reference by Obie Fernandez.

Rails 3 In Action - Ryan Bigg and Yehuda Katz deliver a great Rails book which teaches readers Rails by doing BDD with Cucumber and RSpec.

Rails 3 Upgrade Handbook - Jeremy McAnally’s book gives you 120 pages of information about upgrading your Rails 2 application to version 3.

Ruby on Rails Tutorial: Learn Rails by Example – Michael Hartl’s ebook that teaches Rails step by step.

Update:  Rails 3.0.0 was released on August 29th, 2010. To get more details, be sure to read the official announcement.

For those who are unfamiliar with inheritance, it allows us to extend a previously existing entity and supplement it by adding methods/properties to create an entirely new entity. It is an amazing way to reuse code!

Here is Wikipedia’s definition:

“In object-oriented programming(OOP), Inheritance is a way to compartmentalize and reuse code by creating collections of attributes and behaviors called objects which can be based on previously created objects”

There are a variety of JavaScript frameworks that provide a means to perform classical inheritance. Some of these include Prototype, MooTools, and ClassJS. This is a great option for a team where most of the developers come from other object-oriented languages. Even though the above implementations are viable solutions, Douglas Crockford suggests the ideal solution is to use the prototypal inheritance, which has objects inheriting from other objects

Implementation

In JavaScript everything is an object, there is no concept of a class like other object-oriented programming languages. With prototypal inheritance, we implement inheritance by creating objects which will act as prototypes for other objects.

My favourite implementation comes from Stoyan Stefanov’s book Object-Oriented JavaScript: Create scalable, reusable high-quality JavaScript applications, and libraries. Here is my slightly modified version of a function which abstracts the creation of a child object:

function object(parent, supplements){
  /*  Create a variable that will store our child object. */
  var child;

  /*  Create an empty function F which will act as an intermediary between
      the parent and the child. F will have no properties of its own.	*/
  function F() {};

  /*  Assign the parent constructor to the prototype of F.
      This will allow the child to copy all the parent’s properties without
      having to set it’s prototype to the parent instance. */
  F.prototype = parent;

  /*  Create a new child object from F. We get a copy of all the parent’s properties.
      Functions/objects are copied by reference. */
  child = new F();

  /*  Define a property uber which points to the parent object. Simulates super
      from other languages. */
  child.uber = parent;

  /*  Add any functions/properties desired for the child object. */
  for(var i in supplements){
    child[i] = supplements[i]
  }

  return child;
};

Example

Here is a basic example displaying how the properties are copied and overridden in a parent/child relationship.

var parent = {
  firstName: "William",
  lastName: "Adama",
  fullName: function() {
    return this.firstName + " " + this.lastName;
  }
};

var child = object(parent, {
  firstName: "Lee"
});

child.fullName(); // "Lee Adama"
parent.fullName(); // "William Adama"

We can implement another version of fullName() that indicates William is Lee’s father without removing the parent function.

child.fullName = function(){
  return this.uber.fullName() + "'s child " + this.firstName;
};

child.fullName(); // "William Adama's child Lee"
parent.fullName(); // "William Adama"

We can even remove our child’s fullName() function and still have access to out parent’s function because it exists in the child’s prototype chain.

delete child.fullName
child.fullName(); // "Lee Adama"

Benefits

The benefit of using prototypal inheritance is that we are working with the strengths of JavaScript and not trying to imitate features of another language.

Not only does it provide an easy way to do inheritance, but there is a performance boost as well. When a function is defined in an object, they are created by reference, resulting in all child objects pointing to the same function and not creating their own copies. This can also lead to some issues if you are unaware of this. If you do not want to share any objects or functions in your child object, make sure to supplement them. Any functions/objects you create in your child object will take precedence over the parent’s version.

Out in the Wild

In the latest ECMAScript 5 standard, prototypal inheritance became a first class citizen as a new native method Object.create(proto [, propertiesObject ]) was added. It allows you to create a new object with the specified prototype object and properties. You can also use it today in YUI 3 via the Y.Object(…) function from YUI core.

First you will need to setup your Rails 3 application to use Mongoid, Cucumber, RSpec, and Factory Girl. Once you have a project skeleton, you will need to setup RSpec to drop all the MongoDB collections of the project before each spec is run to ensure a clean test harness.

The best command to drop your MongoDB collections comes from Mongoid creator Durran Jordan in Mongoid’s code base:

Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)

RSpec

Here is a sample RSpec configuration which will empty your MongoDB db and also use Factory Girl to create your models. Note that config.user_transactional_fixtures is commented out.

# spec_helper.rb

ENV["RAILS_ENV"] ||= 'test'
require File.expand_path("../../config/environment", __FILE__)
require 'rspec/rails'
require 'remarkable/active_model'
require 'remarkable/mongoid'
require 'factory_girl'

# Requires supporting files with custom matchers and macros, etc,
# in ./support/ and its subdirectories.
Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

RSpec.configure do |config|
  config.mock_with :rspec

  # If you're not using ActiveRecord, or you'd prefer not to run each of your
  # examples within a transaction, comment the following line or assign false
  # instead of true.
  # config.use_transactional_fixtures = true

    config.before :each do
      Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
    end

end

Cucumber

Cucumber allows defining hooks in any file under the features/support directory. To begin setting up Cucumber, first create a file features/support/hooks.rb that will drop your MongoDB collections before each scenario.

# features/support/hooks.rb

Before do |scenario|
    Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
end

I also find that using Factory Girl for my Cucumber scenarios makes my life a lot easier. Below is an example features/support/env.rb file which will import all your factories. It will also provide some already defined step definitions by the guys at thoughtbot. Be sure to read about them in their post gimme three steps.

# env.rb

ENV["RAILS_ENV"] ||= "test"
require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')

require 'cucumber/formatter/unicode'
require 'cucumber/rails/rspec'
require 'cucumber/rails/world'
require 'cucumber/web/tableish'

require 'capybara/rails'
require 'capybara/cucumber'
require 'capybara/session'
require 'cucumber/rails/capybara_javascript_emulation'

Capybara.default_selector = :css

ActionController::Base.allow_rescue = false

require 'factory_girl'
require 'factory_girl/step_definitions'
Dir[File.expand_path(File.join(File.dirname(__FILE__),'..','..',
  'spec','factories','*.rb'))].each {|f| require f}

All the step definitions from factory_girl/step_definitions work except for “create record & set one attribute”:

Given an author exists with an email of "author@example.com"

The reason for this is because in the Factory girl code, theere is a check that determines if the given model responds to :columns. To get around this, add the following code to a new file features/step_definitions/mongoid_steps.rb:

# features/step_definitions/mongoid_steps.rb

Given /^an? (.+) exists with an? (.+) of "([^"]*)"$/ do |model, field, value|
  factory_name = model.gsub(' ', '_')
  Factory factory_name, field => value
end

The last thing to do is stub out the rake task for db:test:prepare. The Cucumber rake tasks are still dependent on the ActiveRecord test workflow and will attempt to load the db schema into the test db. Create the  file lib/tasks/mongo.rake to get around this:

Update: As of version 2.0.0.beta.14 of mongoid, a stubbed rake task for db:test:clone is included.

# lib/tasks/mongo.rake

namespace :db do
  namespace :test do
    task :prepare do
      # Stub out for MongoDB
    end
  end
end

Finally, if you don’t want to do this everytime you setup an application, I’ve updated rails-templater to do the above steps automatically.

To simplify things further, I have started a template project called rails-templater. It is inspired by Mike Gunderloy’s BigOldRailsTemplate project which provides templates for Rails 2.3.x projects. To get started, clone the rails-templater repository to your hard drive:

% git clone http://github.com/kfaustino/rails-templater.git

When you are ready to create a new Rails 3 application, run:

% rails new app_name -JOT -m \
 /path/to/rails-tempater/templater.rb

Optionally you can also use Compass as your stylesheet framework and Cucumber for integration testing.

I will be continuously making updates to the project by adding new recipes and template options.

Be sure to check out the project GitHub page.

Photo credit: Railroad in Crestwood by dystopos

My ideal application stack consists of Mongoid as my ODM, Haml as my template engine, jQuery as my JavaScript framework, RSpec as my testing framework, and factory_girl as my fixture replacement.

I will outline how to setup each of these individually for your Ruby on Rails 3 application.

To begin, generate a new Rails 3 application with the following command:

% rails new app_name -TOJ

The flags passed into the rails command will remove certain elements from the generation of our application.

Replacing ActiveRecord with Mongoid

Mongoid is an Object Document Mapper for MongoDB. It has a beautiful chaining criteria dsl for queries and is optimized for extremely large datasets.

To add mongoid to your project, add the following to your Gemfile:

gem ‘mongoid’, ‘>= 2.0.0.beta14’
gem ‘bson_ext’, ‘1.0.4’

Mongoid provides a generator to setup your project to create mongoid documents for model generation and setup a sample database connection configuration. To run this generator, first execute bundle install to ensure all missing dependencies are installed. Finally, run the mongoid:config generator:

% rails g mongoid:config

Replacing ERB with Haml

Haml was one of the primary reasons why I feel in love with working on Ruby on Rails applications. It just makes working with markup a pleasure.

Adding Haml to your project requires only 2 lines in your Gemfile:

gem ‘rails3-generators’
gem ‘haml’

The gem rails3-generators provides a variety of generators for Ruby on Rails 3 applications including factory_girl which we will be using later.

In config/application.rb, add the following to your application configuration:

config.generators do |g|
  g.template_engine :haml
end

Replacing Prototype with jQuery

Using jQuery simplifies dealing with the DOM and provides all the tools necessary to do unobtrusive JavaScript in your web application. According to Hampton Catlin’s 2010 ruby survey, 78.8% of all ruby users prefer it over Prototype.

Run the following two commands in the root of your project directory:

curl -L http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js > \
public/javascripts/jquery.js

curl -L http://github.com/rails/jquery-ujs/raw/master/src/rails.js > \
public/javascripts/rails.js

Once you setup a layout file, include the two javascript files and your set.

Replacing Test::Unit with RSpec

With the latest beta release of RSpec 2, all generators and rake tasks are now exposed through a Railtie.

To replace Test::Unit as your default test framework, include the rspec-rails gem in both the :development and :test group in your Gemfile:

group :development, :test do
  gem ‘rspec-rails’, ‘>= 2.0.0.beta.19’
end

The next step is to install rspec into the application. The rspec:install generator will create a spec directory and some skeleton files. Run the following in your project root:

% bundle install
% rails g rspec:install

Even though you are including RSpec as a development environment dependency, it is not completely loaded. It is only completely loaded when you invoke rails generate or rake. Read more details about this change at David Chelimsky’s post rspec-rails-2 generators and rake tasks – part II.

Replacing Fixtures with Factory Girl

The rails3-generators gem we included earlier also provides some factory_girl generators. This allows for the creation of a factory when we use the model generator from Rails.

Add a dependency to the factory_girl_rails to the test environment in your Gemfile:

gem 'factory_girl_rails', :group => :test

You will also need to manually configure your generators to use factory_girl in config/application.rb. Your generators configuration should now look like the following:

config.generators do |g|
  g.template_engine :haml
  g.fixture_replacement :factory_girl, :dir => "spec/factories"
end

Update: If you absolutely love this stack, be sure to check out rails-templater.

Here are ten of my favourite bundles and plugins available to TextMate that will save you time and effort while working with Ruby on Rails:

1. PeepOpen – One of the best features of TextMate is fuzzy search(Command-T) which allows you to find files in your project with just a few characters of the filename. The issue with fuzzy search is that it becomes hard to pinpoint a file when there are many files with the same name in your project. Working in Ruby on Rails, you will face an endless amount repeated filenames in your views such as index.html.erb. Geoffrey Grosenbach from PeepCode, has developed an application PeepOpen that replaces the default fuzzy search with a beautiful fuzzy search that also allows you to pinpoint directories within your search. For a mere $9.00, it is a must own add-on to TextMate.

2. Ruby on Rails – Ruby on Rails development just got better with the recent changes made by Carlos Brando to Dr. Nic’s bundle. Not only does it include all the snippets and Rails integrations we are all used to, but now we also get a pseudo-intellisense for attributes for each ActiveRecord model in your project. One of my favourite additions to the bundle is the ability to easily create RVM .rvmrc files for your project.  The best resource for this bundle is PeepCode’s TextMate for Rails 2 screencast, be sure to check it out.

3. AckMate – If you need to find some text fast, AckMate is your answer. By default, you have the power of regular expressions to pinpoint even the most complex pattern of text. AckMate also allows the filtering of files by specifying file extensions and pattern matching if a filename contains certain text.

4. JavaScript Tools – JavaScript is ingrained in web development regardless of the server technology being utilized. Using the JavaScript Tools bundle you get all of the following:

• JavaScript Lint to check all your source code for common JavaScript mistakes
• A JavaScript beautifier to uniform line breaks and indentation
• Packing and minimizer tools to compress your JavaScript documents for production

5. JavaScript jQuery – jQuery is the most popular JavaScript library available today. This bundle by jQuery team member Karl Swedberg and Jonathan Chaffer provides a huge amount of snippets to save you some keystrokes when working with jQuery.

6. Git – The Git bundle provides access to common Git commands without leaving your editor. Do things like viewing your uncommitted changes, find out who made that bad code change, and commit your changes to the repository.

7 & 8. rSpec/Cucumber – Outside-in Rails development has never been easier with Behavior Driven Development (BDD) tools rSpec and Cucumber. These bundles allow for the running of specs and features from within TextMate and provide an HTML output of the results.

9. Code Beautifier –  TextMate does a good job of formatting your code but there is room for improvement. Using the Option-Command-B keyboard combination, the Code Beautifier bundle will clean up any white space and fix indentation in your ruby code. This is one of my most used bundles when I work with TextMate.

10. Compass + Blueprint – Compass is the amazing Sass framework which cuts down development time by providing mixins and a means for doing unobtrusive CSS. This Compass bundle focuses on snippets for the popular Blueprint CSS framework.

Give these bundles/plugins a try and be sure to let me know of any you think belong on this list.

In this post, I am going to show you how to do the latter in Mac OS X using my preferred merge tool, Diffmerge.  Diffmerge is a free graphical file comparison tool by SourceGear available in Mac OS X, Linux, and Windows. It is ideal to perform 3-way merges as it supports 3-way file comparison. During a conflict, you are presented with the version of the branch you are working on, the common file ancestor, and the branch you are merging in.

Visual Mergetool Configuration

Running the following commands in your terminal will set Diffmerge as your default visual mergetool:

git config --global merge.tool diffmerge

git config --global mergetool.diffmerge.cmd "diffmerge --merge
--result=\$MERGED \$LOCAL \$BASE \$REMOTE"

git config --global mergetool.diffmerge.trustExitCode true

As of the 3.3 release of Diffmerge, exiting a visual merge will return the correct status to Git. Prior to this release, Diffmerge would always return 0, indicating that the merge was resolved even on aborted merges. When you attempt to close Diffmerge, you will be prompted to choose if the merge is to be aborted or is resolved.

To start a 3-way merge with your visual mergetool, run:

git mergetool

This will perform a visual merge for each file in conflict. You may also provide an optional file parameter, to perform a merge on a specific file.

Don’t store backups

By default, Git will store a backup of the original file with conflict markers after a successful merge. These files will have a .orig extension added to the original filename. When I configure Git, I ensure that these files are not saved. To globally disable backups of the original merge file, run the following:

git config --global mergetool.keepBackup false

Visual Difftool Configuration

You may also setup Diffmerge to be your visual Difftool by running the following commands in your terminal:

git config --global diff.tool diffmerge
git config --global difftool.diffmerge.cmd "diffmerge \$LOCAL \$REMOTE"

This will allow you to compare two different versions of files visually. For example:

git difftool master~1 foo.rb

More Resources

• Screencast source code
• Binged source code
• Binged Documentation

Creative Commons:
http://www.flickr.com/photos/chrisjohnbeckett/ / CC BY-NC-ND 2.0

The Bing API does not cost you a single penny to use. It’s completely free! Bing’s biggest competitor, Google Site Search on the other hand can cost you from $100 annually to a price point only known by calling a google sales representative. Looking at the their small business plan, it will cost $250 annually for 1,001 – 5000 indexed pages. If your site has a lot of pages, you will start feeling very limited. Using the Bing API, you have access to the same results as the Bing search engine and not a small subset. The one limitation to the API is that you can only request the first 1000 results of a query. If your site displays 20 results per page, that is a total of 50 pages of search results.

Bing also provides unlimited bandwidth for queries as long as you make less than 7 queries per second per IP address. In a single day, you can query 518,400 times per server. That is a magnitude of search queries that will satisfy even large web applications. Compare this with the $750 annual google plan that only allows 500,000 queries per year!

Finally,  the another great benefit of using the Bing API is that you can style the results to match the look and feel of your site.

The Rules

Based on the Bing Web Services API Terms of Use, the following rules must be followed in order to use Bing:

• It is to only be used for display in your Website or application.
• You must display some form of attribution to Bing compliant with the Microsoft branding rules.
• Do not filter any results you request.
• If you interleave with other sources, you must clearly differentiate those sources.

Be sure to read the full Terms of Use to know exactly what you are entitled to.

Bing in Ruby via Binged

Binged is a ruby gem I wrote that wraps the Bing API. It allows ruby developers to work with bing using all the common ruby syntax and idioms they know. Binged also has a chainable query syntax to allow easy query construction based on a large set of available filters.

Installation

[sudo] gem install binged

Get Your Bing API key

To use binged, you will require a Bing API key. Create one at: http://www.bing.com/developers/createapp.aspx

Usage

Instantiate a Client

binged = Binged::Client.new(:api_key => 'binged')

The client is used to search via different sources and holds a reference to your api key to simplify calls to the API.

Ruby on Rails configuration

Binged allows for configuration to be done once using a configure block. To use binged in your Ruby on Rails project, configure it globally in an initializer like this:

# config/initializers/binged.rb
Binged.configure do |config|
  config.api_key = 'api_key'
end

Globally configuring Binged removes the need to provide the client with any credentials or options in your code as they would have already been set. For example, defining a client would be as follows:

binged = Binged::Client.new

Web Search Example

The following example demonstrates how to search within a specific site for a keyword and provide a maximum of 30 results:

Binged::Client.new.web('ruby').from_site('adventuresincoding.com').per_page(30).each do |result|
  puts result.title
  puts result.description
  puts result.url
end

Conclusion

For simple site-wide search, Bing is the optimal solution for most web applications. It is free and the usage limits are so  lax, they can almost be thought of as unlimited. Be sure to check out the Binged documentation to get a grasp of all the conditions you can specify in your queries. If you find a bug or have a great feature idea, create an issue over at github.

Update

View the Binged screencast on how to integrate Binged with your Ruby on Rails application.

Creative Commons:
http://www.flickr.com/photos/chrisjohnbeckett/ / CC BY-NC-ND 2.0

Step 1: Ensure you include db/schema.rb in your SCM

The file db/schema.rb is the current definition of your database. It is versioned and updated after a migration is run. This file is essential in creating your database once all your older migrations are gone. Remember that db/schema.rb is db agnostic, so any implementation specific db statements in your migrations will not exist in the schema.

Step 2: Migrate to the latest version

Notify your team to checkout the latest version of your project and migrate. This will ensure that future migrations will continue to run smoothly on their current development database.

Step 3: Seed your database with db/seeds.rb

Go through each of your migrations and ensure that no data is being inserted in any of them. Migrations are only supposed to be used to manipulate the structure of your database, not populate it.  Rails provides a file db/seeds.rb where you can run ruby code and model creation statements to set all the data required by your application to start.

Below is an example of a db/seeds.rb file setting up the users of a system:

User.create [{ :name => ‘admin’ }, { :name => ‘foo’ }, { :name => ‘bar’ }]

You can populate your database with seed data anytime by running rake db:seed. Seeding was added in Ruby on Rails 2.3.4.

Step 4:  Keep only latest migrations

Go to db/migrate folder and delete all but your latest migration or move the older migrations to a folder such as db/archieved_migrations. You will want to keep the last migration as a reference if you need to migrate down.

Step 5: Setting up a fresh environment

Even though all your migrations are gone except for one, a developer can setup a fresh environment with a development database containing all required data by running one rake task: rake db:setup. This task will create the database, load the entire schema from db/schema.rb, and then populate the database based on db/seeds.rb.