Class: RDoc::Context

     # File 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 code_objects.rb, line 454
454:     def <=>(other)
455:       name <=> other.name
456:     end

add_alias(an_alias)

[Source]

     # File code_objects.rb, line 263
263:     def add_alias(an_alias)
264:       meth = find_instance_method_named(an_alias.old_name)
265:       if meth
266:         new_meth = AnyMethod.new(an_alias.text, an_alias.new_name)
267:         new_meth.is_alias_for = meth
268:         new_meth.singleton    = meth.singleton
269:         new_meth.params       = meth.params
270:         new_meth.comment = "Alias for \##{meth.name}"
271:         meth.add_alias(new_meth)
272:         add_method(new_meth)
273:       else
274:         add_to(@aliases, an_alias)
275:       end
276:     end

add_alias(an_alias, ignore_case=nil)

[Source]

     # File parsers/parse_f95.rb, line 557
557:     def add_alias(an_alias, ignore_case=nil)
558:       meth = find_instance_method_named(an_alias.old_name, ignore_case)
559:       if meth
560:         new_meth = AnyMethod.new(an_alias.text, an_alias.new_name)
561:         new_meth.is_alias_for = meth
562:         new_meth.singleton    = meth.singleton
563:         new_meth.params       = meth.params
564:         new_meth.comment = "Alias for \##{meth.name}"
565:         meth.add_alias(new_meth)
566:         add_method(new_meth)
567:       else
568:         add_to(@aliases, an_alias)
569:       end
570:     end

add_attribute(an_attribute)

 moved to parse_f95.rb #

!# !# def add_method(a_method) !# if !(a_method.visibility == :public) && !# !(a_method.visibility == :private) && !# !(a_method.visibility == :protected) !# a_method.visibility = @visibility !# end !# puts "Adding #{a_method.visibility} method #{a_method.name} to #@name" if $DEBUG !# add_to(@method_list, a_method) !# end !#

 moved to parse_f95.rb #

[Source]

     # File code_objects.rb, line 259
259:     def add_attribute(an_attribute)
260:       add_to(@attributes, an_attribute)
261:     end

add_class(class_type, name, superclass)

[Source]

     # File 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 code_objects.rb, line 316
316:     def add_class_or_module(collection, class_type, name, superclass=nil)
317:       cls = collection[name]
318:       if cls
319:         puts "Reusing class/module #{name}" if $DEBUG
320:       else
321:         cls = class_type.new(name, superclass)
322:         puts "Adding class/module #{name} to #@name" if $DEBUG
323: #        collection[name] = cls if @document_self  && !@done_documenting
324:         collection[name] = cls if !@done_documenting
325:         cls.parent = self
326:         cls.section = @current_section
327:       end
328:       cls
329:     end

add_constant(const)

[Source]

     # File code_objects.rb, line 303
303:     def add_constant(const)
304:       add_to(@constants, const)
305:     end

add_include(an_include)

 moved to parse_f95.rb #

!# !# def add_alias(an_alias, ignore_case=nil) !# meth = find_instance_method_named(an_alias.old_name, ignore_case) !# 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 !#

 moved to parse_f95.rb #

[Source]

     # File code_objects.rb, line 299
299:     def add_include(an_include)
300:       add_to(@includes, an_include)
301:     end

add_method(a_method)

[Source]

     # File parsers/parse_f95.rb, line 547
547:     def add_method(a_method)
548:       if !(a_method.visibility == :public)      &&
549:            !(a_method.visibility == :private)   &&
550:            !(a_method.visibility == :protected)
551:         a_method.visibility = @visibility
552:       end
553:       puts "Adding #{a_method.visibility} method #{a_method.name} to #@name" if $DEBUG
554:       add_to(@method_list, a_method)
555:     end

add_method(a_method)

[Source]

     # File 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 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 code_objects.rb, line 308
308:     def add_require(a_require)
309:       if self.kind_of? TopLevel
310:         add_to(@requires, a_require)
311:       else
312:         parent.add_require(a_require)
313:       end
314:     end

add_to(array, thing)

[Source]

     # File code_objects.rb, line 331
331:     def add_to(array, thing)
332:       array <<  thing if @document_self  && !@done_documenting
333:       thing.parent = self
334:       thing.section = @current_section
335:     end

classes()

map the class hash to an array externally

[Source]

     # File 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 code_objects.rb, line 225
225:     def defined_in?(file)
226:       @in_files.include?(file)
227:     end

each_attribute() {|a| ...}

[Source]

     # File code_objects.rb, line 426
426:     def each_attribute 
427:       @attributes.each {|a| yield a}
428:     end

each_classmodule() {|m| ...}

Iterate over all the classes and modules in this object

[Source]

     # File code_objects.rb, line 417
417:     def each_classmodule
418:       @modules.each_value {|m| yield m}
419:       @classes.each_value {|c| yield c}
420:     end

each_constant() {|c| ...}

[Source]

     # File code_objects.rb, line 430
430:     def each_constant
431:       @constants.each {|c| yield c}
432:     end

each_includes() {|i| ...}

[Source]

     # File parsers/parse_f95.rb, line 603
603:     def each_includes
604:       @includes.each {|i| yield i}
605:     end

each_method() {|m| ...}

[Source]

     # File code_objects.rb, line 422
422:     def each_method
423:       @method_list.each {|m| yield m}
424:     end

find_attribute_named(name)

Find a named attribute, or return nil

[Source]

     # File code_objects.rb, line 629
629:     def find_attribute_named(name)
630:       @attributes.find {|m| m.name == name}
631:     end

find_attribute_named(name, ignore_case=nil)

Find a named attribute, or return nil

[Source]

     # File parsers/parse_f95.rb, line 722
722:     def find_attribute_named(name, ignore_case=nil)
723:       if !ignore_case
724:         @attributes.find {|m| m.name == name}
725:       else
726:         @attributes.find {|m| m.name.upcase == name.upcase}
727:       end
728:     end

find_constant_named(name)

Find a named constant, or return nil

[Source]

     # File code_objects.rb, line 624
624:     def find_constant_named(name)
625:       @constants.find {|m| m.name == name}
626:     end

find_constant_named(name, ignore_case=nil)

Find a named constant, or return nil

[Source]

     # File parsers/parse_f95.rb, line 713
713:     def find_constant_named(name, ignore_case=nil)
714:       if !ignore_case
715:         @constants.find {|m| m.name == name}
716:       else
717:         @constants.find {|m| m.name.upcase == name.upcase}
718:       end
719:     end

find_enclosing_module_named(name)

find a module at a higher scope

[Source]

     # File code_objects.rb, line 373
373:     def find_enclosing_module_named(name)
374:       parent && parent.find_module_named(name)
375:     end

find_enclosing_module_named(name, ignore_case=nil)

find a module at a higher scope

[Source]

     # File parsers/parse_f95.rb, line 599
599:     def find_enclosing_module_named(name, ignore_case=nil)
600:       parent && parent.find_module_named(name, ignore_case)
601:     end

find_file(file, method=nil, ignore_case=nil)

Look up the given filename.

[Source]

     # File parsers/parse_f95.rb, line 608
608:     def find_file(file, method=nil, ignore_case=nil)
609:       find_file_named(file, method, ignore_case)
610:     end

find_instance_method_named(name)

Find a named instance method, or return nil

[Source]

     # File code_objects.rb, line 619
619:     def find_instance_method_named(name)
620:       @method_list.find {|meth| meth.name == name && !meth.singleton}
621:     end

find_instance_method_named(name, ignore_case=nil)

Find a named instance method, or return nil

[Source]

     # File parsers/parse_f95.rb, line 702
702:     def find_instance_method_named(name, ignore_case=nil)
703:       if !ignore_case
704:         @method_list.find {|meth| meth.name == name && !meth.singleton}
705:       else
706:         @method_list.find {|meth| 
707:           meth.name.upcase == name.upcase && !meth.singleton
708:         } 
709:       end
710:     end

find_local_symbol(symbol)

[Source]

     # File code_objects.rb, line 506
506:     def find_local_symbol(symbol)
507:       res = find_method_named(symbol) ||
508:             find_constant_named(symbol) ||
509:             find_attribute_named(symbol) ||
510:             find_module_named(symbol) 
511:     end

find_local_symbol(symbol, ignore_case=nil)

[Source]

     # File parsers/parse_f95.rb, line 661
661:     def find_local_symbol(symbol, ignore_case=nil)
662:       res = find_method_named(symbol, ignore_case) ||
663:             find_constant_named(symbol, ignore_case) ||
664:             find_attribute_named(symbol, ignore_case) ||
665:             find_module_named(symbol, ignore_case) 
666:     end

find_method_named(name)

Find a named method, or return nil

[Source]

     # File code_objects.rb, line 614
614:     def find_method_named(name)
615:       @method_list.find {|meth| meth.name == name}
616:     end

find_method_named(name, ignore_case=nil)

Find a named method, or return nil

[Source]

     # File parsers/parse_f95.rb, line 693
693:     def find_method_named(name, ignore_case=nil)
694:       if !ignore_case
695:         @method_list.find {|meth| meth.name == name}
696:       else
697:         @method_list.find {|meth| meth.name.upcase == name.upcase}
698:       end
699:     end

find_module_named(name)

Find a named module

[Source]

     # File code_objects.rb, line 365
365:     def find_module_named(name)
366:       return self if self.name == name
367:       res = @modules[name] || @classes[name]
368:       return res if res
369:       find_enclosing_module_named(name)
370:     end

find_module_named(name, ignore_case=nil)

Find a named module

[Source]

     # File parsers/parse_f95.rb, line 573
573:     def find_module_named(name, ignore_case=nil)
574:       res = nil
575:       if !ignore_case
576:         return self if self.name == name
577:       else
578:         return self if self.name.upcase == name.upcase
579:       end
580:       if !ignore_case
581:         res = @modules[name] || @classes[name]
582:       else
583:         @modules.each{ |n, v|
584:           if n.upcase == name.upcase
585:             res = v ; break
586:           end
587:         }
588:         @classes.each{ |n, v|
589:           if n.upcase == name.upcase
590:             res = v ; break
591:           end
592:         } if !res
593:       end
594:       return res if res
595:       find_enclosing_module_named(name, ignore_case)
596:     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 code_objects.rb, line 461
461:     def find_symbol(symbol, method=nil)
462:       result = nil
463:       case symbol
464:       when /^::(.*)/
465:         result = toplevel.find_symbol($1)
466:       when /::/
467:         modules = symbol.split(/::/)
468:         unless modules.empty?
469:           module_name = modules.shift
470:           result = find_module_named(module_name)
471:           if result
472:             modules.each do |module_name|
473:               result = result.find_module_named(module_name)
474:               break unless result
475:             end
476:           end
477:         end
478:       else
479:         # if a method is specified, then we're definitely looking for
480:         # a module, otherwise it could be any symbol
481:         if method
482:           result = find_module_named(symbol)
483:         else
484:           result = find_local_symbol(symbol)
485:           if result.nil?
486:             if symbol =~ /^[A-Z]/
487:               result = parent
488:               while result && result.name != symbol
489:                 result = result.parent
490:               end
491:             end
492:           end
493:         end
494:       end
495:       if result && method
496:         if !result.respond_to?(:find_local_symbol)
497:           p result.name
498:           p method
499:           fail
500:         end
501:         result = result.find_local_symbol(method)
502:       end
503:       result
504:     end

find_symbol(symbol, method=nil, ignore_case=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 parsers/parse_f95.rb, line 615
615:     def find_symbol(symbol, method=nil, ignore_case=nil)
616:       result = nil
617:       case symbol
618:       when /^::(.*)/
619:         result = toplevel.find_symbol($1, nil, ignore_case)
620:       when /::/
621:         modules = symbol.split(/::/)
622:         unless modules.empty?
623:           module_name = modules.shift
624:           result = find_module_named(module_name, ignore_case)
625:           if result
626:             modules.each do |module_name|
627:               result = result.find_module_named(module_name, ignore_case)
628:               break unless result
629:             end
630:           end
631:         end
632:       else
633:         # if a method is specified, then we're definitely looking for
634:         # a module, otherwise it could be any symbol
635:         if method
636:           result = find_module_named(symbol, ignore_case)
637:         else
638:           result = find_local_symbol(symbol, ignore_case)
639:           if result.nil?
640:             if symbol =~ /^[A-Z]/ ||
641:                        symbol =~ /^[A-Za-z]/ && ignore_case
642:               result = parent
643:               while result && result.name != symbol
644:                 result = result.parent
645:               end
646:             end
647:           end
648:         end
649:       end
650:       if result && method
651:         if !result.respond_to?(:find_local_symbol)
652:           p result.name
653:           p method
654:           fail
655:         end
656:         result = result.find_local_symbol(method, ignore_case)
657:       end
658:       result
659:     end

include_includes?(name, ignore_case=nil)

[Source]

     # File parsers/parse_f95.rb, line 682
682:     def include_includes?(name, ignore_case=nil)
683:       self.includes.each{|i|
684:         if i.name == name ||
685:             i.name.upcase == name.upcase && ignore_case
686:           return true
687:         end
688:       }
689:       return false
690:     end

include_requires?(name, ignore_case=nil)

[Source]

     # File parsers/parse_f95.rb, line 668
668:     def include_requires?(name, ignore_case=nil)
669:       if self.kind_of? TopLevel
670:         self.requires.each{|r|
671:           if r.name == name ||
672:               r.name.upcase == name.upcase && ignore_case
673:             return true
674:           end
675:         }
676:         return false
677:       else
678:         parent.include_requires?(name)
679:       end
680:     end

initialize_classes_and_modules()

[Source]

     # File code_objects.rb, line 359
359:     def initialize_classes_and_modules
360:       @classes     = {}
361:       @modules     = {}
362:     end

initialize_methods_etc()

[Source]

     # File code_objects.rb, line 345
345:     def initialize_methods_etc
346:       @method_list = []
347:       @attributes  = []
348:       @aliases     = []
349:       @requires    = []
350:       @includes    = []
351:       @constants   = []
352:     end

modules()

map the module hash to an array externally

[Source]

     # File 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 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 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 code_objects.rb, line 355
355:     def remove_classes_and_modules
356:       initialize_classes_and_modules
357:     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 code_objects.rb, line 341
341:     def remove_methods_etc
342:       initialize_methods_etc
343:     end

set_current_section(title, comment)

Handle sections

[Source]

     # File code_objects.rb, line 606
606:     def set_current_section(title, comment)
607:       @current_section = Section.new(title, comment)
608:       @sections << @current_section
609:     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 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 code_objects.rb, line 446
446:     def toplevel
447:       return @toplevel if defined? @toplevel
448:       @toplevel = self
449:       @toplevel = @toplevel.parent until TopLevel === @toplevel
450:       @toplevel
451:     end

Methods

Classes and Modules

Attributes

Public Class methods

Public Instance methods