[ruby-talk:14930] Re: Class/Module Information

> "Yukihiro Matsumoto" <[e-mail]> wrote in message news:[e-mail]...

Thank you for the response.

To recap (mostly for me), the goal was to develop a means
to list all of the items specifically contributed by a class or
module to the system, and only those items.

I included a more comprehensive example at the end of this
message to exhibit some additional cases to my original
post.

>
> Confucius once said "accept things as they are". ;-)

I am sure it unwise to contradict Confucius. Unfortunately, I
cannot recall anyone ever saying I was wise ;-(

>
> Anyway, let me think about things.
>
> Included Modules:
>
>   current Ruby implementation does not distinguish direct included
>   modules (B, this case) and indirect included modules (A, this
>   case).

A possible addition to a future version?

>
> Constants:
>
>   you can get this information by
>
>     c = C.constants
>     C.included_modules.each{|m| c -= m.constants}
>

Classes require a little additional work (versus modules only) as you
get everything from the superclasses and any requires, see example
below. I am sure you must be aware of these, but I included them for
completeness.

> Class Variables:
>
>   same as above.  it might be useful to add optional argument to
>   restrict search for this class/module only.
>

This would cover most of my wants.

> Instance Variables:
>
>   In Ruby, instance variables belong to each instance, not a class nor
>   module, so that you can get their information from module.
>

Is this not also true for instance methods? Yet, instance_methods
returns the list I am interested in since it restricts superclass information
by default.

> matz.

# Example Code Begins Here

require "tk"

module A
  CONSTANT_A = "A"
  @@class_a = nil
  def func_a
    @var_a = nil
  end
end

module B
  include A
  CONSTANT_B = "B"
  @@class_b = nil
  def func_b
    @var_b = nil
  end
end

module C
  include B
  CONSTANT_C = "C"
  @@class_c = nil
  def func_c
    @var_c = nil
  end
end

class D
  CONSTANT_D = "D"
  @@class_d = nil
  def func_d
    @var_d = nil
  end
end

class E < D
  include C
  CONSTANT_E = "E"
  @@class_e = nil
  def func_e
    @var_e = nil
  end
end

if __FILE__ == $0

  if false

    # Put test code here.
    # Change false to true for testing.

  else

  # Module Tree

    c  = C.constants
    cv = C.class_variables

    C.included_modules.each do |m|
      c  -= m.constants
      cv -= m.class_variables
    end

    print "\n"
    print "Current Ruby Processing (Modules):\n"
    print "Name ................. "; p C.name
    print "Included Modules ..... "; p C.included_modules
    print "Constants ............ "; p C.constants
    print "Class Variables ...... "; p C.class_variables
    print "Instance Variables ... "; p C.instance_variables
    print "Instance Methods ..... "; p C.instance_methods

    print "\n"
    print "Modified Ruby Processing (Modules):\n"
    print "Name ................. "; p C.name
    print "Included Modules ..... "; p C.included_modules
    print "Constants ............ "; p c
    print "Class Variables ...... "; p cv
    print "Instance Variables ... "; p C.instance_variables
    print "Instance Methods ..... "; p C.instance_methods

    puts
    puts  'Desired Output (Modules):'
    puts  'Name ................. "C"'
    puts  'Included Modules ..... [B]'
    puts  'Constants ............ ["CONSTANT_C"]'
    puts  'Class Variables ...... ["@@class_c"]'
    puts  'Instance Variables ... ["@var_c"]'
    puts  'Instance Methods ..... ["func_c"]'

  # Class/Module Tree

    c  = E.constants
    cv = E.class_variables
    sc = E.superclass

    E.included_modules.each do |m|
      c  -= m.constants
      cv -= m.class_variables
    end

    while sc
      c  -= sc.constants
      cv -= sc.class_variables
      sc  = sc.superclass
    end

    print "\n"
    print "Current Ruby Processing (Class/Module):\n"
    print "Name ................. "; p E.name
    print "Included Modules ..... "; p E.included_modules
    print "Constants ............ "; p E.constants
    print "Class Variables ...... "; p E.class_variables
    print "Instance Variables ... "; p E.instance_variables
    print "Instance Methods ..... "; p E.instance_methods

    print "\n"
    print "Modified Ruby Processing (Class/Module):\n"
    print "Name ................. "; p E.name
    print "Included Modules ..... "; p E.included_modules
    print "Constants ............ "; p c
    print "Class Variables ...... "; p cv
    print "Instance Variables ... "; p E.instance_variables
    print "Instance Methods ..... "; p E.instance_methods

    puts
    puts  'Desired Output (Class/Module):'
    puts  'Name ................. "E"'
    puts  'Included Modules ..... [C]'
    puts  'Constants ............ ["CONSTANT_E"]'
    puts  'Class Variables ...... ["@@class_e"]'
    puts  'Instance Variables ... ["@var_e"]'
    puts  'Instance Methods ..... ["func_e"]'

  end

end

# Example Code Ends Here