Current File : //proc/thread-self/root/opt/alt/ruby18/lib64/ruby/1.8/rdoc/code_objects.rb
# 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
Mini Shell