Ruby on Rails 3.0: What's New, Release History & Support Lifecycle

What Is New in Ruby on Rails 3.0

How does Rails 3 change the way we configure and start a new application?

The first step is now to run rails new myapp, which generates a Gemfile and a config/application.rb Application object.

• All environment-specific settings live inside the Application object; config/environment.rb is now a thin loader.
• The old script/ scripts are gone; rails console and rails generate replace them.
• Dependencies are managed by Bundler. Run bundle install to resolve the Gemfile and you can vendor gems with bundle install --path vendor/bundle.

# Example Gemfile
source 'https://rubygems.org'

gem 'rails', '3.0.0'
gem 'pg'
gem 'puma'

In practice this means a cleaner, reproducible setup and eliminates the need for config.gem calls.

What are the major architectural shifts introduced in Rails 3?

Rails 3 decouples core components and introduces a unified plugin API via Railties.

• Railties rewrite: Generators, engines, and plugins now share a single API; you can place custom generators under lib/templates and hook into any stage.
• Active Model: Provides a thin interface (validations, callbacks, naming) that any ORM can implement, allowing DataMapper or Sequel to plug into Action Pack.
• AbstractController: Extracts rendering, helpers, and callbacks from ActionController, enabling ActionMailer and other libraries to inherit the same base.
• Arel: Powers the new relation-based query interface; all Active Record queries now return an Arel::Relation object that can be chained.
• Mail gem extraction: Email parsing and delivery are delegated to the standalone mail gem, reducing ActionMailer's footprint.

Watch out for the compatibility layer: the old Active Record API still works but will be removed after Rails 3.1.

How has routing and controller handling been revamped in Rails 3?

Rails 3 introduces Action Dispatch, a Rack-based router with a modern DSL.

• Routes are defined inside AppName::Application.routes do ... end instead of the old map block.
• New helpers: match, scope, constraints, and root simplify complex routing scenarios.
• Controllers now inherit from ActionController::Base which itself inherits from AbstractController::Base; protect_from_forgery is enabled by default.
• The responder pattern (respond_with and ActionController::Responder) streamlines format negotiation.

# config/routes.rb
MyApp::Application.routes do
  root to: 'home#index'
  resources :posts
  match '/search', to: 'search#show', via: [:get, :post]
end

This matters if you rely on the legacy catch-all route; it is now commented out and will disappear in Rails 3.1.

What updates to Active Record and validations should I be aware of in Rails 3?

Active Record now returns chainable relations powered by Arel, and validations live in Active Model.

• New query methods: where, select, order, limit, etc., all return an Arel::Relation that can be further chained.
• Validations are available via ActiveModel::Validations; the classic validates_presence_of still works, but you can also use the hash-style validates :title, presence: true, length: { maximum: 50 }.
• Custom validators are simple Ruby classes inheriting from ActiveModel::EachValidator.

# app/models/post.rb
class Post < ActiveRecord::Base
  validates :title, presence: true, length: { maximum: 100 }
  validates :slug, uniqueness: true
end

In practice, the new API makes complex queries more readable and lets you swap the ORM without rewriting validation logic.

Which APIs were deprecated or removed in Rails 3 and what should I replace them with?

Rails 3 removes several legacy entry points and replaces them with modern equivalents.

• config.gem → use a Gemfile and Bundler.
• script/* → rails command (e.g., rails console, rails server).
• rake freeze → bundle install --path vendor/bundle to vendor gems.
• RAILS_ROOT / RAILS_ENV / RAILS_DEFAULT_LOGGER → Rails.root, Rails.env, Rails.logger.
• filter_parameter_logging → config.filter_parameters << :password in an initializer.
• old map routing → new DSL inside Application.routes with resources, match, etc.

Most teams will need to audit initializers, Rake tasks, and plugin code for these patterns before the upgrade.