RDoc::Context

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

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

 
               # File rdoc/code_objects.rb, line 344
def add_alias(an_alias)
  meth = find_instance_method_named(an_alias.old_name)

  if meth then
    add_alias_impl(an_alias, meth)
  else
    add_to(@aliases, an_alias)
    unmatched_alias_list = @unmatched_alias_lists[an_alias.old_name] ||= []
    unmatched_alias_list.push(an_alias)
  end

  an_alias
end
            

 
               # File rdoc/code_objects.rb, line 334
def add_alias_impl(an_alias, 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)
end
            

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

 
               # File rdoc/code_objects.rb, line 290
def add_class(class_type, name, superclass)
  klass = add_class_or_module @classes, class_type, name, superclass

  #
  # If the parser encounters Container::Item before encountering
  # Container, then it assumes that Container is a module.  This
  # may not be the case, so remove Container from the module list
  # if present and transfer any contained classes and modules to
  # the new class.
  #
  mod = @modules.delete(name)

  if mod then
    klass.classes_hash.update(mod.classes_hash)
    klass.modules_hash.update(mod.modules_hash)
    klass.method_list.concat(mod.method_list)
  end

  return klass
end
            

 
               # File rdoc/code_objects.rb, line 375
    def add_class_or_module(collection, class_type, name, superclass=nil)
      cls = collection[name]

      if cls then
        cls.superclass = superclass unless cls.module?
        puts "Reusing class/module #{name}" if $DEBUG_RDOC
      else
        cls = class_type.new(name, superclass)
#        collection[name] = cls if @document_self  && !@done_documenting
        collection[name] = cls if !@done_documenting
        cls.parent = self
        cls.section = @current_section
      end
      cls
    end
            

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

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

 
               # File rdoc/code_objects.rb, line 315
def add_method(a_method)
  a_method.visibility = @visibility
  add_to(@method_list, a_method)

  unmatched_alias_list = @unmatched_alias_lists[a_method.name]
  if unmatched_alias_list then
    unmatched_alias_list.each do |unmatched_alias|
      add_alias_impl unmatched_alias, a_method
      @aliases.delete unmatched_alias
    end

    @unmatched_alias_lists.delete a_method.name
  end
end
            

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

 
               # File rdoc/code_objects.rb, line 367
def add_require(a_require)
  if TopLevel === self then
    add_to @requires, a_require
  else
    parent.add_require a_require
  end
end
            

 
               # File rdoc/code_objects.rb, line 391
def add_to(array, thing)
  array << thing if @document_self and not @done_documenting
  thing.parent = self
  thing.section = @current_section
end
            

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

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

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

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

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

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

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

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

 
               # File rdoc/code_objects.rb, line 429
def find_module_named(name)
  # First check the enclosed modules, then check the module itself,
  # then check the enclosing modules (this mirrors the check done by
  # the Ruby parser)
  res = @modules[name] || @classes[name]
  return res if res
  return self if self.name == name
  find_enclosing_module_named(name)
end
            

 
               # File rdoc/code_objects.rb, line 482
def find_symbol(symbol, method = nil)
  result = nil

  case symbol
  when /^::(.*)/ then
    result = toplevel.find_symbol($1)
  when /::/ then
    modules = symbol.split(/::/)

    unless modules.empty? then
      module_name = modules.shift
      result = find_module_named(module_name)

      if result then
        modules.each do |name|
          result = result.find_module_named(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 and method then
    fail unless result.respond_to? :find_local_symbol
    result = result.find_local_symbol(method)
  end

  result
end
            

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

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

  # This Hash maps a method name to a list of unmatched
  # aliases (aliases of a method not yet encountered).
  @unmatched_alias_lists = {}
end
            

 
               # File rdoc/code_objects.rb, line 249
def methods_matching(methods, singleton = false)
  count = 0

  @method_list.each do |m|
    if methods.include? m.name and m.singleton == singleton then
      yield m
      count += 1
    end
  end

  return if count == methods.size || singleton

  # perhaps we need to look at attributes

  @attributes.each do |a|
    yield a if methods.include? a.name
  end
end
            

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

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

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

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

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

 
               # File rdoc/code_objects.rb, line 539
def set_current_section(title, comment)
  @current_section = Section.new(title, comment)
  @sections << @current_section
end
            

 
               # File rdoc/code_objects.rb, line 272
def set_visibility_for(methods, vis, singleton = false)
  methods_matching methods, singleton do |m|
    m.visibility = vis
  end
end
            

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

 
               # File rdoc/code_objects.rb, line 225
def classes_hash
  @classes
end
            

 
               # File rdoc/code_objects.rb, line 233
def modules_hash
  @modules
end