Advanced Ruby

Advanced Ruby Beyond the Basics

Blocks { puts 'Hello' } do puts 'Hello' end

Blocks def call_block puts 'Start of method' # you can call the block using the yield keyword yield yield puts 'End of method' end # invoke call_block {puts 'In the block' } >> Start of method In the block In the block End of method

Blocks def call_block_with_params puts 'Start of method' yield 'foo' , 'bar' puts 'End of method' end # invoke call_block_with_params {|a,b| puts "#{a} #{b}" } >> Start of method foo bar End of method

Exercise 1 For the class ‘Exercise1’ Implement method ‘greet’ to: Accept an array of names and a block That joins all the names together with ‘and’ Implement method ‘invoke’ to: Call the ‘greet’ method, passing it the names ‘joe’ and ‘fred’ And pass greet a block that adds “Hello” in front of the names returned from ‘greet’ Should return “Hello joe and fred”

Proc objects p = Proc.new { puts "Hello" } p .call l = lambda { puts "Hello" } l .call

Proc vs lambda def return_test l = lambda { return } l .call puts "Still here!" p = Proc.new { return } p .call puts "You won't see this." end return_test >> Still here!

Convert Blocks to Proc objects def grab_block (&block) block .call end grab_block {puts "Hello" }

Higher Order Functions proc = lambda{puts 'Hello' } proc .call def hello (proc) puts "start of method" proc .call puts "end of method" end # invoke hello proc >> Hello >> start of method Hello end of method

Closures >> a = 1 @a = 2 original class Holder def call_block (pr) a = 101 @a = 102 pr .call end end class Creator def create_block a = 1 @a = 2 lambda do puts "a = #{a}" puts "@a = #@a" puts yield end end end block = Creator.new.create_block { "original" } Holder .new.call_block block

Metaprogramming Add/remove classes dynamically Add/remove methods dynamically Change existing methods Intercept messages to objects Useful for DSLs

Adding methods to a class class Object def greet puts "Hello" end end obj = Object.new obj .greet >> Hello obj2 = Object.new obj2 .greet >> Hello

Adding methods to a class - example 3.hours .from_now class Fixnum def hours self * 60 * 60 end def from_now Time .now + self end end

Adding a method to an object obj = Object.new def obj .greet puts "Hello" end obj .greet >> Hello obj2 = Object.new obj2 .greet >> undefined method `greet' for #<Object:0x2bae594>

Singleton Class object Singleton class class module

Adding methods to singleton class s = "Hello" class << s def twice self + " " + self end end puts s .twice >> Hello Hello def s .twice self + " " + self end

Using modules module M def greet puts "Hello" end end obj = C.new class << obj include M end obj.greet obj = C.new obj.extend(M) obj.greet

Class method definitions class String class << self def hello "hello" end end end class << String def hello "hello" end end def String def self .hello "hello" end end

Class methods and inheritance class C singleton class of C class D singleton class of D extends lookup path object

Exercise 2 Add a method to the already existing class ‘Account’ Create file ‘account_transfer_to.rb’ and “re-open” the Account class. To run the specs: spec .

Exercise 3 Add a method to an instance of a class Edit the file ‘account_instance_transfer_to_spec.rb’ Implement the ‘transfer_to’ method here, for account1 only.

Method Aliasing class C def hi puts "hello" end end class C alias_method :original_hi , :hi def hi puts "greetings“ original_hi end end obj = C.new obj .hi >> greetings hello

Exercise 4 Alias an existing method implement the ‘number_of_withdrawals’ and ‘number_of_deposits’ methods in a new file: ‘account_auditing.rb’ Reopen Account class and define @number_of_withdrawals and @number_of_deposits Alias original withdraw, deposit and initialize methods, and implement new versions.

Method_missing class Echo def method_missing method_sym, *args puts "#{method_sym}: #{args.inspect}" end end Echo .new.yell "Hello" , "world!" Echo .new.say "Good" , "bye!" >> yell: ["Hello", "world!"] say: ["Good", "bye!"]

Exercise 5 Using method_missing Implement Remember class from scratch Remember class should accept any method, and store the method and any parameters in a history array

Dynamically add methods >> "defining method yell“ "yell: [\"Hello\", \"world!\"]“ "yell: [\"good\", \"bye\"]"

Dynamically add methods class Echo def method_missing method_sym, *args p "defining method #{method_sym}" self .class.class_eval <<-EOF def #{method_sym.to_s} *args p "#{method_sym}: " + args.inspect end EOF send (method_sym, *args) end end Echo .new.yell "Hello" , "world!" Echo .new.yell "good" , "bye" >> "defining method yell“ "yell: [\"Hello\", \"world!\"]“ "yell: [\"good\", \"bye\"]"

Dynamically add methods class Echo def method_missing method_sym, *args p "defining method #{method_sym}" Echo .class_eval <<-EOF def #{method_sym.to_s} *args p "#{method_sym}: " + args.inspect end EOF send (method_sym, *args) end end Echo .new.yell "Hello" , "world!" Echo .new.yell "good" , "bye" >> "defining method yell“ "yell: [\"Hello\", \"world!\"]“ "yell: [\"good\", \"bye\"]"

Dynamically add instance methods >> "new_method: [\"blah\"]"

Exercise 6 Dynamically add methods to a class at runtime Use method_missing the first time a method is called, but define the missing method on the class Subsequent calls to that method then won’t have to use method_missing.

Further Reading Ruby for Rails book (ch13) – David A. Black Seeing Metaclasses Clearly Dwemthy’s Array Ruby metaprogramming techniques

Extra Stuff Continuations Symbols

Continuations def strange callcc {|continuation| return continuation} print "Back in method. " end print "Before method. " continuation = strange() print "After method. " continuation .call if continuation Before method. After method. Back in method. After method. RETURN THIS

Symbols :this_is_a_symbol :’This is also a symbol’ Has both integer and string representations Is immutable Quicker to lookup than strings Quicker to compare No need to construct a string literal when doing lookups

Advanced Ruby

More Related Content

Similar to Advanced Ruby (20)

Recently uploaded (20)

Advanced Ruby

Editor's Notes