Working Effectively With Legacy Code

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

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.

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

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

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

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

The model

class Boat < ActiveRecord::Base
belongs_to :owner, :class_name => quot;Userquot;

def can_update?(user)
user == owner || user.admin? || owner.blank?
end
end

The controller
class BoatsController < ApplicationController
def update
@boat = Boat.ﬁnd params[:id]
if @boat.can_update?(current_user)
if @boat.update_attributes(params[:boat])
redirect_to boat_url(@boat)
else
render :action => quot;editquot;
end
else
end
end
end

The new controller
require_authorization :update

def update
redirect_to @boat
else
end
end

def load_model
@boat ||= Boat.ﬁnd(params[:id])
end
end

The “magic”
class ApplicationController < ActionController::Base
def self.require_authorization(*actions)
actions.each do |a|
before_ﬁlter :check_authorization, :only => a
end
end

def check_authorization
model = load_model
unless model.send(quot;can_#{action_name}?quot;, 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

A little cleanup
...
def object
@boat ||= Boat.ﬁnd(params[:id])
end
end

class ApplicationController < ActionController::Base
...
def check_authorization
unless object.send(quot;can_#{action_name}?quot;, current_user)
redirect_to model
end
end
end

resource_controller

resource_controller # thanks James!!!
end

Before
def update
@boat = Boat.ﬁnd params[:id]
if @boat.can_update?(current_user)
else
end
else
end
end
end

After

resource_controller # thanks James!!!
end

METAPROGRAMMING ROCKS

(with great power comes great responsibility)

Rails Extension Points

before_*/after_* hooks

AR observers

ActionController filters

The Test

describe AccountsController, quot;POST createquot; do
def do_post
post :create, :account => {:name => quot;Nikequot;}
end

it quot;should create a project for the accountquot; 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 => quot;#{@account.name}'s First Projectquot;
redirect_to @account
else
render :template => quot;newquot;
end
end
end

Using Callbacks

class Account < ActiveRecord::Base
has_many :projects

after_create :create_project

def create_project
projects.create! :name => quot;#{name}'s First Projectquot;
end
end

Simpler Controller

def create
@account = Account.new params[:account]
if @account.save
redirect_to @account
else
end
end

A little more
describe AccountsController, quot;POST createquot; do
def do_post
post :create, :account => {:name => quot;Nikequot;}
end

it quot;should create a project for the accountquot; do
do_post
Account.first.should have(1).project
end

it quot;should create a video for the projectquot; do
do_post
Account.first.projects.first.should have(1).video
end
end

The Model
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 => quot;#{account.name}'s First Videoquot;
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 => quot;#{@name}'s First Projectquot;
project.videos.create! :name => quot;#{@name}'s First Videoquot;
end
end

Controller & Other Models
# Use resource_controller
def create
@registration = AccountRegistration.new params[:account]
if @registration.save
redirect_to @registration.account
else
end
end

has_many :videos
end

has_many :projects
end

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

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, quot;calculating taxquot; do
it quot;should add tax onto the totalquot; do
o = Order.new quot;CAquot;
bacon = Item.new quot;Chunky baconquot;, 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

fake_calculator = mock('calculator')
fake_calculator.should_receive(:calculate).
with(42, quot;CAquot;).and_return 3.26
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)
end
end

o.add_item bacon, 1
end
end

Free DI to the rescue
class Order
Clients continue to
def tax(calculator=TaxCalculator)
work unchanged
end
end

o.add_item bacon, 1
end
end

Partial mocking
class Order
def tax
TaxCalculator.calculate @subtotal, @us_state
end
end

o.add_item bacon, 1
TaxCalculator.should_receive(:calculate).
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

Working Effectively With Legacy Code

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Working Effectively With Legacy Code

Similar to Working Effectively With Legacy Code (20)

Recently uploaded

Recently uploaded (20)

Working Effectively With Legacy Code

Editor's Notes