rdoc 3.1 → 6.3.3

data/lib/rdoc/method_attr.rb

@@ -1,5 +1,4 @@
-require 'rdoc/code_object'
-
+# frozen_string_literal: true
 ##
 # Abstract class representing either a method or an attribute.
 
@@ -96,11 +95,31 @@ class RDoc::MethodAttr < RDoc::CodeObject
     @params       = nil
   end
 
+  ##
+  # Resets cached data for the object so it can be rebuilt by accessor methods
+
+  def initialize_copy other # :nodoc:
+    @full_name = nil
+  end
+
+  def initialize_visibility # :nodoc:
+    super
+    @see = nil
+  end
+
   ##
   # Order by #singleton then #name
 
   def <=>(other)
-    [@singleton ? 0 : 1, name] <=> [other.singleton ? 0 : 1, other.name]
+    return unless other.respond_to?(:singleton) &&
+                  other.respond_to?(:name)
+
+    [     @singleton ? 0 : 1,       name] <=>
+    [other.singleton ? 0 : 1, other.name]
+  end
+
+  def == other # :nodoc:
+    equal?(other) or self.class == other.class and full_name == other.full_name
   end
 
   ##
@@ -135,6 +154,15 @@ class RDoc::MethodAttr < RDoc::CodeObject
     @see
   end
 
+  ##
+  # Sets the store for this class or module and its contained code objects.
+
+  def store= store
+    super
+
+    @file = @store.add_file @file.full_name if @file
+  end
+
   def find_see # :nodoc:
     return nil if singleton || is_alias_for
 
@@ -151,16 +179,16 @@ class RDoc::MethodAttr < RDoc::CodeObject
     return nil unless parent.respond_to? :ancestors
 
     searched = parent.ancestors
-    kernel = RDoc::TopLevel.all_modules_hash['Kernel']
+    kernel = @store.modules_hash['Kernel']
 
     searched << kernel if kernel &&
       parent != kernel && !searched.include?(kernel)
 
     searched.each do |ancestor|
-      next if parent == ancestor
       next if String === ancestor
+      next if parent == ancestor
 
-      other = ancestor.find_method_named('#' << name) ||
+      other = ancestor.find_method_named('#' + name) ||
               ancestor.find_attribute_named(name)
 
       return other if other
@@ -173,10 +201,10 @@ class RDoc::MethodAttr < RDoc::CodeObject
   # Abstract method. Contexts in their building phase call this
   # to register a new alias for this known method/attribute.
   #
-  # - creates a new AnyMethod/Attribute +newa+ named an_alias.new_name;
-  # - adds +self+ as +newa.is_alias_for+;
-  # - adds +newa+ to #aliases
-  # - adds +newa+ to the methods/attributes of +context+.
+  # - creates a new AnyMethod/Attribute named <tt>an_alias.new_name</tt>;
+  # - adds +self+ as an alias for the new method or attribute
+  # - adds the method or attribute to #aliases
+  # - adds the method or attribute to +context+.
 
   def add_alias(an_alias, context)
     raise NotImplementedError
@@ -199,7 +227,7 @@ class RDoc::MethodAttr < RDoc::CodeObject
   end
 
   ##
-  # Attempts to sanitize the content passed by the ruby parser:
+  # Attempts to sanitize the content passed by the Ruby parser:
   # remove outer parentheses, etc.
 
   def block_params=(value)
@@ -261,6 +289,8 @@ class RDoc::MethodAttr < RDoc::CodeObject
   # HTML id-friendly method/attribute name
 
   def html_name
+    require 'cgi'
+
     CGI.escape(@name.gsub('-', '-2D')).gsub('%','-').sub(/^-/, '')
   end
 
@@ -268,14 +298,39 @@ class RDoc::MethodAttr < RDoc::CodeObject
   # Full method/attribute name including namespace
 
   def full_name
-    @full_name || "#{parent_name}#{pretty_name}"
+    @full_name ||= "#{parent_name}#{pretty_name}"
+  end
+
+  def inspect # :nodoc:
+    alias_for = @is_alias_for ? " (alias for #{@is_alias_for.name})" : nil
+    visibility = self.visibility
+    visibility = "forced #{visibility}" if force_documentation
+    "#<%s:0x%x %s (%s)%s>" % [
+      self.class, object_id,
+      full_name,
+      visibility,
+      alias_for,
+    ]
   end
 
   ##
   # '::' for a class method/attribute, '#' for an instance method.
 
   def name_prefix
-    singleton ? '::' : '#'
+    @singleton ? '::' : '#'
+  end
+
+  ##
+  # Name for output to HTML.  For class methods the full name with a "." is
+  # used like +SomeClass.method_name+.  For instance methods the class name is
+  # used if +context+ does not match the parent.
+  #
+  # This is to help prevent people from using :: to call class methods.
+
+  def output_name context
+    return "#{name_prefix}#{@name}" if context == parent
+
+    "#{parent_name}#{@singleton ? '.' : '#'}#{@name}"
   end
 
   ##
@@ -293,7 +348,7 @@ class RDoc::MethodAttr < RDoc::CodeObject
   end
 
   ##
-  # Path to this method
+  # Path to this method for use with HTML generator output.
 
   def path
     "#{@parent.path}##{aref}"
@@ -307,7 +362,12 @@ class RDoc::MethodAttr < RDoc::CodeObject
   end
 
   def pretty_print q # :nodoc:
-    alias_for = @is_alias_for ? "alias for #{@is_alias_for.name}" : nil
+    alias_for =
+      if @is_alias_for.respond_to? :name then
+        "alias for #{@is_alias_for.name}"
+      elsif Array === @is_alias_for then
+        "alias for #{@is_alias_for.last}"
+      end
 
     q.group 2, "[#{self.class.name} #{full_name} #{visibility}", "]" do
       if alias_for then
@@ -331,13 +391,19 @@ class RDoc::MethodAttr < RDoc::CodeObject
     end
   end
 
-  def inspect # :nodoc:
-    alias_for = @is_alias_for ? " (alias for #{@is_alias_for.name})" : nil
-    "#<%s:0x%x %s (%s)%s>" % [
-      self.class, object_id,
+  ##
+  # Used by RDoc::Generator::JsonIndex to create a record for the search
+  # engine.
+
+  def search_record
+    [
+      @name,
       full_name,
-      visibility,
-      alias_for,
+      @name,
+      @parent.full_name,
+      path,
+      params,
+      snippet(@comment),
     ]
   end
 

data/lib/rdoc/mixin.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+##
+# A Mixin adds features from a module into another context.  RDoc::Include and
+# RDoc::Extend are both mixins.
+
+class RDoc::Mixin < RDoc::CodeObject
+
+  ##
+  # Name of included module
+
+  attr_accessor :name
+
+  ##
+  # Creates a new Mixin for +name+ with +comment+
+
+  def initialize(name, comment)
+    super()
+    @name = name
+    self.comment = comment
+    @module = nil # cache for module if found
+  end
+
+  ##
+  # Mixins are sorted by name
+
+  def <=> other
+    return unless self.class === other
+
+    name <=> other.name
+  end
+
+  def == other # :nodoc:
+    self.class === other and @name == other.name
+  end
+
+  alias eql? == # :nodoc:
+
+  ##
+  # Full name based on #module
+
+  def full_name
+    m = self.module
+    RDoc::ClassModule === m ? m.full_name : @name
+  end
+
+  def hash # :nodoc:
+    [@name, self.module].hash
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %s.%s %s>" % [
+      self.class,
+      object_id,
+      parent_name, self.class.name.downcase, @name,
+    ]
+  end
+
+  ##
+  # Attempts to locate the included module object.  Returns the name if not
+  # known.
+  #
+  # The scoping rules of Ruby to resolve the name of an included module are:
+  # - first look into the children of the current context;
+  # - if not found, look into the children of included modules,
+  #   in reverse inclusion order;
+  # - if still not found, go up the hierarchy of names.
+  #
+  # This method has <code>O(n!)</code> behavior when the module calling
+  # include is referencing nonexistent modules.  Avoid calling #module until
+  # after all the files are parsed.  This behavior is due to ruby's constant
+  # lookup behavior.
+  #
+  # As of the beginning of October, 2011, no gem includes nonexistent modules.
+
+  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.includes.take_while { |i| i != self }.reverse
+    searched.each do |i|
+      inc = i.module
+      next if String === inc
+      full_name = inc.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
+
+  ##
+  # Sets the store for this class or module and its contained code objects.
+
+  def store= store
+    super
+
+    @file = @store.add_file @file.full_name if @file
+  end
+
+  def to_s # :nodoc:
+    "#{self.class.name.downcase} #@name in: #{parent}"
+  end
+
+end
+

data/lib/rdoc/normal_class.rb

@@ -1,31 +1,55 @@
-require 'rdoc/class_module'
-
+# frozen_string_literal: true
 ##
 # A normal class, neither singleton nor anonymous
 
 class RDoc::NormalClass < RDoc::ClassModule
 
   ##
-  # Appends the superclass, if any, to the included modules.
+  # The ancestors of this class including modules.  Unlike Module#ancestors,
+  # this class is not included in the result.  The result will contain both
+  # RDoc::ClassModules and Strings.
 
   def ancestors
+    if String === superclass then
+      super << superclass
+    elsif superclass then
+      ancestors = super
+      ancestors << superclass
+      ancestors.concat superclass.ancestors
+    else
+      super
+    end
+  end
+
+  def aref_prefix # :nodoc:
+    'class'
+  end
+
+  ##
+  # The definition of this class, <tt>class MyClassName</tt>
+
+  def definition
+    "class #{full_name}"
+  end
+
+  def direct_ancestors
     superclass ? super + [superclass] : super
   end
 
   def inspect # :nodoc:
     superclass = @superclass ? " < #{@superclass}" : nil
-    "<%s:0x%x class %s%s includes: %p attributes: %p methods: %p aliases: %p>" % [
+    "<%s:0x%x class %s%s includes: %p extends: %p attributes: %p methods: %p aliases: %p>" % [
       self.class, object_id,
-      full_name, superclass, @includes, @attributes, @method_list, @aliases
+      full_name, superclass, @includes, @extends, @attributes, @method_list, @aliases
     ]
   end
 
   def to_s # :nodoc:
     display = "#{self.class.name} #{self.full_name}"
     if superclass
-      display << ' < ' << (superclass.is_a?(String) ? superclass : superclass.full_name)
+      display += ' < ' + (superclass.is_a?(String) ? superclass : superclass.full_name)
     end
-    display << ' -> ' << is_alias_for.to_s if is_alias_for
+    display += ' -> ' + is_alias_for.to_s if is_alias_for
     display
   end
 
@@ -38,20 +62,25 @@ class RDoc::NormalClass < RDoc::ClassModule
       q.breakable
       q.seplist @includes do |inc| q.pp inc end
 
+      q.breakable
+      q.text "constants:"
+      q.breakable
+      q.seplist @constants do |const| q.pp const end
+
       q.breakable
       q.text "attributes:"
       q.breakable
-      q.seplist @attributes do |inc| q.pp inc end
+      q.seplist @attributes do |attr| q.pp attr end
 
       q.breakable
       q.text "methods:"
       q.breakable
-      q.seplist @method_list do |inc| q.pp inc end
+      q.seplist @method_list do |meth| q.pp meth end
 
       q.breakable
       q.text "aliases:"
       q.breakable
-      q.seplist @aliases do |inc| q.pp inc end
+      q.seplist @aliases do |aliaz| q.pp aliaz end
 
       q.breakable
       q.text "comment:"

data/lib/rdoc/normal_module.rb

@@ -1,17 +1,27 @@
-require 'rdoc/class_module'
-
+# frozen_string_literal: true
 ##
 # A normal module, like NormalClass
 
 class RDoc::NormalModule < RDoc::ClassModule
 
+  def aref_prefix # :nodoc:
+    'module'
+  end
+
   def inspect # :nodoc:
-    "#<%s:0x%x module %s includes: %p attributes: %p methods: %p aliases: %p>" % [
+    "#<%s:0x%x module %s includes: %p extends: %p attributes: %p methods: %p aliases: %p>" % [
       self.class, object_id,
-      full_name, @includes, @attributes, @method_list, @aliases
+      full_name, @includes, @extends, @attributes, @method_list, @aliases
     ]
   end
 
+  ##
+  # The definition of this module, <tt>module MyModuleName</tt>
+
+  def definition
+    "module #{full_name}"
+  end
+
   ##
   # This is a module, returns true
 
@@ -27,19 +37,24 @@ class RDoc::NormalModule < RDoc::ClassModule
       q.seplist @includes do |inc| q.pp inc end
       q.breakable
 
+      q.breakable
+      q.text "constants:"
+      q.breakable
+      q.seplist @constants do |const| q.pp const end
+
       q.text "attributes:"
       q.breakable
-      q.seplist @attributes do |inc| q.pp inc end
+      q.seplist @attributes do |attr| q.pp attr end
       q.breakable
 
       q.text "methods:"
       q.breakable
-      q.seplist @method_list do |inc| q.pp inc end
+      q.seplist @method_list do |meth| q.pp meth end
       q.breakable
 
       q.text "aliases:"
       q.breakable
-      q.seplist @aliases do |inc| q.pp inc end
+      q.seplist @aliases do |aliaz| q.pp aliaz end
       q.breakable
 
       q.text "comment:"