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

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 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 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 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 => quot;editquot; 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

USE EXISTING FRAMEWORKS

A little cleanup class BoatsController < ApplicationController ... 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 class BoatsController < ApplicationController resource_controller # thanks James!!! require_authorization :update end

Before 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 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, 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 render :template => quot;newquot; 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 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 => 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 render :template => quot;newquot; 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 => 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 describe Order, quot;calculating taxquot; do it quot;should add tax onto the totalquot; do fake_calculator = mock('calculator') fake_calculator.should_receive(:calculate). with(42, quot;CAquot;).and_return 3.26 o = Order.new quot;CAquot; bacon = Item.new quot;Chunky baconquot;, 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, quot;calculating taxquot; do it quot;should add tax onto the totalquot; do fake_calculator = mock('calculator') fake_calculator.should_receive(:calculate). with(42, quot;CAquot;).and_return 3.26 o = Order.new quot;CAquot; bacon = Item.new quot;Chunky baconquot;, 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, quot;calculating taxquot; do it quot;should add tax onto the totalquot; do fake_calculator = mock('calculator') fake_calculator.should_receive(:calculate). with(42, quot;CAquot;).and_return 3.26 o = Order.new quot;CAquot; bacon = Item.new quot;Chunky baconquot;, 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, 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 TaxCalculator.should_receive(:calculate). with(42, quot;CAquot;).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

http://www.refactorsquad.com	16
http://refactorsquad.com	13
http://feeds2.feedburner.com	13
http://translate.googleusercontent.com	9
http://www.slideshare.net	6

Working Effectively With Legacy Code

by scidept

Accessibility

Categories

Upload Details

Usage Rights

5 Embeds 57

Statistics

Working Effectively With Legacy Code Presentation Transcript