Nordic Ruby 2011

Saturday, June 18, 2011

bitcoin==

con-currency?


Me!José! ♥Saturday, June 18, 2011

WWFMD?Saturday, June 18, 2011

Public Service Announcements


SIGSEGV is bad


neversaydie


begin # something dangerousrescue NeverSayDie # fix memoryend


"Not working in production mode"


DO NOT USE THIS SOFTWARE


ruby -w


def hello x = Object.new # warning 10 + 10end


warning: assigned but unused variable - x


How deprecation notices SHOULD be

written


class Foo def deprecated if $VERBOSE warn "hey bro, don't call this" end 10 endend


RSpec Problem


warning: useless use of == in void context


it "passes" do 10.should == 10 11.should == 11end


def check(thing)end

def deprecated check 10.should == 10 check 11.should == 10end


@tenderlove


AT&T, AT&T logo and all AT&T related marks are trademarks of AT&T Intellectual Property and/or AT&T affiliated companies.


Ruby Core Team


Rails Core Team


White Guy


Story about Geethika and pinochle, java, etc


It's TYRA!

Story about Geethika and pinochle, java, etc


<3 <3 <3


"Congratulations, you just made us not consider Rails

for anything anymore despite our coders liking it."


SWEDEN!


IKEA!Saturday, June 18, 2011

MEATBALLS!Saturday, June 18, 2011

SWEDISH FISH!Saturday, June 18, 2011

Made in Canada!Saturday, June 18, 2011

How do you catch such tiny fish?


Will you share your Swedish FishFishing spot?


Mountain Dewand my

Trail of Tears

Talk about Rails,Talk about work projects


Legacy Code


What isLegacy Code?


Untested


Old


Not Understood

Maintainers are gone


Importance of Legacy Code


Old code containsKnowledge


Solves Today's Problems


All Legacy Code isNot Equal


TenderloveTear Formula


Code BurdenTears

Time


Tears cried at time T


Volume at time T


Last Week


I LOVE hackingold code


Techniques


Universal

Techniques

Extending

Testing


Universal


Liskov substitution principle


A subclass can be used in place of it's

superclass


Object

Animal

Person


class Animalend

class Person < Animalend


def leg_count(animal) animal.legsend

def account_number(person) person.account_numberend


Single Responsibility Principal


Each class has one and only one responsibility


Each class has one reason to change


Method Extraction


class WebClient def get(url) url = URI.parse url Net::HTTP.get(url.host, url.path) endend


class WebClient def get(url) url = URI.parse url http_get end

private def http_get Net::HTTP.get(url.host, url.path) endend


class WebClient def get(url) url = URI.parse url http_get(url.host, url.path) end

private def http_get(host, path) Net::HTTP.get(host, path) endend

I don't like it, but it helps us to reason


Object#extend


class Foo def metaclass class << self; self; end endend

x = Foo.newp x.metaclass.ancestors

x.extend(Module.new { })p x.metaclass.ancestors


[Foo, Object, Kernel, BasicObject]

[#<Module:0x81c98>, Foo, Object, Kernel, BasicObject]


Code Seams


Testing


Load Path Hacking


$LOAD_PATH


ruby -Ifoo script.rb


require 'net/http'



[aaron@higgins project (master)]$ find .../test./test/lib./test/lib/net./test/lib/net/http.rb./web.rb


http://web.rb

http://web.rb

module Net class HTTP def self.get(host, path) "hello world" end endend

test/lib/net/http.rb


ruby -I test/lib web.rb


require 'web'require 'minitest/autorun'

class WebTest < MiniTest::Unit::TestCase def test_get client = WebClient.new response = client.get 'http://www.reddit.com/r/ruby' assert_equal 'hello world', response endend


http://www.reddit.com/r/ruby'


require File.expand_path( File.join('..', 'foo'))

People don't know about -IRSpec and test/unit will set your -I for you


Heavy Handed


Good for Small APIs


Constant Hacking


require 'net/http'



class MyHTTP def self.get(host, path) "hello world" endend

WebClient.const_set(:Net, Module.new)WebClient::Net.const_set(:HTTP, MyHTTP)


class WebTest < MiniTest::Unit::TestCase def setup WebClient.const_set(:Net, Module.new) WebClient::Net.const_set(:HTTP, MyHTTP) end

def teardown WebClient.send(:remove_const, :Net) end

def test_get client = WebClient.new response = client.get 'http://www.reddit.com/r/ruby' assert_equal 'hello world', response endend




class WebClient def get(url) url = URI.parse url ::Net::HTTP.get(url.host, url.path) endend


Heavy Handed

Localized changes to one class

Still must mock entire API


Subclass Testing


require 'net/http'




Class.new


class WebTest < MiniTest::Unit::TestCase def test_get client = Class.new(WebClient) { def http_get(host, path) 'hello world' end }.new

response = client.get 'http://www.reddit.com/r/ruby' assert_equal 'hello world', response endend




Annoying Constructors


class Column def initialize(name, default, sql_type = nil, null = true) @name = name @sql_type = sql_type @null = null @limit = extract_limit(sql_type) @precision = extract_precision(sql_type) @scale = extract_scale(sql_type) @type = simplified_type(sql_type) @default = extract_default(default) @primary = nil @coder = nil end ....end

Many parameters,

don't care about some of them


Just Pass nil


def test_type_cast_true c = Column.new(nil, 1, 'int')

assert_equal 't', @conn.type_cast(true, nil) assert_equal 1, @conn.type_cast(true, c)end


Not Constructible

Can't construct, but want to break dependencies


pool = ActiveRecord::Base.connection_pool

Too hard to construct


pool = ActiveRecord::Base.connection_pool.dup

pool.extend(Module.new { def checkin conn @checkins << conn conn.object_id end})


Detecting Changes


Measure http_getclass WebClient def get(url) url = URI.parse url http_get(url.host, url.path) end



via Class.new


def test_http_get_count call_count = 0 client = Class.new(WebClient) { define_method(:http_get) { |host, path| call_count += 1 "hello world" } }.new

assert_equal 0, call_count client.get 'http://www.reddit.com/r/ruby' assert_equal 1, call_countend


http://google.com

http://google.com

def test_http_get_count call_count = 0 client = Class.new(WebClient) { define_method(:http_get) { |host, path| call_count += 1 "hello world" } }.new


Decide to call super or not


http://google.com

http://google.com

via Module.new


def test_http_get_count client = WebClient.new

call_count = 0 client.extend(Module.new { define_method(:http_get) { |host, path| call_count += 1 "hello world" } })



http://google.com

http://google.com

Extending


Huge Methods!


def table_rows rows[table_name] = fixtures.map do |label, fixture| if model_class && model_class < ActiveRecord::Base reflection_class.reflect_on_all_associations.each do |association| case association.macro when :belongs_to # Do not replace association name with association foreign key if they are named the same fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s

if association.name.to_s != fk_name && value = row.delete(association.name.to_s) if association.options[:polymorphic] && value.sub!(/\s*$([^$]*)\)\s*$/, "") # support polymorphic belongs_to as "label (Type)" row[association.foreign_type] = $1 end

row[fk_name] = ActiveRecord::Fixtures.identify(value) end when :has_and_belongs_to_many if (targets = row.delete(association.name.to_s)) targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/) table_name = association.options[:join_table] rows[table_name].concat targets.map { |target| { association.foreign_key => row[primary_key_name], association.association_foreign_key => ActiveRecord::Fixtures.identify(target) } } end end end end row end rowsend


Extract Methods


def belongs_to_row(association, row) # Do not replace association name with association foreign key if they are named the same fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s

if association.name.to_s != fk_name && value = row.delete(association.name.to_s) if association.options[:polymorphic] && value.sub!(/\s*$([^$]*)\)\s*$/, "") # support polymorphic belongs_to as "label (Type)" row[association.foreign_type] = $1 end

row[fk_name] = ActiveRecord::Fixtures.identify(value)end


def habtm_row(association, row) if (targets = row.delete(association.name.to_s)) targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/) table_name = association.options[:join_table] rows[table_name].concat targets.map { |target| { association.foreign_key => row[primary_key_name], association.association_foreign_key => ActiveRecord::Fixtures.identify(target) } } endend


def table_rows rows[table_name] = fixtures.map do |label, fixture| row = fixture.to_hash

if model_class && model_class < ActiveRecord::Base

# If STI is used, find the correct subclass for association reflection reflection_class = if row.include?(inheritance_column_name) row[inheritance_column_name].constantize rescue model_class else model_class end

reflection_class.reflect_on_all_associations.each do |association| case association.macro when :belongs_to belongs_to_row(association, row) when :has_and_belongs_to_many habtm_row(association, row) end end end

row end rowsend


Extract Object


class RowFilter def rows fixtures.map do |label, fixture| row = fixture.to_hash if model_class && model_class < ActiveRecord::Base # If STI is used, find the correct subclass for association reflection reflection_class = if row.include?(inheritance_column_name) row[inheritance_column_name].constantize rescue model_class else model_class end

reflection_class.reflect_on_all_associations.each do |association| case association.macro when :belongs_to belongs_to_row(association, row) when :has_and_belongs_to_many habtm_row(association, row) end end end row end endend


class RowFilter attr_reader :fixtures, :model_class

def initialize(fixtures, model_class) @fixtures = fixtures @model_class = model_class endend


def table_rows filter = RowFilter.new(fixtures, model_class) rows[table_name] = filter.rows rowsend


Huge Classes!


Look at Method Names


Look at shared instance variables


Group Similar Methods


Use SRP to create a new class


Then Delegate.


All API calls




Once we had extracted the HTTP methods to their own functions, could reason about HTTP api.


class WebClient def initialize(client = Net::HTTP) @client = client end

def get(url) url = URI.parse url http_get(url.host, url.path) end

private def http_get(host, path) @client.get(host, path) endend


class TestHTTP < Struct.new(:data) def get(host, path) data[[host, path]] endend


class WebTest < Test::Unit::TestCase def test_get_home mockhttp = TestHTTP.new({ ['localhost', '/~aaron/'] => 'hello' }) wc = WebClient.new mockhttp assert_equal 'hello', wc.get('http://localhost/~aaron/') endend


http://localhost/~aaron/'

http://localhost/~aaron/'

We define expectations


Not Bound to HTTP


Legacy code can make you cry


But it doesn't have to


Don't be afraid!


Ruby is your mocking framework


Credits & More Info


Open Questions?


Do you like mocking / stubbing?


How do these testing tools impact your API?


Do you like hearts?


How about kittens?


<3 <3 <3


Nordic Ruby 2011

Technology

Transcript of Nordic Ruby 2011