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

Recomendados

Recomendados

Mais conteúdo relacionado

Mais de Brian Hogan

Mais de Brian Hogan (19)

Último

Último (20)

Intro To Advanced Ruby

Notas do Editor