Class RDoc::Context
In: code_objects.rb
parsers/parse_f95.rb
Parent: CodeObject

Extend Context class for parse_f95.rb Original class is defined in code_objects.rb.

Methods

Classes and Modules

Class RDoc::Context::Section

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

[Source]

     # 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

Public Instance methods

allow us to sort modules by name

[Source]

     # File code_objects.rb, line 454
454:     def <=>(other)
455:       name <=> other.name
456:     end

[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

[Source]

     # File parsers/parse_f95.rb, line 464
464:     def add_alias(an_alias, ignore_case=nil)
465:       meth = find_instance_method_named(an_alias.old_name, ignore_case)
466:       if meth
467:         new_meth = AnyMethod.new(an_alias.text, an_alias.new_name)
468:         new_meth.is_alias_for = meth
469:         new_meth.singleton    = meth.singleton
470:         new_meth.params       = meth.params
471:         new_meth.comment = "Alias for \##{meth.name}"
472:         meth.add_alias(new_meth)
473:         add_method(new_meth)
474:       else
475:         add_to(@aliases, an_alias)
476:       end
477:     end
 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

[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

[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

[Source]

     # File code_objects.rb, line 303
303:     def add_constant(const)
304:       add_to(@constants, const)
305:     end
 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

[Source]

     # File parsers/parse_f95.rb, line 454
454:     def add_method(a_method)
455:       if !(a_method.visibility == :public)      &&
456:            !(a_method.visibility == :private)   &&
457:            !(a_method.visibility == :protected)
458:         a_method.visibility = @visibility
459:       end
460:       puts "Adding #{a_method.visibility} method #{a_method.name} to #@name" if $DEBUG
461:       add_to(@method_list, a_method)
462:     end

[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

[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

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

[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

map the class hash to an array externally

[Source]

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

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

[Source]

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

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

[Source]

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

[Source]

     # File parsers/parse_f95.rb, line 510
510:     def each_includes
511:       @includes.each {|i| yield i}
512:     end

[Source]

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

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 a named attribute, or return nil

[Source]

     # File parsers/parse_f95.rb, line 629
629:     def find_attribute_named(name, ignore_case=nil)
630:       if !ignore_case
631:         @attributes.find {|m| m.name == name}
632:       else
633:         @attributes.find {|m| m.name.upcase == name.upcase}
634:       end
635:     end

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 a named constant, or return nil

[Source]

     # File parsers/parse_f95.rb, line 620
620:     def find_constant_named(name, ignore_case=nil)
621:       if !ignore_case
622:         @constants.find {|m| m.name == name}
623:       else
624:         @constants.find {|m| m.name.upcase == name.upcase}
625:       end
626:     end

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 a module at a higher scope

[Source]

     # File parsers/parse_f95.rb, line 506
506:     def find_enclosing_module_named(name, ignore_case=nil)
507:       parent && parent.find_module_named(name, ignore_case)
508:     end

Look up the given filename.

[Source]

     # File parsers/parse_f95.rb, line 515
515:     def find_file(file, method=nil, ignore_case=nil)
516:       find_file_named(file, method, ignore_case)
517:     end

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 a named instance method, or return nil

[Source]

     # File parsers/parse_f95.rb, line 609
609:     def find_instance_method_named(name, ignore_case=nil)
610:       if !ignore_case
611:         @method_list.find {|meth| meth.name == name && !meth.singleton}
612:       else
613:         @method_list.find {|meth| 
614:           meth.name.upcase == name.upcase && !meth.singleton
615:         } 
616:       end
617:     end

[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

[Source]

     # File parsers/parse_f95.rb, line 568
568:     def find_local_symbol(symbol, ignore_case=nil)
569:       res = find_method_named(symbol, ignore_case) ||
570:             find_constant_named(symbol, ignore_case) ||
571:             find_attribute_named(symbol, ignore_case) ||
572:             find_module_named(symbol, ignore_case) 
573:     end

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 a named method, or return nil

[Source]

     # File parsers/parse_f95.rb, line 600
600:     def find_method_named(name, ignore_case=nil)
601:       if !ignore_case
602:         @method_list.find {|meth| meth.name == name}
603:       else
604:         @method_list.find {|meth| meth.name.upcase == name.upcase}
605:       end
606:     end

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 a named module

[Source]

     # File parsers/parse_f95.rb, line 480
480:     def find_module_named(name, ignore_case=nil)
481:       res = nil
482:       if !ignore_case
483:         return self if self.name == name
484:       else
485:         return self if self.name.upcase == name.upcase
486:       end
487:       if !ignore_case
488:         res = @modules[name] || @classes[name]
489:       else
490:         @modules.each{ |n, v|
491:           if n.upcase == name.upcase
492:             res = v ; break
493:           end
494:         }
495:         @classes.each{ |n, v|
496:           if n.upcase == name.upcase
497:             res = v ; break
498:           end
499:         } if !res
500:       end
501:       return res if res
502:       find_enclosing_module_named(name, ignore_case)
503:     end

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

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 522
522:     def find_symbol(symbol, method=nil, ignore_case=nil)
523:       result = nil
524:       case symbol
525:       when /^::(.*)/
526:         result = toplevel.find_symbol($1, nil, ignore_case)
527:       when /::/
528:         modules = symbol.split(/::/)
529:         unless modules.empty?
530:           module_name = modules.shift
531:           result = find_module_named(module_name, ignore_case)
532:           if result
533:             modules.each do |module_name|
534:               result = result.find_module_named(module_name, ignore_case)
535:               break unless result
536:             end
537:           end
538:         end
539:       else
540:         # if a method is specified, then we're definitely looking for
541:         # a module, otherwise it could be any symbol
542:         if method
543:           result = find_module_named(symbol, ignore_case)
544:         else
545:           result = find_local_symbol(symbol, ignore_case)
546:           if result.nil?
547:             if symbol =~ /^[A-Z]/ ||
548:                        symbol =~ /^[A-Za-z]/ && ignore_case
549:               result = parent
550:               while result && result.name != symbol
551:                 result = result.parent
552:               end
553:             end
554:           end
555:         end
556:       end
557:       if result && method
558:         if !result.respond_to?(:find_local_symbol)
559:           p result.name
560:           p method
561:           fail
562:         end
563:         result = result.find_local_symbol(method, ignore_case)
564:       end
565:       result
566:     end

[Source]

     # File parsers/parse_f95.rb, line 589
589:     def include_includes?(name, ignore_case=nil)
590:       self.includes.each{|i|
591:         if i.name == name ||
592:             i.name.upcase == name.upcase && ignore_case
593:           return true
594:         end
595:       }
596:       return false
597:     end

[Source]

     # File parsers/parse_f95.rb, line 575
575:     def include_requires?(name, ignore_case=nil)
576:       if self.kind_of? TopLevel
577:         self.requires.each{|r|
578:           if r.name == name ||
579:               r.name.upcase == name.upcase && ignore_case
580:             return true
581:           end
582:         }
583:         return false
584:       else
585:         parent.include_requires?(name)
586:       end
587:     end

[Source]

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

[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

map the module hash to an array externally

[Source]

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

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 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

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

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

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

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

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

[Validate]