超级扩展/包含的方法ruby

Question

Is there a way I can super a method which is added from extending a module? I am using elasticsearch and need to include the methods

class Someclass
  include Elasticsearch::Model

  class << self
    alias_method :importing, :import
  end
  def self.import(options = {})
    transform = lambda do |a|
        {index: {_id: "#{a.resource_id},#{a.ayah_key}", _parent: a.ayah_key, data: a.__elasticsearch__.as_indexed_json}} 
    end
    options = {transform: transform}.merge(options)
    self.importing options 
  end

end 

The import method from elasticsearch:

   def import(options={}, &block)
      errors       = []
      refresh      = options.delete(:refresh)   || false
      target_index = options.delete(:index)     || index_name
      target_type  = options.delete(:type)      || document_type
      transform    = options.delete(:transform) || __transform
      return_value = options.delete(:return)    || 'count'

      unless transform.respond_to?(:call)
        raise ArgumentError,
              "Pass an object responding to `call` as the :transform option, #{transform.class} given"
      end

      if options.delete(:force)
        self.create_index! force: true, index: target_index
      end

      __find_in_batches(options) do |batch|
        response = client.bulk \
                     index:   target_index,
                     type:    target_type,
                     body:    __batch_to_bulk(batch, transform)

        yield response if block_given?

        errors +=  response['items'].select { |k, v| k.values.first['error'] }
      end

      self.refresh_index! if refresh

      case return_value
        when 'errors'
          errors
        else
          errors.size
      end
    end

When I do self.import , I get stack level too deep error, and when i use super I get no superclass method to super

Update Made it work by added alias_method See above.

Answer 1

When using import options like this:

def import options
  # code...
  import options 
end

You're making a recursive call to the import method defined in Someclass , thus getting an infinite loop.

If you're including the module, then just do this:

class Someclass
  include Elasticsearch::Model::ClassMethods

  def import (options = {})
    transform = lambda do |a|
        {index: {_id: "#{a.resource_id},#{a.ayah_key}", _parent: a.ayah_key, data: a.__elasticsearch__.as_indexed_json}} 
    end
    options = {transform: transform}.merge(options)
    #calling import method from the module
    super options
  end
end

Answer 2

I believe that extend adds class methods to Someclass, so you may need to do:

class Someclass
  extend SomeModuleWithImportMethod

  def self.import
    ...
    super
  end

end