Intro To Advanced Ruby

Intro to Advanced Ruby

twitter: bphogan
email: brianhogan at napcs.com
http://spkr8.com/t/7114

What makes Ruby
special?

twitter: bphogan

It's expressive
5.times do
puts "Hello World"
end

twitter: bphogan

It's dynamic
class Person

[:first_name, :last_name, :gender].each do |method|
attr_accessor method
end

end

twitter: bphogan

It's extendable
module KeywordSearch
def find_all_by_keywords(keywords)
self.where(["name like ?", "%" + keywords + "%"])
end
end

class Project < ActiveRecord::Base
extend KeywordSearch
end

class Task < ActiveRecord::Base
extend KeywordSearch
end

twitter: bphogan

It's ﬂexible
def add(*args)
args.reduce(0){ |result, item| result + item}
end

add 1,1,1,1

twitter: bphogan

It's dangerous!
class String
def nil?
self == ""
end
end

twitter: bphogan

Our roadmap for today
• Requiring ﬁles
• Testing
• Message passing
• Classes vs Instances
• Blocks and Lambdas
• Monkeypatching
• Modules
twitter: bphogan

require

twitter: bphogan

require more functionality
Date.today.to_s
NoMethodError: undefined method 'today' for
Date:Class

require 'date'
=> true

Date.today.to_s
=> "2011-04-09"

twitter: bphogan

Testing

twitter: bphogan

A simple Unit test
require 'test/unit'

class PersonTest < Test::Unit::TestCase

def test_person_under_16_cant_drive
p = Person.new
p.age = 15
assert !p.can_drive?
end

end

twitter: bphogan

Make it fail ﬁrst...
Loaded suite untitled
Started
E
Finished in 0.000325 seconds.

1) Error:
test_person_under_16_cannot_drive(PersonTest):
NameError: uninitialized constant PersonTest::Person
method test_person_under_16_cannot_drive in untitled
document at line 6

1 tests, 0 assertions, 0 failures, 1 errors

twitter: bphogan

Now write the code

class Person
attr_accessor :age
def can_drive?
self.age >= 16
end
end

twitter: bphogan

And pass the test!

Loaded suite untitled
Started
.
Finished in 0.00028 seconds.

1 tests, 1 assertions, 0 failures, 0
errors

twitter: bphogan

Classes and Objects
• A Ruby Class is an object of type Class
• An Object is an instance of a Class
• Classes can have methods just like objects
• These are often used as static methods.

twitter: bphogan

Instance vs class methods
class Person class Person
def sleep def self.sleep
puts "ZZZZZZ" puts "ZZZZZZ"
end end
end end

p = Person.new Person.sleep
p.sleep "ZZZZZZ"
"ZZZZZZ" => nil
=> nil

twitter: bphogan

Message passing

twitter: bphogan

.send
class Person p = Person.new
def name
@name p.send(:name)
end

def name=(input) p.send(:name=, "Homer")
@name = input
end
end

twitter: bphogan

We reduce complexity with this.
class Sorter class Sorter
def move_higher def move_higher
puts "moved one higher" puts "moved one higher"
end end

def move_lower def move_lower
puts "moved lower" puts "moved lower"
end end

def move(type) def move(type)
case type self.send "move_" + type
when "higher" then move_higher end
when "lower" then move_lower end
end
end
end

twitter: bphogan

Then we can add more methods.
class Sorter
def move_higher
puts "moved one higher"
end

def move_lower
puts "moved lower"
end

def move_top
puts "moved to the top"
end

def move_bottom
puts "moved to the bottom"
end

def move(type)
self.send "move_" + type
end
end

twitter: bphogan

Send and respond_to

class Person
attr_accessor(:name)
end

p = Person.new

p.send(:name) if p.respond_to?(:name)
p.send(:age) if p.respond_to?(:age)

twitter: bphogan

Blocks and Lambdas

twitter: bphogan

Blocks

twitter: bphogan

Encapsulation
result = wrap(:p) do
"Hello world"
end

puts result
=> "<p>Hello world</p>”

def wrap(tag, &block)
output = "<#{tag}>#{yield}</#{tag}>"
end

twitter: bphogan

yield can bind objects!
navbar = Navbar.create do |menu|
menu.add "Google", "http://www.google.com"
menu.add "Amazon", "http://www.amazon.com"
end

class Menu
class Navbar
def self.create(&block)
def add(name, link)
menu = Menu.new
@items ||= []
yield menu
@items << "<li><a href='#{link}'>#{name}</a></li>"
menu.to_s(options)
end
end
end
def to_s(options)
menu = @items.join("n")
"<ul>n#{menu}n</ul>"
end
end

twitter: bphogan

Procs and Lambdas

twitter: bphogan

Delayed Execution
a = lambda{|phrase| puts "#{phrase} at #{Time.now}" }
puts a.call("Hello")
sleep 1
puts a.call("Goodbye")

Hello at Sat Apr 09 13:34:07 -0500 2011
Goodbye at Sat Apr 09 13:34:08 -0500 2011

twitter: bphogan

Monkeypatching

twitter: bphogan

Reopen a class!
class Object
def blank?
self.nil? || self.to_s == ""
end

def orelse(other)
self.blank? ? other : self
end

end

twitter: bphogan

Monkeypatching is an
evil process!

twitter: bphogan

Instead, we use Modules

twitter: bphogan

Modules
module OrElseMethods

def blank?
end

def orelse(other)
end

end

twitter: bphogan

In Ruby, we don’t care
about the type... we
care about how the
object works.

twitter: bphogan

Including modules on objects
module NinjaBehaviors
def attack
puts "You've been killed silently!"
end
end

class Person
include NinjaBehaviors
end

p = Person.new
p.attack

twitter: bphogan

Extending classes with modules
module NinjaCreator

def new_ninja
puts "I've created a new Ninja"
end

end

class Person
extend NinjaCreator
end

Person.new_ninja

twitter: bphogan

Person
vs
PersonNinjaRockStarAdmin

twitter: bphogan

Extending objects with modules
module NinjaBehaviors
def attack
puts "You've been killed silently!"
end
end

module RockStarBehaviors
def trash_hotel_room
puts "What a mess!"
end
end

twitter: bphogan

Extending objects with modules
ninja = Person.new
ninja.extend NinjaBehaviors
ninja.attack

rockstar = Person.new
rockstar.extend RockStarBehaviors
rockstar.trash_hotel_room

rockstar.extend NinjaBehaviors
rockstar.attack

twitter: bphogan

Inject code without reopening!
module OrElseMethods

def blank?
end

def orelse(other)
end

end

Object.send :include, OrElseMethods

twitter: bphogan

self.included class access
module UserValidations
def self.included(base)
base.validates_presence_of :email, :login
base.valudates_uniqueness_of :email, :login
base.validates_confirmation_of :password
end
end

class User < ActiveRecord::Base
include UserValidations
end

twitter: bphogan

Modules can’t contain
methods that overwrite
existing methods!

twitter: bphogan

self.included + class_eval
class Person module NoSave
def save
puts "Original save" def self.included(base)
true base.class_eval do
end def save
end puts "New save"
false
end
end
end

end

Person.send :include, NoSave

twitter: bphogan

Yes, that’s weird.

twitter: bphogan

Putting it all together
• Implement “before save” behavior - when we
call “save” on our object, we want to declare
other methods we want to hook in.
class Person
before_save, :foo,
lambda{|p| p.name = "test"},
SuperFilter
end

twitter: bphogan

Demo
https://github.com/napcs/intro_to_advanced_ruby

twitter: bphogan

Questions?

twitter: bphogan

Intro To Advanced Ruby

More Related Content

What's hot (13)

Similar to Intro To Advanced Ruby (20)

More from Brian Hogan (18)

Recently uploaded (20)

Intro To Advanced Ruby

Editor's Notes