How Well does Ruby support Aspect Oriented Programming?

Here’s my question, I would really appreciate input from the list.

What is the most basic, narrowest AOP feature that Ruby can not support
without language extensions?

Take “support” to be a very broad term. If Ruby can effectively
provide the same functionality, but perhaps with a different syntax or
with a reasonable number of “hoops,” that’s fine.

For reference, here are 2 wiki pages that prompted this question. My
contention, based on my very limited knowledge of Ruby and AOP, is that
some/many of the language extensions proposed here are not necessary,
but I would be happy to be proven wrong. I really just want input from
the group.

What follows is the thought process that drove me to ask this question
of the group

From the first link, here is a code example involving a “cut,” a
proposed language extension

cut A < C
def m1
print ‘{’, super, ‘}’
end #=> {1}

I believe anything accomplished here can just as easily be accomplished
by aliasing the existing m1 method, and (re)def’ing C#m1, calling the
old method (via the alias) from the new. Obviously, taking my example
literally, that’s far too much work for a common construct. The
systemized, native ruby version of that would look something as
follows, with wrap method being a method on Object utilizing the eval
methods (i.e. metaprogramming). I have a working implementation of
both of these methods.

class C
wrap_method (m1), { |this,old_method,*args| “(” +
old_method(*args).to_s + “)” }

A similar method takes 2 blocks, with the first determining what
methods to wrap

class C
wrap_matching_methods { |method| method == “m1” } {
|this,old_method,*args| “(” + old_method(*args).to_s + “)” }

Clearly, the code from the article I quoted is merely a simple example,
and does not encompass all functionality. I use it as a cherry-picked

I look forward to everyone’s input