Ruby元编程 打破private protected限制

需求源于分离职责, 对一些涉及多个model的业务，专门分出一个service层来负责，一个service的方法就是装配不同model提供的方法，这些model的方法应该只能被service调用，而不能被controller调用，那就将这些方法设置为private或者protected（绝对限制是做不到的，起码跟普通方法有所区别，不能直接调用），外部只能用send来调用，但如果调用多的话，一是难看且麻烦，二是影响性能，那就meta programming一下吧

思路是动态产生调用者类的子类，然后委托该子类调用父类的private或protected方法，如果调用者是单件类(metaclass)的话那就到此结束了，但如果是实例，调用private方法还是不行，那就是保存实例到子类对象中，同时打开实例类，生成private方法的一个代理，然后子类调用保存的实例调用代理方法，代码与例子如下

=begin
Example:

class A
  class << self
    private
    def t1
    "t1"
    end
  end

  def initialize(a = nil)
    @a = a
  end
  private
  def t1
    @a
  end
end


A.extend(BreakProtect) #or class A; include BreakProtect; end
p A.break_protect.t1
p A.new("leon").break_protect.t1 # or for reuse, a = A.new("leon").break_protect; a.t1
=end

module BreakProtect
  def self.extended(obj)
    set_sub(obj)
  end
  def self.included(obj)
    set_sub(obj)
  end
  def self.set_sub(obj)
    obj.class_eval %{
    class #{obj.to_s}_Sub < #{obj.to_s}
      def initialize(parent)
        @parent = parent
      end
      def self.method_missing(method_id, *args)
        class_eval %\{
                    def self.#\{method_id\}(*args)
                      @parent.nil? ? super : @parent.#\{method_id\}
                    end
                  \}
                  send(method_id, *args)
      end
      def method_missing(method_id, *args)
        if private_methods.include?(method_id.to_s)
          instance_eval %\{
                      class ::#{obj.to_s}
                        def #\{method_id\}_to_protect(*args)
                          #\{method_id\}
                        end
                        protected :#\{method_id\}
                      end
                      def #\{method_id\}(*args)
                        if @parent.nil?
                          super
                        else
                          @parent.#\{method_id\}_to_protect
                        end
                      end
                    \}
        else
          instance_eval %\{
                      def #\{method_id\}(*args)
                        @parent.nil? ? super : @parent.#\{method_id\}
                      end
                    \}
        end
        send(method_id, *args)
      end
    end
    def break_protect
      #{obj.to_s}_Sub.new(self)
    end
    def self.break_protect
      #{obj.to_s}_Sub
    end
  }
  end
end