How does this deprecate method work?

Question

I was trying to understand this call:

deprecate :new_record?, :new?

which uses this deprecate method:

   def deprecate(old_method, new_method)
      class_eval <<-RUBY, __FILE__, __LINE__ + 1
        def #{old_method}(*args, &block)
          warn "\#{self.class}##{old_method} is deprecated," + 
                "use \#{self.class}##{new_method} instead"
          send(#{new_method.inspect}, *args, &block)
        end
      RUBY
    end

I don't really understand the metaprogramming that's being used here. But, is this just another way of aliasing the new_record? method - so in effect, new_record? is still available but it issues a warning when you use it? Would anyone like to explain how this works?

Answer 1

ok, so what happens here is that all the functionality of old_method has been moved to new_method by the programmer. To make both names point to the same functionality but note the deprecation, the programmer puts in the deprecate line. This causes the string specified in the <-RUBY heredoc (http://en.wikipedia.org/wiki/Heredoc) to be interpreted as code (evaluated) at the class level. The string interpolations work just as they do in normal ruby strings.

The code then looks something like this (if we were to expand out the metaprogramming)

class SomeClass
  def new?; true; end

  deprecate :new_record?, :new? # this generates the following code

  def new_record?(*args, &block)
    warn "SomeClass#new_record? is deprecated," + 
            "use SomeClass#new? instead"
    send(:new?, *args, &block)
  end
end

I hope that makes sense