GOLF (and improve) #instance_interception

I have been working on this and was hoping maybe others would like to
take some wacks at it. It’s a general purpose tool for prepending a
module in the inheritance chain. Here’s an example of it’s use. (code
follows):

module A
def f ; “F” ; end
def g ; “G” ; end

instance_interception do
  def f( target, *args, &blk )
    '{' + target.super + '}'
  end
  def g( target, *args, &blk )
    '{' + target.super + '}'
  end
end

end

class X
def f ; super ; end
include A
def g ; super ; end
end

x = X.new
x.f #=> “{F}”
x.g #=> “#{G}”

instance_interception.rb

class Module

def instance_interception(&block)
@instance_interception ||= Module.new do
def self.append_features(mod)
append_features_without_instance_interception( mod )
end
end
@instance_interception.module_eval(&block) if block_given?
@instance_interception
end

private :instance_interception

alias_method :append_features_without_instance_interception,
:append_features

Append features

def append_features( mod )

aspect = instance_interception
aspect.__send__( :append_features_without_instance_interception,

mod )

aspect.instance_methods.each do |meth|
  if mod.method_defined?( meth )
    aspect.advise( mod, meth )
  end
end

append_features_without_instance_interception( mod )

#if mod.instance_of? Module
aspect.__send__( :append_features_without_instance_interception,

mod.send(:instance_interception) )
#end

end

Apply the around advice.

def advise( mod, meth )
advice = instance_method( meth )
instance_target = mod.instance_method(meth)
mod.send( :define_method, meth ) { |*args| #, &blk|
target = instance_target.bind( self )
(class << target; self; end).class_eval { define_method( :super
){ call( *args ) } }
advice.bind( self ).call( target, *args ) #, &blk )
}
end

If a method is added to the module/class that is advised.

def method_added( meth )
return if @method_added_short
if instance_interception.method_defined?( meth )
include instance_interception
@method_added_short = true
instance_interception.advise( self, meth )
@method_added_short = false
end
end

end

[email protected] wrote:

def f ; “F” ; end
def g ; “G” ; end

Well, the golf part is easy, but I don’t think it looks very good:

module A;def f;“F”;end;def g;“G”;end;end

Are you sure you want to golf this? :slight_smile:

Well, okay. I guess golf isn’t exactly what I mean. Just *improve"
then. Thanks.

BTW, typo in example:

x.g #=> “#{G}”

should be

x.g #=> “{G}”

T.

Hi –

On Fri, 14 Jul 2006, [email protected] wrote:

I have been working on this and was hoping maybe others would like to
take some wacks at it. It’s a general purpose tool for prepending a
module in the inheritance chain. Here’s an example of it’s use. (code
follows):

module A
def f ; “F” ; end
def g ; “G” ; end

Well, the golf part is easy, but I don’t think it looks very good:

module A;def f;“F”;end;def g;“G”;end;end

Are you sure you want to golf this? :slight_smile:

David

Ryan D. wrote:

It looks an awful lot like MuffDaddy to me.

http://blog.zenspider.com/archives/2005/02/muffdaddy_the_u.html

'Fraid MuffDaddy’z not so “ultimate” – It’s not dynamic.

T.

It looks an awful lot like MuffDaddy to me.

http://blog.zenspider.com/archives/2005/02/muffdaddy_the_u.html

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs