In Files

  • rdoc/code_objects.rb

Files

Class/Module Index [+]

Quicksearch

RDoc::Context

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

Attributes

aliases[R]
attributes[R]
constants[R]
in_files[R]
includes[R]
method_list[R]
name[R]
requires[R]
sections[R]
visibility[R]

Public Class Methods

new() click to toggle source
 
               # File rdoc/code_objects.rb, line 163
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
            

Public Instance Methods

<=>(other) click to toggle source

allow us to sort modules by name

 
               # File rdoc/code_objects.rb, line 370
def <=>(other)
  name <=> other.name
end
            
add_alias(an_alias) click to toggle source
 
               # File rdoc/code_objects.rb, line 247
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
            
add_attribute(an_attribute) click to toggle source
 
               # File rdoc/code_objects.rb, line 243
def add_attribute(an_attribute)
  add_to(@attributes, an_attribute)
end
            
add_class(class_type, name, superclass) click to toggle source
 
               # File rdoc/code_objects.rb, line 229
def add_class(class_type, name, superclass)
  add_class_or_module(@classes, class_type, name, superclass)
end
            
add_class_or_module(collection, class_type, name, superclass=nil) click to toggle source
 
               # File rdoc/code_objects.rb, line 279
    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
            
add_constant(const) click to toggle source
 
               # File rdoc/code_objects.rb, line 266
def add_constant(const)
  add_to(@constants, const)
end
            
add_include(an_include) click to toggle source
 
               # File rdoc/code_objects.rb, line 262
def add_include(an_include)
  add_to(@includes, an_include)
end
            
add_method(a_method) click to toggle source
 
               # File rdoc/code_objects.rb, line 237
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
            
add_module(class_type, name) click to toggle source
 
               # File rdoc/code_objects.rb, line 233
def add_module(class_type, name)
  add_class_or_module(@modules, class_type, name, nil)
end
            
add_require(a_require) click to toggle source

Requires always get added to the top-level (file) context

 
               # File rdoc/code_objects.rb, line 271
def add_require(a_require)
  if self.kind_of? TopLevel
    add_to(@requires, a_require)
  else
    parent.add_require(a_require)
  end
end
            
add_to(array, thing) click to toggle source
 
               # File rdoc/code_objects.rb, line 294
def add_to(array, thing)
  array <<  thing if @document_self  && !@done_documenting
  thing.parent = self
  thing.section = @current_section
end
            
classes() click to toggle source

map the class hash to an array externally

 
               # File rdoc/code_objects.rb, line 181
def classes
  @classes.values
end
            
defined_in?(file) click to toggle source

Return true if at least part of this thing was defined in file

 
               # File rdoc/code_objects.rb, line 225
def defined_in?(file)
  @in_files.include?(file)
end
            
each_attribute() click to toggle source
 
               # File rdoc/code_objects.rb, line 352
def each_attribute 
  @attributes.each {|a| yield a}
end
            
each_classmodule() click to toggle source

Iterate over all the classes and modules in this object

 
               # File rdoc/code_objects.rb, line 343
def each_classmodule
  @modules.each_value {|m| yield m}
  @classes.each_value {|c| yield c}
end
            
each_constant() click to toggle source
 
               # File rdoc/code_objects.rb, line 356
def each_constant
  @constants.each {|c| yield c}
end
            
each_method() click to toggle source
 
               # File rdoc/code_objects.rb, line 348
def each_method
  @method_list.each {|m| yield m}
end
            
find_enclosing_module_named(name) click to toggle source

find a module at a higher scope

 
               # File rdoc/code_objects.rb, line 336
def find_enclosing_module_named(name)
  parent && parent.find_module_named(name)
end
            
find_local_symbol(symbol) click to toggle source
 
               # File rdoc/code_objects.rb, line 422
def find_local_symbol(symbol)
  res = find_method_named(symbol) ||
        find_constant_named(symbol) ||
        find_attribute_named(symbol) ||
        find_module_named(symbol) 
end
            
find_module_named(name) click to toggle source

Find a named module

 
               # File rdoc/code_objects.rb, line 328
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_symbol(symbol, method=nil) click to toggle source

Look up the given symbol. If method is non-nil, then we assume the symbol references a module that contains that method

 
               # File rdoc/code_objects.rb, line 377
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
            
initialize_classes_and_modules() click to toggle source
 
               # File rdoc/code_objects.rb, line 322
def initialize_classes_and_modules
  @classes     = {}
  @modules     = {}
end
            
initialize_methods_etc() click to toggle source
 
               # File rdoc/code_objects.rb, line 308
def initialize_methods_etc
  @method_list = []
  @attributes  = []
  @aliases     = []
  @requires    = []
  @includes    = []
  @constants   = []
end
            
modules() click to toggle source

map the module hash to an array externally

 
               # File rdoc/code_objects.rb, line 186
def modules
  @modules.values
end
            
ongoing_visibility=(vis) click to toggle source

Change the default visibility for new methods

 
               # File rdoc/code_objects.rb, line 191
def ongoing_visibility=(vis)
  @visibility = vis
end
            
record_location(toplevel) click to toggle source

Record the file that we happen to find it in

 
               # File rdoc/code_objects.rb, line 220
def record_location(toplevel)
  @in_files << toplevel unless @in_files.include?(toplevel)
end
            
remove_classes_and_modules() click to toggle source

and remove classes and modules when we see a :nodoc: all

 
               # File rdoc/code_objects.rb, line 318
def remove_classes_and_modules
  initialize_classes_and_modules
end
            
remove_methods_etc() click to toggle source

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

 
               # File rdoc/code_objects.rb, line 304
def remove_methods_etc
  initialize_methods_etc
end
            
set_current_section(title, comment) click to toggle source

Handle sections

 
               # File rdoc/code_objects.rb, line 431
def set_current_section(title, comment)
  @current_section = Section.new(title, comment)
  @sections << @current_section
end
            
set_visibility_for(methods, vis, singleton=false) click to toggle source

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

 
               # File rdoc/code_objects.rb, line 198
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
            
toplevel() click to toggle source

Return the toplevel that owns us

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

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus