Class: RDoc::Context

     # File lib/rdoc/code_objects.rb, line 163
163:     def initialize
164:       super()
165: 
166:       @in_files    = []
167: 
168:       @name    ||= "unknown"
169:       @comment ||= ""
170:       @parent  = nil
171:       @visibility = :public
172: 
173:       @current_section = Section.new(nil, nil)
174:       @sections = [ @current_section ]
175: 
176:       initialize_methods_etc
177:       initialize_classes_and_modules
178:     end

<=>(other)

allow us to sort modules by name

[Source]

     # File lib/rdoc/code_objects.rb, line 370
370:     def <=>(other)
371:       name <=> other.name
372:     end

add_alias(an_alias)

[Source]

     # File lib/rdoc/code_objects.rb, line 247
247:     def add_alias(an_alias)
248:       meth = find_instance_method_named(an_alias.old_name)
249:       if meth
250:         new_meth = AnyMethod.new(an_alias.text, an_alias.new_name)
251:         new_meth.is_alias_for = meth
252:         new_meth.singleton    = meth.singleton
253:         new_meth.params       = meth.params
254:         new_meth.comment = "Alias for \##{meth.name}"
255:         meth.add_alias(new_meth)
256:         add_method(new_meth)
257:       else
258:         add_to(@aliases, an_alias)
259:       end
260:     end

add_attribute(an_attribute)

[Source]

     # File lib/rdoc/code_objects.rb, line 243
243:     def add_attribute(an_attribute)
244:       add_to(@attributes, an_attribute)
245:     end

add_class(class_type, name, superclass)

[Source]

     # File lib/rdoc/code_objects.rb, line 229
229:     def add_class(class_type, name, superclass)
230:       add_class_or_module(@classes, class_type, name, superclass)
231:     end

add_class_or_module(collection, class_type, name, superclass=nil)

[Source]

     # File lib/rdoc/code_objects.rb, line 279
279:     def add_class_or_module(collection, class_type, name, superclass=nil)
280:       cls = collection[name]
281:       if cls
282:         puts "Reusing class/module #{name}" if $DEBUG
283:       else
284:         cls = class_type.new(name, superclass)
285:         puts "Adding class/module #{name} to #@name" if $DEBUG
286: #        collection[name] = cls if @document_self  && !@done_documenting
287:         collection[name] = cls if !@done_documenting
288:         cls.parent = self
289:         cls.section = @current_section
290:       end
291:       cls
292:     end

add_constant(const)

[Source]

     # File lib/rdoc/code_objects.rb, line 266
266:     def add_constant(const)
267:       add_to(@constants, const)
268:     end

add_include(an_include)

[Source]

     # File lib/rdoc/code_objects.rb, line 262
262:     def add_include(an_include)
263:       add_to(@includes, an_include)
264:     end

add_method(a_method)

[Source]

     # File lib/rdoc/code_objects.rb, line 237
237:     def add_method(a_method)
238:       puts "Adding #@visibility method #{a_method.name} to #@name" if $DEBUG
239:       a_method.visibility = @visibility
240:       add_to(@method_list, a_method)
241:     end

add_module(class_type, name)

[Source]

     # File lib/rdoc/code_objects.rb, line 233
233:     def add_module(class_type, name)
234:       add_class_or_module(@modules, class_type, name, nil)
235:     end

add_require(a_require)

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

[Source]

     # File lib/rdoc/code_objects.rb, line 271
271:     def add_require(a_require)
272:       if self.kind_of? TopLevel
273:         add_to(@requires, a_require)
274:       else
275:         parent.add_require(a_require)
276:       end
277:     end

add_to(array, thing)

[Source]

     # File lib/rdoc/code_objects.rb, line 294
294:     def add_to(array, thing)
295:       array <<  thing if @document_self  && !@done_documenting
296:       thing.parent = self
297:       thing.section = @current_section
298:     end

classes()

map the class hash to an array externally

[Source]

     # File lib/rdoc/code_objects.rb, line 181
181:     def classes
182:       @classes.values
183:     end

defined_in?(file)

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

[Source]

     # File lib/rdoc/code_objects.rb, line 225
225:     def defined_in?(file)
226:       @in_files.include?(file)
227:     end

each_attribute() {|a| ...}

[Source]

     # File lib/rdoc/code_objects.rb, line 352
352:     def each_attribute 
353:       @attributes.each {|a| yield a}
354:     end

each_classmodule() {|m| ...}

Iterate over all the classes and modules in this object

[Source]

     # File lib/rdoc/code_objects.rb, line 343
343:     def each_classmodule
344:       @modules.each_value {|m| yield m}
345:       @classes.each_value {|c| yield c}
346:     end

each_constant() {|c| ...}

[Source]

     # File lib/rdoc/code_objects.rb, line 356
356:     def each_constant
357:       @constants.each {|c| yield c}
358:     end

each_method() {|m| ...}

[Source]

     # File lib/rdoc/code_objects.rb, line 348
348:     def each_method
349:       @method_list.each {|m| yield m}
350:     end

find_enclosing_module_named(name)

find a module at a higher scope

[Source]

     # File lib/rdoc/code_objects.rb, line 336
336:     def find_enclosing_module_named(name)
337:       parent && parent.find_module_named(name)
338:     end

find_local_symbol(symbol)

[Source]

     # File lib/rdoc/code_objects.rb, line 422
422:     def find_local_symbol(symbol)
423:       res = find_method_named(symbol) ||
424:             find_constant_named(symbol) ||
425:             find_attribute_named(symbol) ||
426:             find_module_named(symbol) 
427:     end

find_module_named(name)

Find a named module

[Source]

     # File lib/rdoc/code_objects.rb, line 328
328:     def find_module_named(name)
329:       return self if self.name == name
330:       res = @modules[name] || @classes[name]
331:       return res if res
332:       find_enclosing_module_named(name)
333:     end

find_symbol(symbol, method=nil)

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

[Source]

     # File lib/rdoc/code_objects.rb, line 377
377:     def find_symbol(symbol, method=nil)
378:       result = nil
379:       case symbol
380:       when /^::(.*)/
381:         result = toplevel.find_symbol($1)
382:       when /::/
383:         modules = symbol.split(/::/)
384:         unless modules.empty?
385:           module_name = modules.shift
386:           result = find_module_named(module_name)
387:           if result
388:             modules.each do |module_name|
389:               result = result.find_module_named(module_name)
390:               break unless result
391:             end
392:           end
393:         end
394:       else
395:         # if a method is specified, then we're definitely looking for
396:         # a module, otherwise it could be any symbol
397:         if method
398:           result = find_module_named(symbol)
399:         else
400:           result = find_local_symbol(symbol)
401:           if result.nil?
402:             if symbol =~ /^[A-Z]/
403:               result = parent
404:               while result && result.name != symbol
405:                 result = result.parent
406:               end
407:             end
408:           end
409:         end
410:       end
411:       if result && method
412:         if !result.respond_to?(:find_local_symbol)
413:           p result.name
414:           p method
415:           fail
416:         end
417:         result = result.find_local_symbol(method)
418:       end
419:       result
420:     end

initialize_classes_and_modules()

[Source]

     # File lib/rdoc/code_objects.rb, line 322
322:     def initialize_classes_and_modules
323:       @classes     = {}
324:       @modules     = {}
325:     end

initialize_methods_etc()

[Source]

     # File lib/rdoc/code_objects.rb, line 308
308:     def initialize_methods_etc
309:       @method_list = []
310:       @attributes  = []
311:       @aliases     = []
312:       @requires    = []
313:       @includes    = []
314:       @constants   = []
315:     end

modules()

map the module hash to an array externally

[Source]

     # File lib/rdoc/code_objects.rb, line 186
186:     def modules
187:       @modules.values
188:     end

ongoing_visibility=(vis)

Change the default visibility for new methods

[Source]

     # File lib/rdoc/code_objects.rb, line 191
191:     def ongoing_visibility=(vis)
192:       @visibility = vis
193:     end

record_location(toplevel)

Record the file that we happen to find it in

[Source]

     # File lib/rdoc/code_objects.rb, line 220
220:     def record_location(toplevel)
221:       @in_files << toplevel unless @in_files.include?(toplevel)
222:     end

remove_classes_and_modules()

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

[Source]

     # File lib/rdoc/code_objects.rb, line 318
318:     def remove_classes_and_modules
319:       initialize_classes_and_modules
320:     end

remove_methods_etc()

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

[Source]

     # File lib/rdoc/code_objects.rb, line 304
304:     def remove_methods_etc
305:       initialize_methods_etc
306:     end

set_current_section(title, comment)

Handle sections

[Source]

     # File lib/rdoc/code_objects.rb, line 431
431:     def set_current_section(title, comment)
432:       @current_section = Section.new(title, comment)
433:       @sections << @current_section
434:     end

set_visibility_for(methods, vis, singleton=false)

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

[Source]

     # File lib/rdoc/code_objects.rb, line 198
198:     def set_visibility_for(methods, vis, singleton=false)
199:       count = 0
200:       @method_list.each do |m|
201:         if methods.include?(m.name) && m.singleton == singleton
202:           m.visibility = vis
203:           count += 1
204:         end
205:       end
206: 
207:       return if count == methods.size || singleton
208: 
209:       # perhaps we need to look at attributes
210: 
211:       @attributes.each do |a|
212:         if methods.include?(a.name)
213:           a.visibility = vis
214:           count += 1
215:         end
216:       end
217:     end

toplevel()

Return the toplevel that owns us

[Source]

     # File lib/rdoc/code_objects.rb, line 362
362:     def toplevel
363:       return @toplevel if defined? @toplevel
364:       @toplevel = self
365:       @toplevel = @toplevel.parent until TopLevel === @toplevel
366:       @toplevel
367:     end

find_attribute_named(name)

Find a named attribute, or return nil

[Source]

     # File lib/rdoc/code_objects.rb, line 454
454:     def find_attribute_named(name)
455:       @attributes.find {|m| m.name == name}
456:     end

find_constant_named(name)

Find a named constant, or return nil

[Source]

     # File lib/rdoc/code_objects.rb, line 449
449:     def find_constant_named(name)
450:       @constants.find {|m| m.name == name}
451:     end

find_instance_method_named(name)

Find a named instance method, or return nil

[Source]

     # File lib/rdoc/code_objects.rb, line 444
444:     def find_instance_method_named(name)
445:       @method_list.find {|meth| meth.name == name && !meth.singleton}
446:     end

find_method_named(name)

Find a named method, or return nil

[Source]

     # File lib/rdoc/code_objects.rb, line 439
439:     def find_method_named(name)
440:       @method_list.find {|meth| meth.name == name}
441:     end

Methods

Classes and Modules

Attributes

Public Class methods

Public Instance methods

Private Instance methods