在ruby中，如何将原始源代码加载到Proc的实例？（在类方法中将`before`之后`钩子添加）

Question

Normally, we can do this with Proc objects:

[15] pry(main)> pr = -> { puts "test message" }                                                                                                                                                                                                                          
=> #<Proc:0x000000057b8a90@(pry):12 (lambda)>
[16] pry(main)> pr.call                                                                                                                                                                                                                                                  
test message
=> nil
[17] pry(main)> define_method("test_method", pr)                                                                                                                                                                                                                         
=> :test_method
[18] pry(main)> test_method                                                                                                                                                                                                                                              
test message

But, what if I have a raw code string and want to load it into a proc? Fake code below:

raw_code = "puts 'test message'"
pr = -> { load(raw_code) }   # how to define the `load` method to get this working?
pr.call   # => test message

define_method("test_method", pr}
test_method  # => test message

Actually, my original problem is how to write a method hook like this:

class TestClass
  def test_method
    puts url
  end
  def test_method_a
    puts url
  end
  before :test_method, :test_method_a do
    url = __method__.split("_").join("/")
  end
end

TestClass.new.test_method # => "test/method"
TestClass.new.test_method_a # => "test/method/a"

My problem is more complicated, this is just a simple example to illustrate the key problem.

Answer 1

how to define the load method to get this working?

By spelling it eval :

raw_code = "puts 'test message'"
pr = -> { eval(raw_code) }   # how to define the `load` method to get this working?
pr.call   # => test message

define_method("test_method", pr)
test_method  # => test message

--output:--
test message
test message

Actually, my original problem is how to write a method hook...

class TestClass
  def initialize
    @url = %q{__method__.to_s.split("_").join("/")}
  end

  def test_method
    puts(eval @url)
  end

  def test_method_a
    puts(eval @url)
  end
end

TestClass.new.test_method # => "test/method"
TestClass.new.test_method_a # => "test/method/a"

--output:--
test/method
test/method/a

Actually, my original problem is how to write a method hook like this:

 Module TestClass def test_method puts url end 

The problem is that url can never refer to a value outside the def. A def cuts off the visibility of local variables outside the def.

class TestClass

  def test_method
    puts @url
  end

  def test_method_a
    puts @url
  end

  def self.before(*method_names, &block)
    method_names.each do |method_name|
      alias_method "first_#{method_name}", method_name
      define_method(method_name, block) #This changes __method__ inside the block from nil to method_name

      alias_method "second_#{method_name}", method_name
      define_method(method_name) do
        send "second_#{method_name}"  #This method executes: @url = __method__.to_s.split(...
        send "first_#{method_name}"   #This method executes: puts @url
      end
    end
  end

  before :test_method, :test_method_a do
    @url = __method__.to_s.split("_").join("/")
  end
end

TestClass.new.test_method # => "test/method"
TestClass.new.test_method_a # => "test/method/a"

--output:--
test/method
test/method/a

Answer 2

Short version: load loads code from a file . If you want to run code that you already have in a string, you can use eval , or one of it's friends, class_eval or instance_eval .

If you do end up using eval , however, you need to be very careful so that you won't accidentally run code that could delete your files, install malware or whatever.

Longer version: For a working version (in ruby 2.2.3) with load , you would need to put your TestClass class in a file:

class TestClass
  def test_method
    puts "OHAI"
  end
end

Let's save this class in a file called "test_class.rb".

With that, the following should just work:

pr = -> { load(File.join(__dir__, "test_class.rb")) }
pr.call
TestClass.new.test_method

This will not solve your "original problem", but it should give you a little better understanding on how load works.

Answer 3

---

My own solution and more detail shown here after reading reply:

Maybe there is a lot of confusion about why does my problem method hook matter with load raw source code to Proc instance .

And also, I've solved my problem,now. So,let me explain the whole thing in detail:

1, my original problem comes from that I need to extract a bunch of duplicated code at head of some methods of a module just like this:

module TestClass
  extend self

  def test_method
    url = __method__.to_s.split("_").join("/")  # duplicated code,need to extract
    puts url
  end

  def test_method_a
    url = __method__.to_s.split("_").join("/")  # duplicated code, need to extract
    puts url
  end

2, Then, after a lot of thinking, I come up with an idea, that's get test_method test_method_a 's source code, and modify the source code by adding url = __method__.to_s.split("_").join("/") at the head of it, then redefine the method with new code.

3, After lot of hack, I failed with using eval and then, post here asking help.

4, After reading reply, I make sure eval is definitely what I want.

5, Finally, I succeed, code show here:

 module TestClass
  extend self

  def test_method
    puts url
  end

  def test_method_a
    puts url
  end

  [ :test_method, :test_method_a ].each do |name|
    method_source_code_ar = instance_method(name).source.split("\n")

    method_source_code_ar.insert(1, 'url = __method__.to_s.split("_").join("/")')

    method_source_code = method_source_code_ar[1..-2].join("\n")

    define_method(name, -> { eval(method_source_code) })
  end

end

TestClass.test_method  # => test/method
TestClass.test_method_a  # => test/method/a

6, More concise code version show:

module TestClass
  extend self

  def test_method
    puts url
  end

  def test_method_a
    puts url
  end

  [ :test_method, :test_method_a ].each do |name|
    method_source_code_ar = instance_method(name).source.split("\n")

    method_source_code_ar.insert(1, 'url = __method__.to_s.split("_").join("/")')

    method_source_code = method_source_code_ar.join("\n")

    eval(method_source_code)
  end

end

7, As eval ,for me, I think the key to understand it is,thinking not as if you're in writing mode, but as if code was running line by line until reaching the eval line code, by that time, what do you want the code to do? Sure, just eval the method_source_code string.