Class: RDoc::Extend

### Home Classes Methods

### In Files

- lib/rdoc/extend.rb

### Parent

RDoc::CodeObject

### Methods

- ::new
- #<=>
- #full_name
- #module
- #store=

### Files

- CVE-2013-0256.rdoc
- DEVELOPERS.rdoc
- LICENSE.rdoc
- Manifest.txt
- README.rdoc
- RI.rdoc
- Rakefile
- TODO.rdoc

### 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::Gauntlet
- RDoc::Generator
- RDoc::Generator::Darkfish
- RDoc::Generator::JsonIndex
- RDoc::Generator::Markup
- RDoc::Generator::RI
- RDoc::GhostMethod
- 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::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::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::Task
- RDoc::TestCase
- RDoc::TokenStream
- RDoc::TomDoc
- RDoc::TopLevel
- Object

No matching classes.

# RDoc::Extend

A Module extension in a class with #extend

### Attributes

name[RW]

Name of extension module

### Public Class Methods

new(name, comment) click to toggle source

Creates a new Extend for `name` with `comment`

    # File lib/rdoc/extend.rb, line 14
    def initialize(name, comment)
      super()
      @name = name
      self.comment = comment
      @module = nil # cache for module if found
    end

### Public Instance Methods

<=>(other) click to toggle source

Extends are sorted by name

    # File lib/rdoc/extend.rb, line 24
    def <=> other
      return unless self.class === other

      name <=> other.name
    end

full_name() click to toggle source

Full name based on module

    # File lib/rdoc/extend.rb, line 39
    def full_name
      m = self.module
      RDoc::ClassModule === m ? m.full_name : @name
    end

module() click to toggle source

Attempts to locate the extend module object. Returns the name if not known.

The scoping rules of Ruby to resolve the name of an extension module are:

- first look into the children of the current context;

- if not found, look into the children of extension modules, in reverse extend order;

- if still not found, go up the hierarchy of names.

This method has `O(n!)` behavior when the module calling extend is referencing nonexistent modules. Avoid calling module until after all the files are parsed. This behavior is due to ruby's constant lookup behavior.

    # File lib/rdoc/extend.rb, line 71
    def module
      return @module if @module

      # search the current context
      return @name unless parent
      full_name = parent.child_name(@name)
      @module = @store.modules_hash[full_name]
      return @module if @module
      return @name if @name =~ /^::/

      # search the includes before this one, in reverse order
      searched = parent.extends.take_while { |i| i != self }.reverse
      searched.each do |i|
        ext = i.module
        next if String === ext
        full_name = ext.child_name(@name)
        @module = @store.modules_hash[full_name]
        return @module if @module
      end

      # go up the hierarchy of names
      up = parent.parent
      while up
        full_name = up.child_name(@name)
        @module = @store.modules_hash[full_name]
        return @module if @module
        up = up.parent
      end

      @name
    end

store=(store) click to toggle source

Sets the store for this class or module and its contained code objects.

    # File lib/rdoc/extend.rb, line 106
    def store= store
      super

      @file = @store.add_file @file.full_name if @file
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.