Ausführen von Code für jeden Methodenaufruf in einem Ruby-Modul

Ich Schreibe ein Modul in Ruby 1.9.2, definiert mehrere Methoden. Wenn eine dieser Methoden aufgerufen wird, möchte ich jeden von Ihnen zum ausführen einer bestimmten Anweisung zuerst.

module MyModule
  def go_forth
    a re-used statement
    # code particular to this method follows ...
  end

  def and_multiply
    a re-used statement
    # then something completely different ...
  end
end

Aber ich möchte vermeiden, dass a re-used statement code explizit in jeder einzelnen Methode. Gibt es eine Möglichkeit, dies zu tun?

(Wenn es darauf ankommt, a re-used statement wird jede Methode, wenn Sie aufgerufen wird, drucken Sie Ihren eigenen Namen. Es wird über eine Variante der puts __method__.)

InformationsquelleAutor der Frage GladstoneKeep | 2011-04-01

Wie diese:

module M
  def self.before(*names)
    names.each do |name|
      m = instance_method(name)
      define_method(name) do |*args, &block|  
        yield
        m.bind(self).(*args, &block)
      end
    end
  end
end

module M
  def hello
    puts "yo"
  end

  def bye
    puts "bum"
  end

  before(*instance_methods) { puts "start" }
end

class C
  include M
end

C.new.bye #=> "start" "bum"
C.new.hello #=> "start" "yo"

InformationsquelleAutor der Antwort horseyguy

10

Dies ist genau das, was aspector erstellt.

Mit aspector brauchen Sie nicht zu schreiben, das boilerplate metaprogramming-code. Sie können sogar einen Schritt weiter gehen, um zu extrahieren die gemeinsame Logik in einem separaten Aspekt der Klasse und testen unabhängig.
```
require 'aspector'

module MyModule
  aspector do
    before :go_forth, :add_multiply do
      ...
    end
  end

  def go_forth
    # code particular to this method follows ...
  end

  def and_multiply
    # then something completely different ...
  end
end
```
InformationsquelleAutor der Antwort Guoliang Cao

Ich weiß nicht, warum ich downvoted, aber einen richtigen AOP-framework ist besser als meta-Programmierung Hack. Und das ist, was die OP wurde versucht zu erreichen.

http://debasishg.blogspot.com/2006/06/does-ruby-need-aop.html

Andere Lösung könnte sein:

module Aop
  def self.included(base)
    base.extend(ClassMethods)
  end

  module ClassMethods
    def before_filter(method_name, options = {})
      aop_methods = Array(options[:only]).compact
      return if aop_methods.empty?
      aop_methods.each do |m|
        alias_method "#{m}_old", m
        class_eval <<-RUBY,__FILE__,__LINE__ + 1
          def #{m}
            #{method_name}
            #{m}_old
          end
        RUBY
      end
    end
  end
end

module Bar
  def hello
    puts "Running hello world"
  end
end

class Foo
  include Bar
  def find_hello
    puts "Running find hello"
  end
  include Aop
  before_filter :find_hello, :only => :hello
end

a = Foo.new()
a.hello()

InformationsquelleAutor der Antwort Hemant Kumar

Implementieren Sie können es mit method_missing durch proxy-Modul, so wie dieses:

module MyModule

  module MyRealModule
    def self.go_forth
      puts "it works!"
      # code particular to this method follows ...
    end

    def self.and_multiply
      puts "it works!"
      # then something completely different ...
    end
  end

  def self.method_missing(m, *args, &block)
    reused_statement
    if MyModule::MyRealModule.methods.include?( m.to_s )
      MyModule::MyRealModule.send(m)
    else
      super
    end
  end

  def self.reused_statement
    puts "reused statement"
  end
end

MyModule.go_forth
#=> it works!
MyModule.stop_forth
#=> NoMethodError...

InformationsquelleAutor der Antwort fl00r

Können Sie dies tun, indem Sie metaprogramming Technik, hier ein Beispiel:

module YourModule
  def included(mod)
    def mod.method_added(name)
      return if @added 
      @added = true
      original_method = "original #{name}"
      alias_method original_method, name
      define_method(name) do |*args|
        reused_statement
        result = send original_method, *args
        puts "The method #{name} called!"
        result
      end
      @added = false
    end
  end

  def reused_statement
  end
end

module MyModule
  include YourModule

  def go_forth
  end

  def and_multiply
  end
end

funktioniert nur in ruby 1.9 und höher

UPDATE: und auch nicht verwenden können, blockieren, d.h. es werden keine Ausbeute in Instanz-Methoden

InformationsquelleAutor der Antwort megas

0

Ist es möglich, mit der meta-Programmierung.

Andere alternative ist Aquarium. Aquarium ist ein framework implementiert, mit der Aspekt-Orientierten Programmierung (AOP) für Ruby. AOP erlauben, Sie zu implementieren, die die Funktionalität über die normale Objekt und Methode Grenzen. Ihre Nutzung Fall der Anwendung eines pre-Aktion auf jede Methode, ist eine grundlegende Aufgabe des AOP.

InformationsquelleAutor der Antwort Hemant Kumar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.