RoR - MetaProgramming

ruby是动态语言，它有动态语言的优势与劣势

动态语言，像python与ruby 你不用提前去定义method - they need to only be "found" when invoked

calling method dynamically:

class Dog
    def bark
         puts "Woof, woof!'
    end
    def greet(greeting)
        puts greeting
    end
end

dog = Dog.new
dog.bark # => Woof, woof!
dog.send("bark") # => Woof, woof!
dog.send(:bark) # => Woof, woof!
method_name = :bark
dog.send method_name # => Woof, woof!

dog.send(:greet, "hello") # => hello

　　Dynamic Dispatch:

　　不需要call method 用 xxx.xxx

　　能用string和symbol call methods dynamically

优点：*can decide at runtime which methods to call

*The code doesn't have to find out until runtime which method it needs to call

Dynamic method：

class Whatever
    define_method :make_it_up do
        puts "Whatever..."
    end
end

whatever = Whatever.new
whatever.make_it_up # => Whatever...

写动态方法能有效降低code量

require_relative 'store'
class ReportingSystem 

    def initialize
        @store = Store.new
        @store.methods.grep(/^get_(.*)_desc/) { ReportingSystem.define_report_method_for $1 )
    end

    def self.define_repot_methods_for (item)
        define_method ("get_#{item}_desc") {@store.send("get_#{item}_desc) }
        define_method ("get_#{item}_price") {@store.send("get_#{item}_desc) }
    end
end

r3 = ReportingSystem.new
puts "#{rs.get_piano_desc} costs #{rs.get_piano_price.to_s.ljust(6.'0')}"

# => Excellent piano costs 120.00

Ghost method:

如果我们使用了不存在的method，会自动跳转到method_missing  method，不过method_missing 可以被复写：

class Mystery
    #no_methods defined
    def method_missing (method, *args)
        puts "Looking for..."
        puts "\"#{method}\" with params {#{args.join(',')}} ?"
        puts "Sorry... He is on vacation... "
        yield "Ended up in method_missing" if block_given?
    end
end 

m = Mystery.new
m.solve_mystery("abc", 123123) do |answer|
    puts "And the answer is: #{answer}"
end

# =>  Looking for...
# =>  "solve_mystery" with params (abc,123123) ?
# =>  Sorry... He is on vacation...
# =>  And the answer is: Ended up in method_missing

* method_missing gives you the power to "fake" the methods

* 这被叫做ghost methods 是因为 它并不真正意义上的存在

*ruby built-in classes use method_missing and dynamic methods all over the place...

Struct and OpenStruct:

Struct: 特定类的生成器，每个类都被定义为保存一组变量及其访问器（动态
方法)

OpenStruct: 对象（类似于Struct），其属性在第一次分配时动态创建（“Ghost方法”）。

Customer = Struct.new(:name, :address) do #block is optional
    def to_s
        "#{name} lives at #{address}"
    end
end
jim = Customer.new("Jim", "-1000 wall Street")
puts jim # => Jim lives at -1000 wall Street

require 'ostruct' # => need to require ostruct for OpenStruct 

some_obj = OpenStruct.new(name: "Joe", age: 15)
some_obj.sure = "three"
some_obj.really = "yes, it is true"
some_obj.not_only_strings = 10
puts "#{some_obj.name} #{some_obj.age} #{some_obj.really}"
#=> Joe 15 yes,it is true

method_missing and Performance:

因为调用是直接的，所以可能会慢一些，但大多数情况下不影响。

如果考虑响应速度的话，可以考虑hybird approach

*Define a real method from inside method missing after an attempted ‘call’

Ghost methods allow you to call methods as if they are there even though they are not
Method behavior can be defined at runtime , for example based on database columns existing or not .