Class: RDoc::Context (Ruby 2.3.2)
Description: Class : RDoc::Context - Ruby 2.3.2

- Home
- Core 2.3.2
- Std-lib 2.3.2
- Downloads

Support for the Ruby 2.3 series has ended. See here for reference.

### Home Classes Methods

### In Files

- rdoc/context.rb
- rdoc/context/section.rb
- rdoc/generator/markup.rb

### Parent

RDoc::CodeObject

### Namespace

- CLASS RDoc::Context::Section

### Methods

- ::new
- #<=>
- #add
- #add_alias
- #add_attribute
- #add_class
- #add_class_or_module
- #add_constant
- #add_extend
- #add_include
- #add_method
- #add_module
- #add_module_alias
- #add_require
- #add_section
- #add_to
- #any_content
- #child_name
- #class_attributes
- #class_method_list
- #classes
- #classes_and_modules
- #classes_hash
- #current_section
- #defined_in?
- #each_attribute
- #each_classmodule
- #each_constant
- #each_extend
- #each_include
- #each_method
- #each_section
- #find_attribute
- #find_attribute_named
- #find_class_method_named
- #find_constant_named
- #find_enclosing_module_named
- #find_external_alias
- #find_external_alias_named
- #find_file_named
- #find_instance_method_named
- #find_local_symbol
- #find_method
- #find_method_named
- #find_module_named
- #find_symbol
- #find_symbol_module
- #full_name
- #fully_documented?
- #http_url
- #initialize_methods_etc
- #instance_attributes
- #instance_method_list
- #methods_by_type
- #methods_matching
- #modules
- #modules_hash
- #name_for_path
- #ongoing_visibility=
- #record_location
- #remove_from_documentation?
- #remove_invisible
- #resolve_aliases
- #section_contents
- #sections
- #set_current_section
- #set_visibility_for
- #sort_sections
- #top_level
- #upgrade_to_class

### Included Modules

- Comparable

### Class/Module Index

Quicksearch

- RDoc
- RDoc::Alias
- RDoc::AnonClass
- RDoc::AnyMethod
- RDoc::Attr
- RDoc::ClassModule
- RDoc::CodeObject
- RDoc::Comment
- RDoc::Constant
- RDoc::Context
- RDoc::Context::Section
- RDoc::CrossReference
- RDoc::ERBIO
- RDoc::ERBPartial
- RDoc::Encoding
- RDoc::Error
- RDoc::Extend
- RDoc::Generator
- RDoc::Generator::Darkfish
- RDoc::Generator::JsonIndex
- RDoc::Generator::Markup
- RDoc::Generator::POT
- RDoc::Generator::POT::MessageExtractor
- RDoc::Generator::POT::PO
- RDoc::Generator::POT::POEntry
- RDoc::Generator::RI
- RDoc::GhostMethod
- RDoc::I18n
- RDoc::I18n::Locale
- RDoc::I18n::Text
- RDoc::Include
- RDoc::Markdown
- RDoc::Markdown::Literals
- RDoc::Markup
- RDoc::Markup::AttrChanger
- RDoc::Markup::AttrSpan
- RDoc::Markup::AttributeManager
- RDoc::Markup::Attributes
- RDoc::Markup::BlankLine
- RDoc::Markup::BlockQuote
- RDoc::Markup::Document
- RDoc::Markup::Formatter
- RDoc::Markup::FormatterTestCase
- RDoc::Markup::HardBreak
- RDoc::Markup::Include
- RDoc::Markup::IndentedParagraph
- RDoc::Markup::List
- RDoc::Markup::ListItem
- RDoc::Markup::Paragraph
- RDoc::Markup::Parser
- RDoc::Markup::Parser::Error
- RDoc::Markup::Parser::ParseError
- RDoc::Markup::PreProcess
- RDoc::Markup::Raw
- RDoc::Markup::Rule
- RDoc::Markup::Special
- RDoc::Markup::TextFormatterTestCase
- RDoc::Markup::ToAnsi
- RDoc::Markup::ToBs
- RDoc::Markup::ToHtml
- RDoc::Markup::ToHtmlCrossref
- RDoc::Markup::ToHtmlSnippet
- RDoc::Markup::ToJoinedParagraph
- RDoc::Markup::ToLabel
- RDoc::Markup::ToMarkdown
- RDoc::Markup::ToRdoc
- RDoc::Markup::ToTableOfContents
- RDoc::Markup::ToTest
- RDoc::Markup::ToTtOnly
- RDoc::Markup::Verbatim
- RDoc::MetaMethod
- RDoc::MethodAttr
- RDoc::Mixin
- RDoc::NormalClass
- RDoc::NormalModule
- RDoc::Options
- RDoc::Parser
- RDoc::Parser::C
- RDoc::Parser::ChangeLog
- RDoc::Parser::Markdown
- RDoc::Parser::RD
- RDoc::Parser::Ruby
- RDoc::Parser::RubyTools
- RDoc::Parser::Simple
- RDoc::Parser::Text
- RDoc::RD
- RDoc::RD::BlockParser
- RDoc::RD::Inline
- RDoc::RD::InlineParser
- RDoc::RDoc
- RDoc::RI
- RDoc::RI::Driver
- RDoc::RI::Driver::Error
- RDoc::RI::Driver::NotFoundError
- RDoc::RI::Error
- RDoc::RI::Paths
- RDoc::RI::Task
- RDoc::Require
- RDoc::RubyLex
- RDoc::RubyLex::Error
- RDoc::RubyToken
- RDoc::RubygemsHook
- RDoc::Servlet
- RDoc::SingleClass
- RDoc::Stats
- RDoc::Stats::Normal
- RDoc::Stats::Quiet
- RDoc::Stats::Verbose
- RDoc::Store
- RDoc::Store::Error
- RDoc::Store::MissingFileError
- RDoc::Task
- RDoc::TestCase
- RDoc::Text
- RDoc::TokenStream
- RDoc::TomDoc
- RDoc::TopLevel
- RDocTask
- Test

No matching classes.

# RDoc::Context

A Context is something that can hold modules, classes, methods, attributes, aliases, requires, and includes. Classes, modules, and files are all Contexts.

### Constants

TYPES

  Types of methods

### Attributes

aliases[R]

Class/module aliases

attributes[R]

All attr* methods

block_params[RW]

Block params to be used in the next MethodAttr parsed under this context

constants[R]

Constants defined

constants_hash[R]

Hash of registered constants.

current_section[W]

Sets the current documentation section of documentation

extends[R]

Modules this context is extended with

external_aliases[R]

Aliases that could not be resolved.

in_files[R]

Files this context is found in

includes[R]

Modules this context includes

method_list[R]

Methods defined in this context

methods_hash[R]

Hash of registered methods. Attributes are also registered here, twice if they are RW.

name[R]

Name of this class excluding namespace. See also #full_name

params[RW]

Params to be used in the next MethodAttr parsed under this context

requires[R]

Files this context requires

temporary_section[RW]

Use this section for the next method, attribute or constant added.

unmatched_alias_lists[RW]

Hash `old_name => [aliases]`, for aliases that haven't (yet) been resolved to a method/attribute. (Not to be confused with the aliases of the context.)

visibility[RW]

Current visibility of this context

### Public Class Methods

new() click to toggle source

Creates an unnamed empty context with public current visibility

                   # File rdoc/context.rb, line 119
    def initialize
      super

      @in_files = []

      @name    ||= "unknown"
      @parent  = nil
      @visibility = :public

      @current_section = Section.new self, nil, nil
      @sections = { nil => @current_section }
      @temporary_section = nil

      @classes = {}
      @modules = {}

      initialize_methods_etc
    end

### Public Instance Methods

<=>(other) click to toggle source

Contexts are sorted by #full_name

                   # File rdoc/context.rb, line 166
    def <=>(other)
      return nil unless RDoc::CodeObject === other

      full_name <=> other.full_name
    end

add(klass, name, comment) click to toggle source

Adds an item of type `klass` with the given `name` and `comment` to the context.

Currently only RDoc::Extend and RDoc::Include are supported.

                   # File rdoc/context.rb, line 178
    def add klass, name, comment
      if RDoc::Extend == klass then
        ext = RDoc::Extend.new name, comment
        add_extend ext
      elsif RDoc::Include == klass then
        incl = RDoc::Include.new name, comment
        add_include incl
      else
        raise NotImplementedError, "adding a #{klass} is not implemented"
      end
    end

add_alias(an_alias) click to toggle source

Adds `an_alias` that is automatically resolved

                   # File rdoc/context.rb, line 193
    def add_alias an_alias
      return an_alias unless @document_self

      method_attr = find_method(an_alias.old_name, an_alias.singleton) ||
                    find_attribute(an_alias.old_name, an_alias.singleton)

      if method_attr then
        method_attr.add_alias an_alias, self
      else
        add_to @external_aliases, an_alias
        unmatched_alias_list =
          @unmatched_alias_lists[an_alias.pretty_old_name] ||= []
        unmatched_alias_list.push an_alias
      end

      an_alias
    end

add_attribute(attribute) click to toggle source

Adds `attribute` if not already there. If it is (as method(s) or attribute), updates the comment if it was empty.

The attribute is registered only if it defines a new method. For instance, `attr_reader :foo` will not be registered if method `foo` exists, but `attr_accessor :foo` will be registered if method `foo` exists, but `foo=` does not.

                   # File rdoc/context.rb, line 220
    def add_attribute attribute
      return attribute unless @document_self

      # mainly to check for redefinition of an attribute as a method
      # TODO find a policy for 'attr_reader :foo' + 'def foo=()'
      register = false

      key = nil

      if attribute.rw.index 'R' then
        key = attribute.pretty_name
        known = @methods_hash[key]

        if known then
          known.comment = attribute.comment if known.comment.empty?
        elsif registered = @methods_hash[attribute.pretty_name << '='] and
              RDoc::Attr === registered then
          registered.rw = 'RW'
        else
          @methods_hash[key] = attribute
          register = true
        end
      end

      if attribute.rw.index 'W' then
        key = attribute.pretty_name << '='
        known = @methods_hash[key]

        if known then
          known.comment = attribute.comment if known.comment.empty?
        elsif registered = @methods_hash[attribute.pretty_name] and
              RDoc::Attr === registered then
          registered.rw = 'RW'
        else
          @methods_hash[key] = attribute
          register = true
        end
      end

      if register then
        attribute.visibility = @visibility
        add_to @attributes, attribute
        resolve_aliases attribute
      end

      attribute
    end

add_class(class_type, given_name, superclass = '::Object') click to toggle source

Adds a class named `given_name` with `superclass`.

Both `given_name` and `superclass` may contain '::', and are interpreted relative to the `self` context. This allows handling correctly examples like these:

    class RDoc::Gauntlet < Gauntlet
    module Mod
      class Object   # implies < ::Object
      class SubObject < Object  # this is _not_ ::Object

Given `class Container::Item` RDoc assumes `Container` is a module unless it later sees `class Container`. `add_class` automatically upgrades `given_name` to a class in this case.

                   # File rdoc/context.rb, line 283
    def add_class class_type, given_name, superclass = '::Object'
      # superclass +nil+ is passed by the C parser in the following cases:
      # - registering Object in 1.8 (correct)
      # - registering BasicObject in 1.9 (correct)
      # - registering RubyVM in 1.9 in iseq.c (incorrect: < Object in vm.c)
      #
      # If we later find a superclass for a registered class with a nil
      # superclass, we must honor it.

      # find the name & enclosing context
      if given_name =~ /^:+(\w+)$/ then
        full_name = $1
        enclosing = top_level
        name = full_name.split(/:+/).last
      else
        full_name = child_name given_name

        if full_name =~ /^(.+)::(\w+)$/ then
          name = $2
          ename = $1
          enclosing = @store.classes_hash[ename] || @store.modules_hash[ename]
          # HACK: crashes in actionpack/lib/action_view/helpers/form_helper.rb (metaprogramming)
          unless enclosing then
            # try the given name at top level (will work for the above example)
            enclosing = @store.classes_hash[given_name] ||
                        @store.modules_hash[given_name]
            return enclosing if enclosing
            # not found: create the parent(s)
            names = ename.split('::')
            enclosing = self
            names.each do |n|
              enclosing = enclosing.classes_hash[n] ||
                          enclosing.modules_hash[n] ||
                          enclosing.add_module(RDoc::NormalModule, n)
            end
          end
        else
          name = full_name
          enclosing = self
        end
      end

      # fix up superclass
      if full_name == 'BasicObject' then
        superclass = nil
      elsif full_name == 'Object' then
        superclass = defined?(::BasicObject) ? '::BasicObject' : nil
      end

      # find the superclass full name
      if superclass then
        if superclass =~ /^:+/ then
          superclass = $' #'
        else
          if superclass =~ /^(\w+):+(.+)$/ then
            suffix = $2
            mod = find_module_named($1)
            superclass = mod.full_name + '::' + suffix if mod
          else
            mod = find_module_named(superclass)
            superclass = mod.full_name if mod
          end
        end

        # did we believe it was a module?
        mod = @store.modules_hash.delete superclass

        upgrade_to_class mod, RDoc::NormalClass, mod.parent if mod

        # e.g., Object < Object
        superclass = nil if superclass == full_name
      end

      klass = @store.classes_hash[full_name]

      if klass then
        # if TopLevel, it may not be registered in the classes:
        enclosing.classes_hash[name] = klass

        # update the superclass if needed
        if superclass then
          existing = klass.superclass
          existing = existing.full_name unless existing.is_a?(String) if existing
          if existing.nil? ||
             (existing == 'Object' && superclass != 'Object') then
            klass.superclass = superclass
          end
        end
      else
        # this is a new class
        mod = @store.modules_hash.delete full_name

        if mod then
          klass = upgrade_to_class mod, RDoc::NormalClass, enclosing

          klass.superclass = superclass unless superclass.nil?
        else
          klass = class_type.new name, superclass

          enclosing.add_class_or_module(klass, enclosing.classes_hash,
                                        @store.classes_hash)
        end
      end

      klass.parent = self

      klass
    end

add_class_or_module(mod, self_hash, all_hash) click to toggle source

Adds the class or module `mod` to the modules or classes Hash `self_hash`, and to `all_hash` (either `TopLevel::modules_hash` or `TopLevel::classes_hash`), unless done_documenting is `true`. Sets the parent of `mod` to `self`, and its section to current_section. Returns `mod`.

                   # File rdoc/context.rb, line 399
    def add_class_or_module mod, self_hash, all_hash
      mod.section = current_section # TODO declaring context? something is
                                    # wrong here...
      mod.parent = self
      mod.store = @store

      unless @done_documenting then
        self_hash[mod.name] = mod
        # this must be done AFTER adding mod to its parent, so that the full
        # name is correct:
        all_hash[mod.full_name] = mod
      end

      mod
    end

add_constant(constant) click to toggle source

Adds `constant` if not already there. If it is, updates the comment, value and/or is_alias_for of the known constant if they were empty/nil.

                   # File rdoc/context.rb, line 419
    def add_constant constant
      return constant unless @document_self

      # HACK: avoid duplicate 'PI' & 'E' in math.c (1.8.7 source code)
      # (this is a #ifdef: should be handled by the C parser)
      known = @constants_hash[constant.name]

      if known then
        known.comment = constant.comment if known.comment.empty?

        known.value = constant.value if
          known.value.nil? or known.value.strip.empty?

        known.is_alias_for ||= constant.is_alias_for
      else
        @constants_hash[constant.name] = constant
        add_to @constants, constant
      end

      constant
    end

add_extend(ext) click to toggle source

Adds extension module `ext` which should be an RDoc::Extend

                   # File rdoc/context.rb, line 453
    def add_extend ext
      add_to @extends, ext

      ext
    end

add_include(include) click to toggle source

Adds included module `include` which should be an RDoc::Include

                   # File rdoc/context.rb, line 444
    def add_include include
      add_to @includes, include

      include
    end

add_method(method) click to toggle source

Adds `method` if not already there. If it is (as method or attribute), updates the comment if it was empty.

                   # File rdoc/context.rb, line 463
    def add_method method
      return method unless @document_self

      # HACK: avoid duplicate 'new' in io.c & struct.c (1.8.7 source code)
      key = method.pretty_name
      known = @methods_hash[key]

      if known then
        if @store then # otherwise we are loading
          known.comment = method.comment if known.comment.empty?
          previously = ", previously in #{known.file}" unless
            method.file == known.file
          @store.rdoc.options.warn \
            "Duplicate method #{known.full_name} in #{method.file}#{previously}"
        end
      else
        @methods_hash[key] = method
        method.visibility = @visibility
        add_to @method_list, method
        resolve_aliases method
      end

      method
    end

add_module(class_type, name) click to toggle source

Adds a module named `name`. If RDoc already knows `name` is a class then that class is returned instead. See also add_class.

                   # File rdoc/context.rb, line 492
    def add_module(class_type, name)
      mod = @classes[name] || @modules[name]
      return mod if mod

      full_name = child_name name
      mod = @store.modules_hash[full_name] || class_type.new(name)

      add_class_or_module mod, @modules, @store.modules_hash
    end

add_module_alias(from, name, file) click to toggle source

Adds an alias from `from` (a class or module) to `name` which was defined in `file`.

                   # File rdoc/context.rb, line 506
    def add_module_alias from, name, file
      return from if @done_documenting

      to_name = child_name name

      # if we already know this name, don't register an alias:
      # see the metaprogramming in lib/active_support/basic_object.rb,
      # where we already know BasicObject is a class when we find
      # BasicObject = BlankSlate
      return from if @store.find_class_or_module to_name

      to = from.dup
      to.name = name
      to.full_name = nil

      if to.module? then
        @store.modules_hash[to_name] = to
        @modules[name] = to
      else
        @store.classes_hash[to_name] = to
        @classes[name] = to
      end

      # Registers a constant for this alias.  The constant value and comment
      # will be updated later, when the Ruby parser adds the constant
      const = RDoc::Constant.new name, nil, to.comment
      const.record_location file
      const.is_alias_for = from
      add_constant const

      to
    end

add_require(require) click to toggle source

Adds `require` to this context's top level

                   # File rdoc/context.rb, line 542
    def add_require(require)
      return require unless @document_self

      if RDoc::TopLevel === self then
        add_to @requires, require
      else
        parent.add_require require
      end
    end

add_section(title, comment = nil) click to toggle source

Returns a section with `title`, creating it if it doesn't already exist. `comment` will be appended to the section's comment.

A section with a `title` of `nil` will return the default section.

See also RDoc::Context::Section

                   # File rdoc/context.rb, line 560
    def add_section title, comment = nil
      if section = @sections[title] then
        section.add_comment comment if comment
      else
        section = Section.new self, title, comment
        @sections[title] = section
      end

      section
    end

add_to(array, thing) click to toggle source

Adds `thing` to the collection `array`

                   # File rdoc/context.rb, line 574
    def add_to array, thing
      array << thing if @document_self

      thing.parent  = self
      thing.store   = @store if @store
      thing.section = current_section
    end

any_content(includes = true) click to toggle source

Is there any content?

This means any of: comment, aliases, methods, attributes, external aliases, require, constant.

Includes and extends are also checked unless `includes == false`.

                   # File rdoc/context.rb, line 590
    def any_content(includes = true)
      @any_content ||= !(
        @comment.empty? &&
        @method_list.empty? &&
        @attributes.empty? &&
        @aliases.empty? &&
        @external_aliases.empty? &&
        @requires.empty? &&
        @constants.empty?
      )
      @any_content || (includes && !(@includes + @extends).empty? )
    end

child_name(name) click to toggle source

Creates the full name for a child with `name`

                   # File rdoc/context.rb, line 606
    def child_name name
      if name =~ /^:+/
        $'  #'
      elsif RDoc::TopLevel === self then
        name
      else
        "#{self.full_name}::#{name}"
      end
    end

class_attributes() click to toggle source

Class attributes

                   # File rdoc/context.rb, line 619
    def class_attributes
      @class_attributes ||= attributes.select { |a| a.singleton }
    end

class_method_list() click to toggle source

Class methods

                   # File rdoc/context.rb, line 626
    def class_method_list
      @class_method_list ||= method_list.select { |a| a.singleton }
    end

classes() click to toggle source

Array of classes in this context

                   # File rdoc/context.rb, line 633
    def classes
      @classes.values
    end

classes_and_modules() click to toggle source

All classes and modules in this namespace

                   # File rdoc/context.rb, line 640
    def classes_and_modules
      classes + modules
    end

classes_hash() click to toggle source

Hash of classes keyed by class name

                   # File rdoc/context.rb, line 647
    def classes_hash
      @classes
    end

current_section() click to toggle source

The current documentation section that new items will be added to. If #temporary_section is available it will be used.

                   # File rdoc/context.rb, line 655
    def current_section
      if section = @temporary_section then
        @temporary_section = nil
      else
        section = @current_section
      end

      section
    end

defined_in?(file) click to toggle source

Is part of this thing was defined in `file`?

                   # File rdoc/context.rb, line 668
    def defined_in?(file)
      @in_files.include?(file)
    end

each_attribute() click to toggle source

Iterator for attributes

                   # File rdoc/context.rb, line 693
    def each_attribute # :yields: attribute
      @attributes.each { |a| yield a }
    end

each_classmodule() click to toggle source

Iterator for classes and modules

                   # File rdoc/context.rb, line 700
    def each_classmodule(&block) # :yields: module
      classes_and_modules.sort.each(&block)
    end

each_constant() click to toggle source

Iterator for constants

                   # File rdoc/context.rb, line 707
    def each_constant # :yields: constant
      @constants.each {|c| yield c}
    end

each_extend() click to toggle source

Iterator for extension modules

                   # File rdoc/context.rb, line 721
    def each_extend # :yields: extend
      @extends.each do |e| yield e end
    end

each_include() click to toggle source

Iterator for included modules

                   # File rdoc/context.rb, line 714
    def each_include # :yields: include
      @includes.each do |i| yield i end
    end

each_method() click to toggle source

Iterator for methods

                   # File rdoc/context.rb, line 728
    def each_method # :yields: method
      return enum_for __method__ unless block_given?

      @method_list.sort.each { |m| yield m }
    end

each_section() click to toggle source

Iterator for each section's contents sorted by title. The `section`, the section's `constants` and the sections `attributes` are yielded. The `constants` and `attributes` collections are sorted.

To retrieve methods in a section use methods_by_type with the optional `section` parameter.

NOTE: Do not edit collections yielded by this method

                   # File rdoc/context.rb, line 744
    def each_section # :yields: section, constants, attributes
      return enum_for __method__ unless block_given?

      constants  = @constants.group_by  do |constant|  constant.section end
      attributes = @attributes.group_by do |attribute| attribute.section end

      constants.default  = []
      attributes.default = []

      sort_sections.each do |section|
        yield section, constants[section].sort, attributes[section].sort
      end
    end

find_attribute(name, singleton) click to toggle source

Finds an attribute `name` with singleton value `singleton`.

                   # File rdoc/context.rb, line 761
    def find_attribute(name, singleton)
      name = $1 if name =~ /^(.*)=$/
      @attributes.find { |a| a.name == name && a.singleton == singleton }
    end

find_attribute_named(name) click to toggle source

Finds an attribute with `name` in this context

                   # File rdoc/context.rb, line 769
    def find_attribute_named(name)
      case name
      when /\A#/ then
        find_attribute name[1..-1], false
      when /\A::/ then
        find_attribute name[2..-1], true
      else
        @attributes.find { |a| a.name == name }
      end
    end

find_class_method_named(name) click to toggle source

Finds a class method with `name` in this context

                   # File rdoc/context.rb, line 783
    def find_class_method_named(name)
      @method_list.find { |meth| meth.singleton && meth.name == name }
    end

find_constant_named(name) click to toggle source

Finds a constant with `name` in this context

                   # File rdoc/context.rb, line 790
    def find_constant_named(name)
      @constants.find {|m| m.name == name}
    end

find_enclosing_module_named(name) click to toggle source

Find a module at a higher scope

                   # File rdoc/context.rb, line 797
    def find_enclosing_module_named(name)
      parent && parent.find_module_named(name)
    end

find_external_alias(name, singleton) click to toggle source

Finds an external alias `name` with singleton value `singleton`.

                   # File rdoc/context.rb, line 804
    def find_external_alias(name, singleton)
      @external_aliases.find { |m| m.name == name && m.singleton == singleton }
    end

find_external_alias_named(name) click to toggle source

Finds an external alias with `name` in this context

                   # File rdoc/context.rb, line 811
    def find_external_alias_named(name)
      case name
      when /\A#/ then
        find_external_alias name[1..-1], false
      when /\A::/ then
        find_external_alias name[2..-1], true
      else
        @external_aliases.find { |a| a.name == name }
      end
    end

find_file_named(name) click to toggle source

Finds a file with `name` in this context

                   # File rdoc/context.rb, line 825
    def find_file_named name
      @store.find_file_named name
    end

find_instance_method_named(name) click to toggle source

Finds an instance method with `name` in this context

                   # File rdoc/context.rb, line 832
    def find_instance_method_named(name)
      @method_list.find { |meth| !meth.singleton && meth.name == name }
    end

find_local_symbol(symbol) click to toggle source

Finds a method, constant, attribute, external alias, module or file named `symbol` in this context.

                   # File rdoc/context.rb, line 840
    def find_local_symbol(symbol)
      find_method_named(symbol) or
      find_constant_named(symbol) or
      find_attribute_named(symbol) or
      find_external_alias_named(symbol) or
      find_module_named(symbol) or
      find_file_named(symbol)
    end

find_method(name, singleton) click to toggle source

Finds a method named `name` with singleton value `singleton`.

                   # File rdoc/context.rb, line 852
    def find_method(name, singleton)
      @method_list.find { |m| m.name == name && m.singleton == singleton }
    end

find_method_named(name) click to toggle source

Finds a instance or module method with `name` in this context

                   # File rdoc/context.rb, line 859
    def find_method_named(name)
      case name
      when /\A#/ then
        find_method name[1..-1], false
      when /\A::/ then
        find_method name[2..-1], true
      else
        @method_list.find { |meth| meth.name == name }
      end
    end

find_module_named(name) click to toggle source

Find a module with `name` using ruby's scoping rules

                   # File rdoc/context.rb, line 873
    def find_module_named(name)
      res = @modules[name] || @classes[name]
      return res if res
      return self if self.name == name
      find_enclosing_module_named name
    end

find_symbol(symbol) click to toggle source

Look up `symbol`, first as a module, then as a local symbol.

                   # File rdoc/context.rb, line 883
    def find_symbol(symbol)
      find_symbol_module(symbol) || find_local_symbol(symbol)
    end

find_symbol_module(symbol) click to toggle source

Look up a module named `symbol`.

                   # File rdoc/context.rb, line 890
    def find_symbol_module(symbol)
      result = nil

      # look for a class or module 'symbol'
      case symbol
      when /^::/ then
        result = @store.find_class_or_module symbol
      when /^(\w+):+(.+)$/
        suffix = $2
        top = $1
        searched = self
        while searched do
          mod = searched.find_module_named(top)
          break unless mod
          result = @store.find_class_or_module "#{mod.full_name}::#{suffix}"
          break if result || searched.is_a?(RDoc::TopLevel)
          searched = searched.parent
        end
      else
        searched = self
        while searched do
          result = searched.find_module_named(symbol)
          break if result || searched.is_a?(RDoc::TopLevel)
          searched = searched.parent
        end
      end

      result
    end

full_name() click to toggle source

The full name for this context. This method is overridden by subclasses.

                   # File rdoc/context.rb, line 923
    def full_name
      '(unknown)'
    end

fully_documented?() click to toggle source

Does this context and its methods and constants all have documentation?

(Yes, fully documented doesn't mean everything.)

                   # File rdoc/context.rb, line 932
    def fully_documented?
      documented? and
        attributes.all? { |a| a.documented? } and
        method_list.all? { |m| m.documented? } and
        constants.all? { |c| c.documented? }
    end

http_url(prefix) click to toggle source

URL for this with a `prefix`

                   # File rdoc/context.rb, line 942
    def http_url(prefix)
      path = name_for_path
      path = path.gsub(/<<\s*(\w*)/, 'from-\1') if path =~ /<</
      path = [prefix] + path.split('::')

      File.join(*path.compact) + '.html'
    end

initialize_methods_etc() click to toggle source

Sets the defaults for methods and so-forth

                   # File rdoc/context.rb, line 141
    def initialize_methods_etc
      @method_list = []
      @attributes  = []
      @aliases     = []
      @requires    = []
      @includes    = []
      @extends     = []
      @constants   = []
      @external_aliases = []

      # This Hash maps a method name to a list of unmatched aliases (aliases of
      # a method not yet encountered).
      @unmatched_alias_lists = {}

      @methods_hash   = {}
      @constants_hash = {}

      @params = nil

      @store ||= nil
    end

instance_attributes() click to toggle source

Instance attributes

                   # File rdoc/context.rb, line 953
    def instance_attributes
      @instance_attributes ||= attributes.reject { |a| a.singleton }
    end

instance_method_list() click to toggle source

Instance methods

                   # File rdoc/context.rb, line 962
    def instance_method_list
      @instance_method_list ||= method_list.reject { |a| a.singleton }
    end

methods_by_type(section = nil) click to toggle source

Breaks #method_list into a nested hash by type (`'class'` or `'instance'`) and visibility (`:public`, `:protected`, `:private`).

If `section` is provided only methods in that RDoc::Context::Section will be returned.

                   # File rdoc/context.rb, line 973
    def methods_by_type section = nil
      methods = {}

      TYPES.each do |type|
        visibilities = {}
        RDoc::VISIBILITIES.each do |vis|
          visibilities[vis] = []
        end

        methods[type] = visibilities
      end

      each_method do |method|
        next if section and not method.section == section
        methods[method.type][method.visibility] << method
      end

      methods
    end

methods_matching(methods, singleton = false, &block) click to toggle source

Yields AnyMethod and Attr entries matching the list of names in `methods`.

                   # File rdoc/context.rb, line 996
    def methods_matching(methods, singleton = false, &block)
      (@method_list + @attributes).each do |m|
        yield m if methods.include?(m.name) and m.singleton == singleton
      end

      each_ancestor do |parent|
        parent.methods_matching(methods, singleton, &block)
      end
    end

modules() click to toggle source

Array of modules in this context

                   # File rdoc/context.rb, line 1009
    def modules
      @modules.values
    end

modules_hash() click to toggle source

Hash of modules keyed by module name

                   # File rdoc/context.rb, line 1016
    def modules_hash
      @modules
    end

name_for_path() click to toggle source

Name to use to generate the url. `#full_name` by default.

                   # File rdoc/context.rb, line 1024
    def name_for_path
      full_name
    end

ongoing_visibility=(visibility) click to toggle source

Changes the visibility for new methods to `visibility`

                   # File rdoc/context.rb, line 1031
    def ongoing_visibility=(visibility)
      @visibility = visibility
    end

record_location(top_level) click to toggle source

Record `top_level` as a file `self` is in.

                   # File rdoc/context.rb, line 1038
    def record_location(top_level)
      @in_files << top_level unless @in_files.include?(top_level)
    end

remove_from_documentation?() click to toggle source

Should we remove this context from the documentation?

The answer is yes if:

- received_nodoc is `true`

- any_content is `false` (not counting includes)

- All includes are modules (not a string), and their module has `#remove_from_documentation? == true`

- All classes and modules have `#remove_from_documentation? == true`

                   # File rdoc/context.rb, line 1052
    def remove_from_documentation?
      @remove_from_documentation ||=
        @received_nodoc &&
        !any_content(false) &&
        @includes.all? { |i| !i.module.is_a?(String) && i.module.remove_from_documentation? } &&
        classes_and_modules.all? { |cm| cm.remove_from_documentation? }
    end

remove_invisible(min_visibility) click to toggle source

Removes methods and attributes with a visibility less than `min_visibility`.

                   # File rdoc/context.rb, line 1065
    def remove_invisible min_visibility
      return if [:private, :nodoc].include? min_visibility
      remove_invisible_in @method_list, min_visibility
      remove_invisible_in @attributes, min_visibility
    end

resolve_aliases(added) click to toggle source

Tries to resolve unmatched aliases when a method or attribute has just been added.

                   # File rdoc/context.rb, line 1090
    def resolve_aliases added
      # resolve any pending unmatched aliases
      key = added.pretty_name
      unmatched_alias_list = @unmatched_alias_lists[key]
      return unless unmatched_alias_list
      unmatched_alias_list.each do |unmatched_alias|
        added.add_alias unmatched_alias, self
        @external_aliases.delete unmatched_alias
      end
      @unmatched_alias_lists.delete key
    end

section_contents() click to toggle source

Returns RDoc::Context::Section objects referenced in this context for use in a table of contents.

                   # File rdoc/context.rb, line 1106
    def section_contents
      used_sections = {}

      each_method do |method|
        next unless method.display?

        used_sections[method.section] = true
      end

      # order found sections
      sections = sort_sections.select do |section|
        used_sections[section]
      end

      # only the default section is used
      return [] if
        sections.length == 1 and not sections.first.title

      sections
    end

sections() click to toggle source

Sections in this context

                   # File rdoc/context.rb, line 1130
    def sections
      @sections.values
    end

set_current_section(title, comment) click to toggle source

Sets the current section to a section with `title`. See also add_section

                   # File rdoc/context.rb, line 1141
    def set_current_section title, comment
      @current_section = add_section title, comment
    end

set_visibility_for(methods, visibility, singleton = false) click to toggle source

Given an array `methods` of method names, set the visibility of each to `visibility`

                   # File rdoc/context.rb, line 1149
    def set_visibility_for(methods, visibility, singleton = false)
      methods_matching methods, singleton do |m|
        m.visibility = visibility
      end
    end

sort_sections() click to toggle source

Sorts sections alphabetically (default) or in TomDoc fashion (none, Public, Internal, Deprecated)

                   # File rdoc/context.rb, line 1159
    def sort_sections
      titles = @sections.map { |title, _| title }

      if titles.length > 1 and
         TOMDOC_TITLES_SORT ==
           (titles | TOMDOC_TITLES).sort_by { |title| title.to_s } then
        @sections.values_at(*TOMDOC_TITLES).compact
      else
        @sections.sort_by { |title, _|
          title.to_s
        }.map { |_, section|
          section
        }
      end
    end

top_level() click to toggle source

Return the TopLevel that owns us

                   # File rdoc/context.rb, line 1185
    def top_level
      return @top_level if defined? @top_level
      @top_level = self
      @top_level = @top_level.parent until RDoc::TopLevel === @top_level
      @top_level
    end

upgrade_to_class(mod, class_type, enclosing) click to toggle source

Upgrades NormalModule `mod` in `enclosing` to a `class_type`

                   # File rdoc/context.rb, line 1195
    def upgrade_to_class mod, class_type, enclosing
      enclosing.modules_hash.delete mod.name

      klass = RDoc::ClassModule.from_module class_type, mod
      klass.store = @store

      # if it was there, then we keep it even if done_documenting
      @store.classes_hash[mod.full_name] = klass
      enclosing.classes_hash[mod.name]   = klass

      klass
    end