WORKING EFFECTIVELY WITH LEGACY RAILS
Pat Maddox & BJ Clark

Why Care About Legacy Code?
Rails is almost 5 years old
Lots of $$ to be made
Everyone writes legacy code

What is Legacy Code?
Code written >3 months ago
Code written by someone else

What is Legacy Code?
Michael Feathers - “Code Without Tests”
Ward Cunningham - “Accumulated technical debt”
DHH - “Code you wrote when weren’t as good as you are now”

Code that is difficult to change

TECHNICAL DEBT

What is Technical Debt?
“During the planning or execution of a software project, decisions are
made to defer necessary work, this is creating technical debt”
http://c2.com/cgi/wiki?TechnicalDebt
Why is it bad?
Not necessarily bad (good vs bad debt)

Examples of Technical Debt
Rails
MediaWiki
ActiveScaffold
Code you write

Recognizing Debt
Easy upfront gains
Difficult to extend long-term (does the tool support new
requirements)
No clear migration path

Managing Technical Debt
“Remove cruft as you go. Build simplicity and clarity in from the
beginning, and never relent in keeping them in. “
-Ron Jeffries
Big Design Up Front
Agile

TATFT & RATFT
Virtuous cycle - Symbiotic Relationship
Anti-pattern: Red. Green. Deploy.
Pattern: Red. Green. Refactor. Deploy.

TESTING TO MINIMIZE DEBT

Goals
Maintain existing value
Add new value

Start Testing Now
What level?
Unit vs Acceptance
Cast a wide net

Ok, lets test
Take 6 weeks off to write tests for your code

Ok, lets test
Take 6 weeks off to write tests for your code

Ok, lets test
Just in time
Characterization tests
Cover existing functionality
Never red, always green
Test-drive new features

Siloing Code
Webservice/SOA
Rails 3.0 mounted applications

REFACTORING TECHNIQUES

Rails already does it
Caching
has_many :through
Delegation, memoization, serialization
Validations and the .valid? api

Make everything a framework
All the benefits of abstracted code
Use existing frameworks
Write your own mini-frameworks

EXAMPLE

The Tests
it \"works when updated by owner\" do
describe BoatsController do
before(:each) do do_update @owner
@owner = User.create! @boat.reload.name.should == \"SS Minnow\"
@boat = Boat.create! end
:name => \"Pequod\",
:owner => @owner it \"works when updated by admin\" do
end admin = User.create! :admin => true
do_update admin
def do_update(user) @boat.reload.name.should == \"SS Minnow\"
login_as user end
put :update,
:id => @boat.to_param,
it \"fails when updated by non-owner\" do
:boat =>
nonowner = User.create!
{:name => \"SS Minnow\"}
do_update nonowner
end
@boat.reload.name.should == \"Pequod\"
end

The model
class Boat < ActiveRecord::Base
belongs_to :owner, :class_name => \"User\"
def can_update?(user)
user == owner || user.admin? || owner.blank?
end
end

The controller
class BoatsController < ApplicationController
def update
@boat = Boat.find params[:id]
if @boat.can_update?(current_user)
if @boat.update_attributes(params[:boat])
redirect_to boat_url(@boat)
else
render :action => \"edit\"
end
else
redirect_to boat_url(@boat)
end
end
end

WRITE A MINI-FRAMEWORK

The new controller
class BoatsController < ApplicationController
require_authorization :update
def update
if @boat.update_attributes(params[:boat])
redirect_to @boat
else
render :action => \"edit\"
end
end
def load_model
@boat ||= Boat.find(params[:id])
end
end

The “magic”
class ApplicationController < ActionController::Base
def self.require_authorization(*actions)
actions.each do |a|
before_filter :check_authorization, :only => a
end
end
def check_authorization
model = load_model
unless model.send(\"can_#{action_name}?\", current_user)
redirect_to model
end
end
end

What we’ve learned
Pros
Easy to read
Behavior for free
Cons
Not as accessible to brand new Ruby programmers

USE EXISTING FRAMEWORKS

A little cleanup
class BoatsController < ApplicationController
...
def object
@boat ||= Boat.find(params[:id])
end
end
class ApplicationController < ActionController::Base
...
def check_authorization
unless object.send(\"can_#{action_name}?\", current_user)
redirect_to model
end
end
end

resource_controller
class BoatsController < ApplicationController
resource_controller # thanks James!!!
require_authorization :update
end

Before
class BoatsController < ApplicationController
def update
@boat = Boat.find params[:id]
if @boat.can_update?(current_user)
if @boat.update_attributes(params[:boat])
redirect_to boat_url(@boat)
else
render :action => \"edit\"
end
else
redirect_to boat_url(@boat)
end
end
end

After
class BoatsController < ApplicationController
resource_controller # thanks James!!!
require_authorization :update
end

METAPROGRAMMING ROCKS

METAPROGRAMMING ROCKS
(with great power comes great responsibility)

LEVERAGE RAILS

Rails Extension Points
before_*/after_* hooks
AR observers
ActionController filters

The Test
describe AccountsController, \"POST create\" do
def do_post
post :create, :account => {:name => \"Nike\"}
end
it \"should create a project for the account\" do
do_post
Account.first.should have(1).project
end
end

The Controller
def create
@account = Account.new params[:account]
Account.transaction do
if @account.save
@account.projects.create :name => \"#{@account.name}'s First Project\"
redirect_to @account
else
render :template => \"new\"
end
end
end

Using Callbacks
class Account < ActiveRecord::Base
has_many :projects
after_create :create_project
def create_project
projects.create! :name => \"#{name}'s First Project\"
end
end

Simpler Controller
def create
@account = Account.new params[:account]
if @account.save
redirect_to @account
else
render :template => \"new\"
end
end

A little more
describe AccountsController, \"POST create\" do
def do_post
post :create, :account => {:name => \"Nike\"}
end
it \"should create a project for the account\" do
do_post
Account.first.should have(1).project
end
it \"should create a video for the project\" do
do_post
Account.first.projects.first.should have(1).video
end
end

The Model
class Account < ActiveRecord::Base
after_create :create_project
...
end
class Project < ActiveRecord::Base
has_many :videos
belongs_to :account
after_create :create_video
def create_video
videos.create! :name => \"#{account.name}'s First Video\"
end
end

Tradeoffs
Cons
Pros
Indirection
Free transaction semantics
Testing is a bit slower/
Skinny controller, fat
tougher
model

Modeling a Business Event
class AccountRegistration < ActiveRecord::Base
belongs_to :account
before_create :setup_account
validates_associated :account
attr_writer :name
def setup_account
self.account = Account.create :name => @name
project = account.projects.create!
:name => \"#{@name}'s First Project\"
project.videos.create! :name => \"#{@name}'s First Video\"
end
end

Controller & Other Models
# Use resource_controller
def create
@registration = AccountRegistration.new params[:account]
if @registration.save
redirect_to @registration.account
else
render :template => \"new\"
end
end
class Project < ActiveRecord::Base
has_many :videos
end
class Account < ActiveRecord::Base
has_many :projects
end

Modeling a Business Event
class Account < ActiveRecord::Base
class AccountRegistration < AR::Base
has_many :projects
belongs_to :account
end
before_create :setup_account
validates_associated :account
class Project < ActiveRecord::Base
attr_writer :name
has_many :videos
end
def setup_account
self.account = Account.create
:name => @name
project = account.projects.create!
:name => \"#{@name}'s First Project\"
project.videos.create!
:name => \"#{@name}'s First Video\"
end
end

SEAMS

Seams
Modify or sense behavior of code without changing it
OO - polymorphism
Dependency management

Ruby seams
alias_method_chain
method_missing
send / eval

class Order
def initialize(us_state)
@us_state = us_state
@subtotal = 0
end
def add_item(item, quantity)
@subtotal += (item.cost * quantity)
end
def tax
TaxCalculator.calculate @subtotal, @us_state
end
end
describe Order, \"calculating tax\" do
it \"should add tax onto the total\" do
o = Order.new \"CA\"
bacon = Item.new \"Chunky bacon\", 42
o.add_item bacon, 1
o.tax.should == 3.26
end
end

DI to the rescue
class Order
def tax(calculator)
calculator.calculate @subtotal, @us_state
end
end
describe Order, \"calculating tax\" do
it \"should add tax onto the total\" do
fake_calculator = mock('calculator')
fake_calculator.should_receive(:calculate).
with(42, \"CA\").and_return 3.26
o = Order.new \"CA\"
bacon = Item.new \"Chunky bacon\", 42
o.add_item bacon, 1
o.tax(fake_calculator).should == 3.26
end
end

DI to the rescue
class Order
Breaks existing client code
def tax(calculator)
calculator.calculate @subtotal, @us_state
end
end
describe Order, \"calculating tax\" do
it \"should add tax onto the total\" do
fake_calculator = mock('calculator')
fake_calculator.should_receive(:calculate).
with(42, \"CA\").and_return 3.26
o = Order.new \"CA\"
bacon = Item.new \"Chunky bacon\", 42
o.add_item bacon, 1
o.tax(fake_calculator).should == 3.26
end
end

Free DI to the rescue
class Order
Clients continue to
def tax(calculator=TaxCalculator)
work unchanged
calculator.calculate @subtotal, @us_state
end
end
describe Order, \"calculating tax\" do
it \"should add tax onto the total\" do
fake_calculator = mock('calculator')
fake_calculator.should_receive(:calculate).
with(42, \"CA\").and_return 3.26
o = Order.new \"CA\"
bacon = Item.new \"Chunky bacon\", 42
o.add_item bacon, 1
o.tax(fake_calculator).should == 3.26
end
end

Partial mocking
class Order
def tax
TaxCalculator.calculate @subtotal, @us_state
end
end
describe Order, \"calculating tax\" do
it \"should add tax onto the total\" do
o = Order.new \"CA\"
bacon = Item.new \"Chunky bacon\", 42
o.add_item bacon, 1
TaxCalculator.should_receive(:calculate).
with(42, \"CA\").and_return 3.26
o.tax.should == 3.26
end
end

What To Do From Here
Develop a deep understanding of Ruby
Make good use of Rails
Read “Working Effectively with Legacy Code”
by Michael Feathers
Check out our new blog: www.refactorsquad.com

QUESTIONS