RDoc::Context ^(Class)

# File rdoc/code_objects.rb, line 116
    def initialize
      super()

      @in_files    = []

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

      initialize_methods_etc
      initialize_classes_and_modules
    end

# File rdoc/code_objects.rb, line 317
    def <=>(other)
      name <=> other.name
    end

# File rdoc/code_objects.rb, line 197
    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

# File rdoc/code_objects.rb, line 193
    def add_attribute(an_attribute)
      add_to(@attributes, an_attribute)
    end

# File rdoc/code_objects.rb, line 179
    def add_class(class_type, name, superclass)
      add_class_or_module(@classes, class_type, name, superclass)
    end

# File rdoc/code_objects.rb, line 229
    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
        cls.parent = self
      end
      cls
    end

# File rdoc/code_objects.rb, line 216
    def add_constant(const)
      add_to(@constants, const)
    end

# File rdoc/code_objects.rb, line 212
    def add_include(an_include)
      add_to(@includes, an_include)
    end

# File rdoc/code_objects.rb, line 187
    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

# File rdoc/code_objects.rb, line 183
    def add_module(class_type, name)
      add_class_or_module(@modules, class_type, name, nil)
    end

# File rdoc/code_objects.rb, line 221
    def add_require(a_require)
      if self.kind_of? TopLevel
        add_to(@requires, a_require)
      else
        parent.add_require(a_require)
      end
    end

# File rdoc/code_objects.rb, line 242
    def add_to(array, thing)
      array <<  thing if @document_self  && !@done_documenting
      thing.parent = self
    end

# File rdoc/code_objects.rb, line 131
    def classes
      @classes.values
    end

# File rdoc/code_objects.rb, line 175
    def defined_in?(file)
      @in_files.include?(file)
    end

# File rdoc/code_objects.rb, line 299
    def each_attribute 
      @attributes.each {|a| yield a}
    end

# File rdoc/code_objects.rb, line 290
    def each_classmodule
      @modules.each_value {|m| yield m}
      @classes.each_value {|c| yield c}
    end

# File rdoc/code_objects.rb, line 303
    def each_constant
      @constants.each {|c| yield c}
    end

# File rdoc/code_objects.rb, line 295
    def each_method
      @method_list.each {|m| yield m}
    end

# File rdoc/code_objects.rb, line 283
    def find_enclosing_module_named(name)
      parent && parent.find_module_named(name)
    end

# File rdoc/code_objects.rb, line 369
    def find_local_symbol(symbol)
      res = find_method_named(symbol) ||
            find_constant_named(symbol) ||
            find_attribute_named(symbol) ||
            find_module_named(symbol) 
    end

# File rdoc/code_objects.rb, line 275
    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

# File rdoc/code_objects.rb, line 324
    def find_symbol(symbol, method=nil)
      result = nil
      case symbol
      when /^::(.*)/
        result = toplevel.find_symbol(symbol)
      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

# File rdoc/code_objects.rb, line 269
    def initialize_classes_and_modules
      @classes     = {}
      @modules     = {}
    end

# File rdoc/code_objects.rb, line 255
    def initialize_methods_etc
      @method_list = []
      @attributes  = []
      @aliases     = []
      @requires    = []
      @includes    = []
      @constants   = []
    end

# File rdoc/code_objects.rb, line 136
    def modules
      @modules.values
    end

# File rdoc/code_objects.rb, line 141
    def ongoing_visibility=(vis)
      @visibility = vis
    end

# File rdoc/code_objects.rb, line 170
    def record_location(toplevel)
      @in_files << toplevel unless @in_files.include?(toplevel)
    end

# File rdoc/code_objects.rb, line 265
    def remove_classes_and_modules
      initialize_classes_and_modules
    end

# File rdoc/code_objects.rb, line 251
    def remove_methods_etc
      initialize_methods_etc
    end

# File rdoc/code_objects.rb, line 148
    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

# File rdoc/code_objects.rb, line 309
    def toplevel
      return @toplevel if defined? @toplevel
      @toplevel = self
      @toplevel = @toplevel.parent until TopLevel === @toplevel
      @toplevel
    end