从gem继承一个类并添加本地方法

Question

I use a gem to manage certain attributes of a gmail api integration, and I'm pretty happy with the way it works.

I want to add some local methods to act on the Gmail::Message class that is used in that gem.

ie I want to do something like this.

models/GmailMessage.rb
  class GmailMessage < Gmail::Message

    def initialize(gmail)
      #create a Gmail::Message instance as a GmailMessage instance 
      self = gmail
    end

    def something_clever
      #do something clever utilising the Gmail::Message methods
    end
  end

I don't want to persist it. But obviously I can't define self in that way.

To clarify, I want to take an instance of Gmail::Message and create a GmailMessage instance which is a straight copy of that other message.

I can then run methods like @gmail.subject and @gmail.html, but also run @gmail.something_clever... and save local attributes if necessary.

Am I completely crazy?

Answer 1

You can use concept of mixin , wherein you include a Module in another class to enhance it with additional functions.

Here is how to do it. To create a complete working example, I have created modules that resemble what you may have in your code base.

# Assumed to be present in 3rd party gem, dummy implementation used for demonstration
module Gmail
    class Message
        def initialize
            @some_var = "there"
        end
        def subject
            "Hi"
        end
    end
end

# Your code
module GmailMessage
    # You can code this method assuming as if it is an instance method
    # of Gmail::Message. Once we include this module in that class, it
    # will be able to call instance methods and access instance variables.
    def something_clever
        puts "Subject is #{subject} and @some_var = #{@some_var}"
    end
end

# Enhance 3rd party class with your code by including your module
Gmail::Message.include(GmailMessage)

# Below gmail object will actually be obtained by reading the user inbox
# Lets create it explicitly for demonstration purposes.
gmail = Gmail::Message.new

# Method can access methods and instance variables of gmail object
p gmail.something_clever  
#=> Subject is Hi and @some_var = there

# You can call the methods of original class as well on same object
p gmail.subject
#=> "Hi"

Answer 2

Following should work:

class GmailMessage < Gmail::Message

  def initialize(extra)
    super
    # some additional stuff
    @extra = extra
  end

  def something_clever
    #do something clever utilising the Gmail::Message methods
  end

end

GmailMessage.new # => will call first the initializer of Gmail::Message class..

Answer 3

I'm not sure why you can't just have a simple wrapper class...

class GmailMessage

  def initialize(message)
    @message = message
  end

  def something_clever
    # do something clever here
  end

  def method_missing(m, *args, &block)  
    if @message.class.instance_methods.include?(m)
      @message.send(m, *args, &block)
    else
      super
    end  
  end 
end

Then you can do...

  @my_message = GmailMessage.new(@original_message)

@my_message will correctly respond to all the methods that were supported with @original_message and you can add your own methods to the class.

EDIT - changed thanks to @jeeper's observations in the comments

Answer 4

Building upon what the other posters have said, you can use built-in class SimpleDelegator in ruby to wrap an existing message:

require 'delegate'

class MyMessage < SimpleDelegator
  def my_clever_method
    some_method_on_the_original_message + "woohoo"
  end
end

class OriginalMessage
  def some_method_on_the_original_message
    "hey"
  end

  def another_original_method
    "zoink"
  end
end

original = OriginalMessage.new
wrapper = MyMessage.new(original)

puts wrapper.my_clever_method
# => "heywoohoo"

puts wrapper.another_original_method
# => "zoink"

As you can see, the wrapper automatically forwards method calls to the wrapped object.

Answer 5

It's not the prettiest, but it works...

class GmailMessage < Gmail::Message

  def initialize(message)
    message.instance_variables.each do |variable|
      self.instance_variable_set(
        variable, 
        message.instance_variable_get(variable)
        )
    end
  end

  def something_clever
    # do something clever here
  end

end

Thanks for all your help guys.