[ruby-talk:12732] ModuleModifier.rb - An interesting idea...

Hello,

While exploring Ruby and looking for answers to my recent questions
(see [ruby-talk:12557]).  I came up with an interesting use of
append_features().

I'm looking at using Ruby in a virtual environs project and wanted
a language that was expressive and simple as Smalltalk but was
embeddable and could eventually support native compilation or 
running in an embeddable VM.  Ruby looks like it has that potential
and even has projects working in these directions.

As a bonus Ruby is very expressive at the meta level and allows
extending the language into interesting directions.  One of the
features I wanted with my virtual environs efforts was the ability
for the language implementing environment and entity behavior to
refer to feature sets though a common naming scheme and allow
extending system and user classes by referring to a common feature
name while hiding class specific specializations.

Here is what I came up with using Ruby.  It is a module that allows
packaging extensions to a class or set of classes into a single
module that can be referred to by a single name, and dynamically
extends any classes as necessary to implement the desired behavior
across the calling classes.  I hate the name, ModuleModifier, if
anyone can think of a better OO domain specific nomenclature I
would happily change it.  The comments below contain a functional
example.

Being new to Ruby and OO in general, I would be interested in any
comments.  Please forgive me if my explanation seems thin, I'm 
still learning the vocabulary necessary to communicate OO design
and methodologies.

-Freeman

# ModuleModifier.rb

# ModuleModifier is used to enable modules to package modifications
# to including classes or modules under a common name

# Example:
#
# require "ModuleModifier"
#
# module Foo
#
#   include ModuleModifier
#
#   def whoami
#     puts "#{self.class} = #{self}"
#   end
#
#   module Bar
#     def hello
#       puts "Hello, World!"
#     end
#   end
#
#   module Baz
#     def goodbye
#       puts "Goodbye cruel world!"
#     end
#   end
#
# end
#
# class Bar
#   include Foo
# end
#
# class Baz
#   include Foo
# end
#
# p Bar.ancestors		# -> [Bar, Foo, Foo::Bar, Object, Kernel]
# p Baz.ancestors		# -> [Baz, Foo, Foo::Baz, Object, Kernel]
#
# bar = Bar.new
# baz = Baz.new
#
# bar.whoami			# -> Bar = #<Bar:0x40197e98>
# baz.whoami			# -> Baz = #<Baz:0x401949a0>
#
# bar.hello			# -> Hello, World!
# baz.goodbye			# -> Goodbye cruel world!
#

module ModuleModifier
  
  # Override append_features to add a custom append_features()
  # to the class including ModuleModifier.

  def ModuleModifier.append_features (klass)
    klass.module_eval %Q{

      def #{klass}.append_features (klass)
	klass.ancestors.each { |ancestor|
	  if eval "defined? \#{self}::\#{ancestor}"
	    klass.module_eval "include \#{self}::\#{ancestor}"
	    break
	  end
	}
	super
      end

    }
    # Neglicting to call super here keeps ModuleModifier from being
    # added as an ancestor to the class we are modifying.
  end

end