#$@%#$%!

Ngiler SH3LL 360
: / opt / alt / ruby18 / lib64 / ruby / 1.8 / rdoc /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : code_objects.rb \| Size : 18.03 KB
# We represent the various high-level code constructs that appear # in Ruby programs: classes, modules, methods, and so on. require 'rdoc/tokenstream' module RDoc # We contain the common stuff for contexts (which are containers) # and other elements (methods, attributes and so on) # class CodeObject attr_accessor :parent # We are the model of the code, but we know that at some point # we will be worked on by viewers. By implementing the Viewable # protocol, viewers can associated themselves with these objects. attr_accessor :viewer # are we done documenting (ie, did we come across a :enddoc:)? attr_accessor :done_documenting # Which section are we in attr_accessor :section # do we document ourselves? attr_reader :document_self def document_self=(val) @document_self = val if !val remove_methods_etc end end # set and cleared by :startdoc: and :enddoc:, this is used to toggle # the capturing of documentation def start_doc @document_self = true @document_children = true end def stop_doc @document_self = false @document_children = false end # do we document ourselves and our children attr_reader :document_children def document_children=(val) @document_children = val if !val remove_classes_and_modules end end # Do we _force_ documentation, even is we wouldn't normally show the entity attr_accessor :force_documentation # Default callbacks to nothing, but this is overridden for classes # and modules def remove_classes_and_modules end def remove_methods_etc end def initialize @document_self = true @document_children = true @force_documentation = false @done_documenting = false end # Access the code object's comment attr_reader :comment # Update the comment, but don't overwrite a real comment # with an empty one def comment=(comment) @comment = comment unless comment.empty? end # There's a wee trick we pull. Comment blocks can have directives that # override the stuff we extract during the parse. So, we have a special # class method, attr_overridable, that lets code objects list # those directives. Wehn a comment is assigned, we then extract # out any matching directives and update our object def CodeObject.attr_overridable(name, aliases) @overridables \|\|= {} attr_accessor name aliases.unshift name aliases.each do \|directive_name\| @overridables[directive_name.to_s] = name end end end # A Context is something that can hold modules, classes, methods, # attributes, aliases, requires, and includes. Classes, modules, and # files are all Contexts. class Context < CodeObject attr_reader :name, :method_list, :attributes, :aliases, :constants attr_reader :requires, :includes, :in_files, :visibility attr_reader :sections class Section attr_reader :title, :comment, :sequence @@sequence = "SEC00000" def initialize(title, comment) @title = title @@sequence.succ! @sequence = @@sequence.dup set_comment(comment) end private # Set the comment for this section from the original comment block # If the first line contains :section:, strip it and use the rest. Otherwise # remove lines up to the line containing :section:, and look for # those lines again at the end and remove them. This lets us write # # # --------------------- # # :SECTION: The title # # The body # # --------------------- def set_comment(comment) return unless comment if comment =~ /^.?:section:.$/ start = $` rest = $' if start.empty? @comment = rest else @comment = rest.sub(/#{start.chomp}\Z/, '') end else @comment = comment end @comment = nil if @comment.empty? end end def initialize super() @in_files = [] @name \|\|= "unknown" @comment \|\|= "" @parent = nil @visibility = :public @current_section = Section.new(nil, nil) @sections = [ @current_section ] initialize_methods_etc initialize_classes_and_modules end # map the class hash to an array externally def classes @classes.values end # map the module hash to an array externally def modules @modules.values end # Change the default visibility for new methods def ongoing_visibility=(vis) @visibility = vis end # Given an array +methods+ of method names, set the # visibility of the corresponding AnyMethod object def set_visibility_for(methods, vis, singleton=false) count = 0 @method_list.each do \|m\| if methods.include?(m.name) && m.singleton == singleton m.visibility = vis count += 1 end end return if count == methods.size \|\| singleton # perhaps we need to look at attributes @attributes.each do \|a\| if methods.include?(a.name) a.visibility = vis count += 1 end end end # Record the file that we happen to find it in def record_location(toplevel) @in_files << toplevel unless @in_files.include?(toplevel) end # Return true if at least part of this thing was defined in +file+ def defined_in?(file) @in_files.include?(file) end def add_class(class_type, name, superclass) add_class_or_module(@classes, class_type, name, superclass) end def add_module(class_type, name) add_class_or_module(@modules, class_type, name, nil) end def add_method(a_method) puts "Adding #@visibility method #{a_method.name} to #@name" if $DEBUG a_method.visibility = @visibility add_to(@method_list, a_method) end def add_attribute(an_attribute) add_to(@attributes, an_attribute) end def add_alias(an_alias) meth = find_instance_method_named(an_alias.old_name) if meth new_meth = AnyMethod.new(an_alias.text, an_alias.new_name) new_meth.is_alias_for = meth new_meth.singleton = meth.singleton new_meth.params = meth.params new_meth.comment = "Alias for \##{meth.name}" meth.add_alias(new_meth) add_method(new_meth) else add_to(@aliases, an_alias) end end def add_include(an_include) add_to(@includes, an_include) end def add_constant(const) add_to(@constants, const) end # Requires always get added to the top-level (file) context def add_require(a_require) if self.kind_of? TopLevel add_to(@requires, a_require) else parent.add_require(a_require) end end def add_class_or_module(collection, class_type, name, superclass=nil) cls = collection[name] if cls puts "Reusing class/module #{name}" if $DEBUG else cls = class_type.new(name, superclass) puts "Adding class/module #{name} to #@name" if $DEBUG # collection[name] = cls if @document_self && !@done_documenting collection[name] = cls if !@done_documenting cls.parent = self cls.section = @current_section end cls end def add_to(array, thing) array << thing if @document_self && !@done_documenting thing.parent = self thing.section = @current_section end # If a class's documentation is turned off after we've started # collecting methods etc., we need to remove the ones # we have def remove_methods_etc initialize_methods_etc end def initialize_methods_etc @method_list = [] @attributes = [] @aliases = [] @requires = [] @includes = [] @constants = [] end # and remove classes and modules when we see a :nodoc: all def remove_classes_and_modules initialize_classes_and_modules end def initialize_classes_and_modules @classes = {} @modules = {} end # Find a named module def find_module_named(name) return self if self.name == name res = @modules[name] \|\| @classes[name] return res if res find_enclosing_module_named(name) end # find a module at a higher scope def find_enclosing_module_named(name) parent && parent.find_module_named(name) end # Iterate over all the classes and modules in # this object def each_classmodule @modules.each_value {\|m\| yield m} @classes.each_value {\|c\| yield c} end def each_method @method_list.each {\|m\| yield m} end def each_attribute @attributes.each {\|a\| yield a} end def each_constant @constants.each {\|c\| yield c} end # Return the toplevel that owns us def toplevel return @toplevel if defined? @toplevel @toplevel = self @toplevel = @toplevel.parent until TopLevel === @toplevel @toplevel end # allow us to sort modules by name def <=>(other) name <=> other.name end # Look up the given symbol. If method is non-nil, then # we assume the symbol references a module that # contains that method def find_symbol(symbol, method=nil) result = nil case symbol when /^::(.)/ result = toplevel.find_symbol($1) when /::/ modules = symbol.split(/::/) unless modules.empty? module_name = modules.shift result = find_module_named(module_name) if result modules.each do \|module_name\| result = result.find_module_named(module_name) break unless result end end end else # if a method is specified, then we're definitely looking for # a module, otherwise it could be any symbol if method result = find_module_named(symbol) else result = find_local_symbol(symbol) if result.nil? if symbol =~ /^[A-Z]/ result = parent while result && result.name != symbol result = result.parent end end end end end if result && method if !result.respond_to?(:find_local_symbol) p result.name p method fail end result = result.find_local_symbol(method) end result end def find_local_symbol(symbol) res = find_method_named(symbol) \|\| find_constant_named(symbol) \|\| find_attribute_named(symbol) \|\| find_module_named(symbol) end # Handle sections def set_current_section(title, comment) @current_section = Section.new(title, comment) @sections << @current_section end private # Find a named method, or return nil def find_method_named(name) @method_list.find {\|meth\| meth.name == name} end # Find a named instance method, or return nil def find_instance_method_named(name) @method_list.find {\|meth\| meth.name == name && !meth.singleton} end # Find a named constant, or return nil def find_constant_named(name) @constants.find {\|m\| m.name == name} end # Find a named attribute, or return nil def find_attribute_named(name) @attributes.find {\|m\| m.name == name} end end # A TopLevel context is a source file class TopLevel < Context attr_accessor :file_stat attr_accessor :file_relative_name attr_accessor :file_absolute_name attr_accessor :diagram @@all_classes = {} @@all_modules = {} def TopLevel::reset @@all_classes = {} @@all_modules = {} end def initialize(file_name) super() @name = "TopLevel" @file_relative_name = file_name @file_absolute_name = file_name @file_stat = File.stat(file_name) @diagram = nil end def full_name nil end # Adding a class or module to a TopLevel is special, as we only # want one copy of a particular top-level class. For example, # if both file A and file B implement class C, we only want one # ClassModule object for C. This code arranges to share # classes and modules between files. def add_class_or_module(collection, class_type, name, superclass) cls = collection[name] if cls puts "Reusing class/module #{name}" if $DEBUG else if class_type == NormalModule all = @@all_modules else all = @@all_classes end cls = all[name] if !cls cls = class_type.new(name, superclass) all[name] = cls unless @done_documenting end puts "Adding class/module #{name} to #@name" if $DEBUG collection[name] = cls unless @done_documenting cls.parent = self end cls end def TopLevel.all_classes_and_modules @@all_classes.values + @@all_modules.values end def TopLevel.find_class_named(name) @@all_classes.each_value do \|c\| res = c.find_class_named(name) return res if res end nil end def find_local_symbol(symbol) find_class_or_module_named(symbol) \|\| super end def find_class_or_module_named(symbol) @@all_classes.each_value {\|c\| return c if c.name == symbol} @@all_modules.each_value {\|m\| return m if m.name == symbol} nil end # Find a named module def find_module_named(name) find_class_or_module_named(name) \|\| find_enclosing_module_named(name) end end # ClassModule is the base class for objects representing either a # class or a module. class ClassModule < Context attr_reader :superclass attr_accessor :diagram def initialize(name, superclass = nil) @name = name @diagram = nil @superclass = superclass @comment = "" super() end # Return the fully qualified name of this class or module def full_name if @parent && @parent.full_name @parent.full_name + "::" + @name else @name end end def http_url(prefix) path = full_name.split("::") File.join(prefix, path) + ".html" end # Return +true+ if this object represents a module def is_module? false end # to_s is simply for debugging def to_s res = self.class.name + ": " + @name res << @comment.to_s res << super res end def find_class_named(name) return self if full_name == name @classes.each_value {\|c\| return c if c.find_class_named(name) } nil end end # Anonymous classes class AnonClass < ClassModule end # Normal classes class NormalClass < ClassModule end # Singleton classes class SingleClass < ClassModule end # Module class NormalModule < ClassModule def is_module? true end end # AnyMethod is the base class for objects representing methods class AnyMethod < CodeObject attr_accessor :name attr_accessor :visibility attr_accessor :block_params attr_accessor :dont_rename_initialize attr_accessor :singleton attr_reader :aliases # list of other names for this method attr_accessor :is_alias_for # or a method we're aliasing attr_overridable :params, :param, :parameters, :parameter attr_accessor :call_seq include TokenStream def initialize(text, name) super() @text = text @name = name @token_stream = nil @visibility = :public @dont_rename_initialize = false @block_params = nil @aliases = [] @is_alias_for = nil @comment = "" @call_seq = nil end def <=>(other) @name <=> other.name end def to_s res = self.class.name + ": " + @name + " (" + @text + ")\n" res << @comment.to_s res end def param_seq p = params.gsub(/\s\#./, '') p = p.tr("\n", " ").squeeze(" ") p = "(" + p + ")" unless p[0] == ?( if (block = block_params) # If this method has explicit block parameters, remove any # explicit &block $stderr.puts p p.sub!(/,?\s&\w+/) $stderr.puts p block.gsub!(/\s\#./, '') block = block.tr("\n", " ").squeeze(" ") if block[0] == ?( block.sub!(/^\(/, '').sub!(/\)/, '') end p << " {\|#{block}\| ...}" end p end def add_alias(method) @aliases << method end end # Represent an alias, which is an old_name/ new_name pair associated # with a particular context class Alias < CodeObject attr_accessor :text, :old_name, :new_name, :comment def initialize(text, old_name, new_name, comment) super() @text = text @old_name = old_name @new_name = new_name self.comment = comment end def to_s "alias: #{self.old_name} -> #{self.new_name}\n#{self.comment}" end end # Represent a constant class Constant < CodeObject attr_accessor :name, :value def initialize(name, value, comment) super() @name = name @value = value self.comment = comment end end # Represent attributes class Attr < CodeObject attr_accessor :text, :name, :rw, :visibility def initialize(text, name, rw, comment) super() @text = text @name = name @rw = rw @visibility = :public self.comment = comment end def to_s "attr: #{self.name} #{self.rw}\n#{self.comment}" end def <=>(other) self.name <=> other.name end end # a required file class Require < CodeObject attr_accessor :name def initialize(name, comment) super() @name = name.gsub(/'\|"/, "") #' self.comment = comment end end # an included module class Include < CodeObject attr_accessor :name def initialize(name, comment) super() @name = name self.comment = comment end end end Back

Edit File : code_objects.rb | Size : 18.03 KB

# We represent the various high-level code constructs that appear
# in Ruby programs: classes, modules, methods, and so on.

require 'rdoc/tokenstream'

module RDoc

# We contain the common stuff for contexts (which are containers)
  # and other elements (methods, attributes and so on)
  #
  class CodeObject

attr_accessor :parent

# We are the model of the code, but we know that at some point
    # we will be worked on by viewers. By implementing the Viewable
    # protocol, viewers can associated themselves with these objects.

attr_accessor :viewer

# are we done documenting (ie, did we come across a :enddoc:)?

attr_accessor :done_documenting

# Which section are we in

attr_accessor :section

# do we document ourselves?

attr_reader :document_self

def document_self=(val)
      @document_self = val
      if !val
	remove_methods_etc
      end
    end

# set and cleared by :startdoc: and :enddoc:, this is used to toggle
    # the capturing of documentation
    def start_doc
      @document_self = true
      @document_children = true
    end

def stop_doc
      @document_self = false
      @document_children = false
    end

# do we document ourselves and our children

attr_reader :document_children

def document_children=(val)
      @document_children = val
      if !val
	remove_classes_and_modules
      end
    end

# Do we _force_ documentation, even is we wouldn't normally show the entity
    attr_accessor :force_documentation

# Default callbacks to nothing, but this is overridden for classes
    # and modules
    def remove_classes_and_modules
    end

def remove_methods_etc
    end

def initialize
      @document_self = true
      @document_children = true
      @force_documentation = false
      @done_documenting = false
    end

# Access the code object's comment
    attr_reader :comment

# Update the comment, but don't overwrite a real comment
    # with an empty one
    def comment=(comment)
      @comment = comment unless comment.empty?
    end

# There's a wee trick we pull. Comment blocks can have directives that
    # override the stuff we extract during the parse. So, we have a special
    # class method, attr_overridable, that lets code objects list
    # those directives. Wehn a comment is assigned, we then extract
    # out any matching directives and update our object

def CodeObject.attr_overridable(name, *aliases)
      @overridables ||= {}

attr_accessor name

aliases.unshift name
      aliases.each do |directive_name|
        @overridables[directive_name.to_s] = name
      end
    end

end

# A Context is something that can hold modules, classes, methods, 
  # attributes, aliases, requires, and includes. Classes, modules, and
  # files are all Contexts.

class Context < CodeObject
    attr_reader   :name, :method_list, :attributes, :aliases, :constants
    attr_reader   :requires, :includes, :in_files, :visibility

attr_reader   :sections

class Section
      attr_reader :title, :comment, :sequence

@@sequence = "SEC00000"

def initialize(title, comment)
        @title = title
        @@sequence.succ!
        @sequence = @@sequence.dup
        set_comment(comment)
      end

private

# Set the comment for this section from the original comment block
      # If the first line contains :section:, strip it and use the rest. Otherwise
      # remove lines up to the line containing :section:, and look for 
      # those lines again at the end and remove them. This lets us write
      #
      #   # ---------------------
      #   # :SECTION: The title
      #   # The body
      #   # ---------------------

def set_comment(comment)
        return unless comment

if comment =~ /^.*?:section:.*$/
          start = $`
          rest = $'
          if start.empty?
            @comment = rest
          else
            @comment = rest.sub(/#{start.chomp}\Z/, '')
          end
        else
          @comment = comment
        end
        @comment = nil if @comment.empty?
      end
    end

def initialize
      super()

@in_files    = []

@name    ||= "unknown"
      @comment ||= ""
      @parent  = nil
      @visibility = :public

@current_section = Section.new(nil, nil)
      @sections = [ @current_section ]

initialize_methods_etc
      initialize_classes_and_modules
    end

# map the class hash to an array externally
    def classes
      @classes.values
    end

# map the module hash to an array externally
    def modules
      @modules.values
    end

# Change the default visibility for new methods
    def ongoing_visibility=(vis)
      @visibility = vis
    end

# Given an array +methods+ of method names, set the
    # visibility of the corresponding AnyMethod object

def set_visibility_for(methods, vis, singleton=false)
      count = 0
      @method_list.each do |m|
        if methods.include?(m.name) && m.singleton == singleton
          m.visibility = vis
          count += 1
        end
      end

return if count == methods.size || singleton

# perhaps we need to look at attributes

@attributes.each do |a|
        if methods.include?(a.name)
          a.visibility = vis
          count += 1
        end
      end
    end

# Record the file that we happen to find it in
    def record_location(toplevel)
      @in_files << toplevel unless @in_files.include?(toplevel)
    end

# Return true if at least part of this thing was defined in +file+
    def defined_in?(file)
      @in_files.include?(file)
    end

def add_class(class_type, name, superclass)
      add_class_or_module(@classes, class_type, name, superclass)
    end

def add_module(class_type, name)
      add_class_or_module(@modules, class_type, name, nil)
    end

def add_method(a_method)
      puts "Adding #@visibility method #{a_method.name} to #@name" if $DEBUG
      a_method.visibility = @visibility
      add_to(@method_list, a_method)
    end

def add_attribute(an_attribute)
      add_to(@attributes, an_attribute)
    end

def add_alias(an_alias)
      meth = find_instance_method_named(an_alias.old_name)
      if meth
        new_meth = AnyMethod.new(an_alias.text, an_alias.new_name)
        new_meth.is_alias_for = meth
        new_meth.singleton    = meth.singleton
        new_meth.params       = meth.params
        new_meth.comment = "Alias for \##{meth.name}"
        meth.add_alias(new_meth)
        add_method(new_meth)
      else
        add_to(@aliases, an_alias)
      end
    end

def add_include(an_include)
      add_to(@includes, an_include)
    end

def add_constant(const)
      add_to(@constants, const)
    end

# Requires always get added to the top-level (file) context
    def add_require(a_require)
      if self.kind_of? TopLevel
        add_to(@requires, a_require)
      else
        parent.add_require(a_require)
      end
    end

def add_class_or_module(collection, class_type, name, superclass=nil)
      cls = collection[name]
      if cls
        puts "Reusing class/module #{name}" if $DEBUG
      else
        cls = class_type.new(name, superclass)
        puts "Adding class/module #{name} to #@name" if $DEBUG
#        collection[name] = cls if @document_self  && !@done_documenting
        collection[name] = cls if !@done_documenting
        cls.parent = self
        cls.section = @current_section
      end
      cls
    end

def add_to(array, thing)
      array <<  thing if @document_self  && !@done_documenting
      thing.parent = self
      thing.section = @current_section
    end

# If a class's documentation is turned off after we've started
    # collecting methods etc., we need to remove the ones
    # we have

def remove_methods_etc
      initialize_methods_etc
    end

def initialize_methods_etc
      @method_list = []
      @attributes  = []
      @aliases     = []
      @requires    = []
      @includes    = []
      @constants   = []
    end

# and remove classes and modules when we see a :nodoc: all
    def remove_classes_and_modules
      initialize_classes_and_modules
    end

def initialize_classes_and_modules
      @classes     = {}
      @modules     = {}
    end

# Find a named module
    def find_module_named(name)
      return self if self.name == name
      res = @modules[name] || @classes[name]
      return res if res
      find_enclosing_module_named(name)
    end

# find a module at a higher scope
    def find_enclosing_module_named(name)
      parent && parent.find_module_named(name)
    end

# Iterate over all the classes and modules in
    # this object

def each_classmodule
      @modules.each_value {|m| yield m}
      @classes.each_value {|c| yield c}
    end

def each_method
      @method_list.each {|m| yield m}
    end

def each_attribute 
      @attributes.each {|a| yield a}
    end

def each_constant
      @constants.each {|c| yield c}
    end

# Return the toplevel that owns us

def toplevel
      return @toplevel if defined? @toplevel
      @toplevel = self
      @toplevel = @toplevel.parent until TopLevel === @toplevel
      @toplevel
    end

# allow us to sort modules by name
    def <=>(other)
      name <=> other.name
    end

# Look up the given symbol. If method is non-nil, then
    # we assume the symbol references a module that
    # contains that method
    def find_symbol(symbol, method=nil)
      result = nil
      case symbol
      when /^::(.*)/
        result = toplevel.find_symbol($1)
      when /::/
        modules = symbol.split(/::/)
        unless modules.empty?
          module_name = modules.shift
          result = find_module_named(module_name)
          if result
            modules.each do |module_name|
              result = result.find_module_named(module_name)
              break unless result
            end
          end
        end
      else
        # if a method is specified, then we're definitely looking for
        # a module, otherwise it could be any symbol
        if method
          result = find_module_named(symbol)
        else
          result = find_local_symbol(symbol)
          if result.nil?
            if symbol =~ /^[A-Z]/
              result = parent
              while result && result.name != symbol
                result = result.parent
              end
            end
          end
        end
      end
      if result && method
        if !result.respond_to?(:find_local_symbol)
          p result.name
          p method
          fail
        end
        result = result.find_local_symbol(method)
      end
      result
    end
           
    def find_local_symbol(symbol)
      res = find_method_named(symbol) ||
            find_constant_named(symbol) ||
            find_attribute_named(symbol) ||
            find_module_named(symbol) 
    end

# Handle sections

def set_current_section(title, comment)
      @current_section = Section.new(title, comment)
      @sections << @current_section
    end

private

# Find a named method, or return nil
    def find_method_named(name)
      @method_list.find {|meth| meth.name == name}
    end

# Find a named instance method, or return nil
    def find_instance_method_named(name)
      @method_list.find {|meth| meth.name == name && !meth.singleton}
    end

# Find a named constant, or return nil
    def find_constant_named(name)
      @constants.find {|m| m.name == name}
    end

# Find a named attribute, or return nil
    def find_attribute_named(name)
      @attributes.find {|m| m.name == name}
    end
    
  end

# A TopLevel context is a source file

class TopLevel < Context
    attr_accessor :file_stat
    attr_accessor :file_relative_name
    attr_accessor :file_absolute_name
    attr_accessor :diagram
    
    @@all_classes = {}
    @@all_modules = {}

def TopLevel::reset
      @@all_classes = {}
      @@all_modules = {}
    end

def initialize(file_name)
      super()
      @name = "TopLevel"
      @file_relative_name = file_name
      @file_absolute_name = file_name
      @file_stat          = File.stat(file_name)
      @diagram            = nil
    end

def full_name
      nil
    end

# Adding a class or module to a TopLevel is special, as we only
    # want one copy of a particular top-level class. For example,
    # if both file A and file B implement class C, we only want one
    # ClassModule object for C. This code arranges to share
    # classes and modules between files.

def add_class_or_module(collection, class_type, name, superclass)
      cls = collection[name]
      if cls
        puts "Reusing class/module #{name}" if $DEBUG
      else
        if class_type == NormalModule
          all = @@all_modules
        else
          all = @@all_classes
        end
        cls = all[name]
        if !cls
          cls = class_type.new(name, superclass)
          all[name] = cls  unless @done_documenting
        end
        puts "Adding class/module #{name} to #@name" if $DEBUG
        collection[name] = cls unless @done_documenting
        cls.parent = self
      end
      cls
    end

def TopLevel.all_classes_and_modules
      @@all_classes.values + @@all_modules.values
    end

def TopLevel.find_class_named(name)
     @@all_classes.each_value do |c|
        res = c.find_class_named(name) 
        return res if res
      end
      nil
    end

def find_local_symbol(symbol)
      find_class_or_module_named(symbol) || super
    end

def find_class_or_module_named(symbol)
      @@all_classes.each_value {|c| return c if c.name == symbol}
      @@all_modules.each_value {|m| return m if m.name == symbol}
      nil
    end

# Find a named module
    def find_module_named(name)
      find_class_or_module_named(name) || find_enclosing_module_named(name)
    end

end

# ClassModule is the base class for objects representing either a
  # class or a module.

class ClassModule < Context

attr_reader   :superclass
    attr_accessor :diagram

def initialize(name, superclass = nil)
      @name       = name
      @diagram    = nil
      @superclass = superclass
      @comment    = ""
      super()
    end

# Return the fully qualified name of this class or module
    def full_name
      if @parent && @parent.full_name
        @parent.full_name + "::" + @name
      else
        @name
      end
    end

def http_url(prefix)
      path = full_name.split("::")
      File.join(prefix, *path) + ".html"
    end

# Return +true+ if this object represents a module
    def is_module?
      false
    end

# to_s is simply for debugging
    def to_s
      res = self.class.name + ": " + @name 
      res << @comment.to_s
      res << super
      res
    end

def find_class_named(name)
      return self if full_name == name
      @classes.each_value {|c| return c if c.find_class_named(name) }
      nil
    end
  end

# Anonymous classes
  class AnonClass < ClassModule
  end

# Normal classes
  class NormalClass < ClassModule
  end

# Singleton classes
  class SingleClass < ClassModule
  end

# Module
  class NormalModule < ClassModule
    def is_module?
      true
    end
  end

# AnyMethod is the base class for objects representing methods

class AnyMethod < CodeObject
    attr_accessor :name
    attr_accessor :visibility
    attr_accessor :block_params
    attr_accessor :dont_rename_initialize
    attr_accessor :singleton
    attr_reader   :aliases           # list of other names for this method
    attr_accessor :is_alias_for      # or a method we're aliasing

attr_overridable :params, :param, :parameters, :parameter

attr_accessor :call_seq

include TokenStream

def initialize(text, name)
      super()
      @text = text
      @name = name
      @token_stream  = nil
      @visibility    = :public
      @dont_rename_initialize = false
      @block_params  = nil
      @aliases       = []
      @is_alias_for  = nil
      @comment = ""
      @call_seq = nil
    end

def <=>(other)
      @name <=> other.name
    end

def to_s
      res = self.class.name + ": " + @name + " (" + @text + ")\n"
      res << @comment.to_s
      res
    end

def param_seq
      p = params.gsub(/\s*\#.*/, '')
      p = p.tr("\n", " ").squeeze(" ")
      p = "(" + p + ")" unless p[0] == ?(

if (block = block_params)
        # If this method has explicit block parameters, remove any
        # explicit &block
$stderr.puts p
        p.sub!(/,?\s*&\w+/)
$stderr.puts p

block.gsub!(/\s*\#.*/, '')
        block = block.tr("\n", " ").squeeze(" ")
        if block[0] == ?(
          block.sub!(/^$/, '').sub!(/$/, '')
        end
        p << " {|#{block}| ...}"
      end
      p
    end

def add_alias(method)
      @aliases << method
    end
  end

# Represent an alias, which is an old_name/ new_name pair associated
  # with a particular context
  class Alias < CodeObject
    attr_accessor :text, :old_name, :new_name, :comment
    
    def initialize(text, old_name, new_name, comment)
      super()
      @text = text
      @old_name = old_name
      @new_name = new_name
      self.comment = comment
    end

def to_s
      "alias: #{self.old_name} ->  #{self.new_name}\n#{self.comment}"
    end
  end

# Represent a constant
  class Constant < CodeObject
    attr_accessor :name, :value

def initialize(name, value, comment)
      super()
      @name = name
      @value = value
      self.comment = comment
    end
  end

# Represent attributes
  class Attr < CodeObject
    attr_accessor :text, :name, :rw, :visibility

def initialize(text, name, rw, comment)
      super()
      @text = text
      @name = name
      @rw = rw
      @visibility = :public
      self.comment = comment
    end

def to_s
      "attr: #{self.name} #{self.rw}\n#{self.comment}"
    end

def <=>(other)
      self.name <=> other.name
    end
  end

# a required file

class Require < CodeObject
    attr_accessor :name

def initialize(name, comment)
      super()
      @name = name.gsub(/'|"/, "") #'
      self.comment = comment
    end

end

# an included module
  class Include < CodeObject
    attr_accessor :name

def initialize(name, comment)
      super()
      @name = name
      self.comment = comment
    end

end

Back