ruby - nomethoderror undefined method `+'' for nil nilclass

Ruby-Módulo:: NoMethodError

Question

Tengo un módulo como este:

module Prober
  def probe_invoke(type, data = {})
    p = Probe.new({:probe_type => type.to_s,
        :data => data.to_json, :probe_status => 0, :retries => 0})
    p.save
  end
end

Y estoy tratando de acceder a esto desde mi programa principal como este:

require ''prober''
Prober.probe_invoke("send_sms", sms_text)

Pero genera error:

método indefinido `probe_invoke ''para Prober: Module (NoMethodError)

Answer 1

Aparte de las respuestas que te dan la opción de definir la función como self. , tiene otra opción de incluir el módulo y llamarlo sin la referencia del módulo como esta:

module Prober
  def probe_invoke(type, data = {})
    p = Probe.new({:probe_type => type.to_s,
        :data => data.to_json, :probe_status => 0, :retries => 0})
    p.save
  end
end

y puedes llamarlo así:

require ''prober''
include Prober
probe_invoke("send_sms", sms_text)

Answer 2

Junto a las respuestas aquí también puedes hacer lo siguiente:

module Prober
  class << self
    def probe_invoke(type, data = {})
      p = Probe.new({:probe_type => type.to_s,
          :data => data.to_json, :probe_status => 0, :retries => 0})
      p.save
    end

    # more module instance methods ...
  end
end

La class << self block definirá también todos los métodos en ella como métodos de instancia de su módulo.

(Su funcionalidad es la misma que para definir cada método individual por def Prober.mymethod ... o def self.mymethod ... )

Actualización (2014-11-22)

De acuerdo con la Guía de estilo de Ruby, debes usar module_function en module_function lugar:

module Prober
  module_function # <-- preferred style nowadays

  def probe_invoke(type, data = {})
    Probe.new(probe_type:   type.to_s,
              data:         data.to_json,
              probe_status: 0,
              retries:      0)
      .save # no need for a temporary variable
  end

  # more module methods ...
end

Yo llamaría a esto módulos de utilidad .

Por cierto: en el pasado era más común utilizar extend self lugar de envolver los métodos en una class << self block.

También adapté el código anterior a otras recomendaciones de guías de estilo.

Answer 3

La forma más fácil es convertir su método en un método de nivel de módulo:

module Prober
  def Prober.probe_invoke(type, data = {})
    p = Probe.new({:probe_type => type.to_s,
        :data => data.to_json, :probe_status => 0, :retries => 0})
    p.save
  end
end

def self.probe_invoke también funcionaría, porque en el momento en que se ejecuta esa línea, self es la definición del módulo.

Answer 4

La respuesta es:

module Prober
  def Prober.probe_invoke(type, data = {})
    p = Probe.new({:probe_type => type.to_s,
        :data => data.to_json, :probe_status => 0, :retries => 0})
    p.save
  end
end

Prober.probe_invoke("send_sms", sms_text)

Porque de lo contrario, define el método como un método de instancia del módulo, pero en realidad desea definirlo de forma estática.