A Context is something that can hold modules, classes, methods, attributes, aliases, requires, and includes. Classes, modules, and files are all Contexts.
# 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
allow us to sort modules by name
# 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
Requires always get added to the top-level (file) context
# 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
map the class hash to an array externally
# File rdoc/code_objects.rb, line 211 def classes @classes.values end
Return true if at least part of this thing was defined in file
# 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
Iterate over all the classes and modules in this object
# 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
find a module at a higher scope
# 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
Find a named module
# 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
Look up symbol
. If method
is non-nil, then we
assume the symbol references a module that contains that method.
# 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
Yields Method and Attr entries matching the list of
names in methods
. Attributes are only returned when
singleton
is false.
# 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
map the module hash to an array externally
# File rdoc/code_objects.rb, line 218 def modules @modules.values end
Change the default visibility for new methods
# File rdoc/code_objects.rb, line 241 def ongoing_visibility=(vis) @visibility = vis end
Record the file that we happen to find it in
# File rdoc/code_objects.rb, line 281 def record_location(toplevel) @in_files << toplevel unless @in_files.include?(toplevel) end
and remove classes and modules when we see a :nodoc: all
# File rdoc/code_objects.rb, line 419 def remove_classes_and_modules initialize_classes_and_modules end
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 401 def remove_methods_etc initialize_methods_etc end
Handle sections
# File rdoc/code_objects.rb, line 539 def set_current_section(title, comment) @current_section = Section.new(title, comment) @sections << @current_section end
Given an array methods
of method names, set the visibility of
the corresponding AnyMethod object
# 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