Magic in ruby

Magic in Ruby
David Lin
davll.xc@gmail.com
<beer>
Oct. 18, 2013
</beer>

Suppose You Know
1. Ruby Programming Language
- class, module, method
- block
- mixin (include, extend)
2. Metaprogramming
- class_eval
- define_method
3. Monkey Patching

Outline
1. Smalltalk-style method calling
2. Method swizzling
3. Decorator
4. Refinement

Ruby
is

Smalltalk-style!
Objective-C, too.

丟訊息
給物件
看看物件有什麼反應

obj.hello(“world”)

這是 message

obj.hello(“world”)

這是 receiver

obj.send(:hello,
“world”)
Yes, it sends a message!

obj 接收了message
內容為 hello(“world”)

obj 找一個對應的
method body
根據 message name :hello

然後...
引爆 invoke
呼叫這個 method body

DEFINE
A METHOD
事實上是定義一個 method body
然後連到對應的 message name

def hello(s)
define a method named ‘hello’
define a method for the name ‘hello’
a method body

:hello

method body
&
message name
沒有綁死在一起
而是可以改變的

HACK IT!
Let’s change behaviour

Method
Swizzling
把 method body “抽換”掉

Example.rb
class MyObj
def hello(s)
“Hello #{s}”
end
end

method body
A

:hello

Hack1.rb (part 1)
class MyObj
alias_method :hello_original,
:hello
end
:hello_original
method body
A

:hello

Hack1.rb (part 2)
class MyObj
def hello_with_bracket(s)
“{” + hello_original(s) + ”}”
end
end
method body
B

:hello_with_bracket
send message

:hello_original

Hack1.rb (part 3)
class MyObj
alias_method :hello,
:hello_with_bracket
end
method body
B
method body
A

:hello_with_bracket

:hello

Hack1.rb (final)
:hello
method body
B

:hello_with_bracket

send message

method body
A

:hello_original

可不可以
更簡潔些？
太多沒必要的 message names

Hack2.rb (to expect)
:hello
method body
B

call directly

method body
A

:hello_with_bracket

send message

:hello_original

Hack2.rb (to expect)
:hello
method body
B

call directly

method body
A

Hack2.rb (yes, that’s all)
class MyObj
m = instance_method(:hello)
define_method(:hello) do |s|
“{” + m.bind(self).call(s) + “}”
end
end

Hack2.rb
class MyObj
end
end
m (a local var)
method body
A

:hello

Hack2.rb
class MyObj
end
end
method body
B
method body
A

:hello

Hack2.rb (Ah, ha!)
class MyObj
end
end
method body
B
call directly

method body
A

:hello

Decorator
Method Wrapping
(it’s more complicant than Python, though)

Example (Unsafe!)
def send_money(from, to, amount)
from.balance -= amount
to.balance += amount
from.save!
to.save!
end

Example (Safer)
ActiveRecord::Base.transcation do
from.balance -= amount
to.balance += amount
from.save!
to.save!
end
end

Example in Ruby
ActiveRecord::Base.transcation do
# do operations
end
end

Example in Python
def send_money(from, to, amount):
try:
db.start_transcation()
# do operations
db.commit_transcation()
except:
db.rollback_transcation()
raise

Decorating in Python
Form 1:
@transcational
# do operations
Form 2:
# do operations
send_money = transcational(send_money)

Decorator in Python
def transcational(func):
def func2(*args):
try:
db.start_transcation()
func(*args) # call decoratee
db.commit_transcation()
except:
db.rollback_transcation()
raise
return func2

Decorating in Ruby
class Bank
extend Transcational # include decorator
# do operations
end
transcational :send_money # decorate!
end

Decorator in Ruby
module Transcational
def transcational(mthd_name)
mthd = instance_method(mthd_name)
define_method(mthd_name) do |*args, &blk|
ActiveRecord::Base.transcation {
# call decoratee
mthd.bind(self).call(*args, &blk)
}
end
end
end

這只是
Method
Swizzling
since Ruby has methods but functions

當你要...
Monkey Patching
Modify existing classes of other libs

Instead of monkey patching
class KlassOrModule
# define instance methods...
end
module MyLibrary
# using modified KlassOrModule...
end

住手！
You’re gonna RUIN EVERYTHING!

Use refinement
module MyLibrary
refine KlassOrModule do
# define instance methods...
end
# using modified KlassOrModule...
end

Example
module MyLibrary
refine String do # modify String
def hello
“Hello #{self}”
end
end
end

Example (cont.)
# Outside MyLibrary

puts “Kitty”.hello
# => NoMethodError: hello

Example (cont.)
# Outside MyLibrary
using MyLibrary
puts “Kitty”.hello
# => Hello Kitty

Inside Refinement
Actually, refinement creates an annoymous
module to mixin a class.
module MyLib
refine String do
puts self.is_a?(Module) # => true
puts self
# => #<refinement:String@MyLibrary>
end
end

Inside Refinement

module MyLib
refine String do

module
<refinement:String@MyLibrary>
end
end

It is ...

Automatic Mixining
自動化MIXIN

When using MyLibrary ...
every new instance of String is extended!
using MyLibrary
puts “x”.hello # “x” is extended
puts String.new(“x”).hello

using is lexical in scope
just like Java’s import

using is lexical
1. Refinements are activated only at top-level
- Not inside class, module, and method scope
2. Scope of the effect is the whole source code

using is lexical
Please DO NOT…
class Foo
using MyLib
end

module Moo
using MyLib
end

def bar
using MyLib
end

using is lexical
# refinement of MyLib is deactived
# “World”.hello # => NoMethodError
using MyLib # activate!
# refinement of MyLib is activated
def hello_world
“World”.hello
end
# END OF FILE

Scope of
MyLib
Refinement

Refinement in Ruby
1. Actually, it is based on Mixining
2. Avoid global scope corruption
3. Prefer lexical scope to runtime scope
=> easy to use, just like import in Java

Better Refinement
than
Monkey Patching
please, get rid of monkey patching.

魔法のRuby
まほうのRuby

本簡報
用高橋流製作
在此向たかはしさん致敬

Magic in ruby

More Related Content

What's hot (15)

Viewers also liked (7)

Similar to Magic in ruby (17)

Recently uploaded (20)

Magic in ruby