Class_extension and module_extension

Ruby
1

Just a quick comment about class_extension. In using I’ve come across
cases where I want the extension to propogate through further
inclusions and cases where I do not. So I think we new two versions,
one for each. Perhapos the propogating version caould be called
module_extension.

Thanks,
T.

2

This is actually pretty interesting. I’m in the midst of deep meta code
and I have the situation where I’m creating a sort of DSL for building
classes --you know, defining my own attr methods. And then I use that
in a module which is to be included into my class. That way I keep
these DSL methods out of my class (qua class). Eg.

module MetaDSL
def foos() @foos ||=[] end
def metafoo x
foos << x
attr_reader “#{x}oo”
end
end

module MetaFoo
extend MetaDSL
metafoo :f
end

class Foo
include MetaFoo
end

The problem is that I actaully want #foos to show up in my class (qua
class) but not metafoo! How’s can I achieve that?

In the future there’s class_extension, and I suggested
module_extiension too, one for propogating and one not (which is
which?) So a solution would be:

module MetaDSL
# lets say class_extension propogates
class_extension do
def foos() @foos ||=[] end
end
# and module_extension does not
module_extension do
def metafoo x
foos << x
attr_reader “#{x}oo”
end
end
end

module MetaFoo
include MetaDSL
metafoo :f
end

But uh oh! Now the two methods can’t see each other. Well, maybe we can
fix by including the returned module of each when invoked without a
block:

module MetaDSL
class_extension do
def foos() @foos ||=[] end
end
include class_extension

module_extension do
  def metafoo x
     foos << x
     attr_reader "#{x}oo"
  end
end
include module_extension

end

Will that work? Well, I assume somthing to that effect would. But even
so, now I’m looking at this and thinking it got quite complex, when all
I really want to do is control visibility, much like public, private
and protected. But local, single_provision, and propogated (for lack of
better terms).

T.