rdoc 2.4.3 → 2.5

data/lib/rdoc/alias.rb

@@ -39,9 +39,10 @@ class RDoc::Alias < RDoc::CodeObject
   end
 
   def inspect # :nodoc:
+    parent_name = parent ? parent.name : '(unknown)'
     "#<%s:0x%x %s.alias_method %s, %s>" % [
       self.class, object_id,
-      parent.name, @old_name, @new_name,
+      parent_name, @old_name, @new_name,
     ]
   end
 
@@ -51,4 +52,3 @@ class RDoc::Alias < RDoc::CodeObject
 
 end
 
-

data/lib/rdoc/any_method.rb

@@ -6,6 +6,10 @@ require 'rdoc/tokenstream'
 
 class RDoc::AnyMethod < RDoc::CodeObject
 
+  MARSHAL_VERSION = 0 # :nodoc:
+
+  include Comparable
+
   ##
   # Method name
 
@@ -74,15 +78,19 @@ class RDoc::AnyMethod < RDoc::CodeObject
 
   def initialize(text, name)
     super()
+
     @text = text
     @name = name
-    @token_stream  = nil
-    @visibility    = :public
+
+    @aliases                = []
+    @block_params           = nil
+    @call_seq               = nil
     @dont_rename_initialize = false
-    @block_params  = nil
-    @aliases       = []
-    @is_alias_for  = nil
-    @call_seq = nil
+    @is_alias_for           = nil
+    @parent_name            = nil
+    @singleton              = nil
+    @token_stream           = nil
+    @visibility             = :public
 
     @aref  = @@aref
     @@aref = @@aref.succ
@@ -111,21 +119,73 @@ class RDoc::AnyMethod < RDoc::CodeObject
 
   def inspect # :nodoc:
     alias_for = @is_alias_for ? " (alias for #{@is_alias_for.name})" : nil
-      "#<%s:0x%x %s%s%s (%s)%s>" % [
-        self.class, object_id,
-        parent_name,
-        singleton ? '::' : '#',
-        name,
-        visibility,
-        alias_for,
-      ]
+    "#<%s:0x%x %s (%s)%s>" % [
+      self.class, object_id,
+      full_name,
+      visibility,
+      alias_for,
+    ]
   end
 
   ##
   # Full method name including namespace
 
   def full_name
-    "#{@parent.full_name}#{pretty_name}"
+    @full_name ||= "#{@parent ? @parent.full_name : '(unknown)'}#{pretty_name}"
+  end
+
+  ##
+  # Dumps this AnyMethod for use by ri.  See also #marshal_load
+
+  def marshal_dump
+    aliases = @aliases.map do |a|
+      [a.full_name, parse(a.comment)]
+    end
+
+    [ MARSHAL_VERSION,
+      @name,
+      full_name,
+      @singleton,
+      @visibility,
+      parse(@comment),
+      @call_seq,
+      @block_params,
+      aliases,
+    ]
+  end
+
+  ##
+  # Loads this AnyMethod from +array+.  For a loaded AnyMethod the following
+  # methods will return cached values:
+  #
+  # * #full_name
+  # * #parent_name
+
+  def marshal_load(array)
+    @aliases                = []
+    @dont_rename_initialize = nil
+    @is_alias_for           = nil
+    @token_stream           = nil
+
+    @name         = array[1]
+    @full_name    = array[2]
+    @singleton    = array[3]
+    @visibility   = array[4]
+    @comment      = array[5]
+    @call_seq     = array[6]
+    @block_params = array[7]
+
+    @parent_name = if @full_name =~ /#/ then
+                     $`
+                   else
+                     name = @full_name.split('::')
+                     name.pop
+                     name.join '::'
+                   end
+
+    array[8].each do |old_name, new_name, comment|
+      add_alias RDoc::Alias.new(nil, old_name, new_name, comment)
+    end
   end
 
   ##
@@ -134,7 +194,7 @@ class RDoc::AnyMethod < RDoc::CodeObject
   def name
     return @name if @name
 
-    @name = @call_seq[/^.*?\.(\w+)/, 1] || @call_seq
+    @name = @call_seq[/^.*?\.(\w+)/, 1] || @call_seq if @call_seq
   end
 
   ##
@@ -161,6 +221,13 @@ class RDoc::AnyMethod < RDoc::CodeObject
     params
   end
 
+  ##
+  # Name of our parent with special handling for un-marshaled methods
+
+  def parent_name
+    @parent_name || super
+  end
+
   ##
   # Path to this method
 
@@ -175,6 +242,31 @@ class RDoc::AnyMethod < RDoc::CodeObject
     "#{singleton ? '::' : '#'}#{@name}"
   end
 
+  def pretty_print q # :nodoc:
+    alias_for = @is_alias_for ? "alias for #{@is_alias_for.name}" : nil
+
+    q.group 2, "[#{self.class.name} #{full_name} #{visibility}", "]" do
+      if alias_for then
+        q.breakable
+        q.text alias_for
+      end
+
+      if text then
+        q.breakable
+        q.text "text:"
+        q.breakable
+        q.pp @text
+      end
+
+      unless comment.empty? then
+        q.breakable
+        q.text "comment:"
+        q.breakable
+        q.pp @comment
+      end
+    end
+  end
+
   def to_s # :nodoc:
     "#{self.class.name}: #{full_name} (#{@text})\n#{@comment}"
   end

data/lib/rdoc/attr.rb

@@ -6,6 +6,8 @@ require 'rdoc/code_object'
 
 class RDoc::Attr < RDoc::CodeObject
 
+  MARSHAL_VERSION = 0 # :nodoc:
+
   ##
   # Name of the attribute
 
@@ -42,6 +44,35 @@ class RDoc::Attr < RDoc::CodeObject
     self.name <=> other.name
   end
 
+  ##
+  # Attributes are equal when their names and rw is identical
+
+  def == other
+    self.class == other.class and
+      self.name == other.name and
+      self.rw == other.rw
+  end
+
+  ##
+  # Returns nil, for duck typing with RDoc::AnyMethod
+
+  def block_params
+  end
+
+  ##
+  # Returns nil, for duck typing with RDoc::AnyMethod
+
+  def call_seq
+  end
+
+  ##
+  # Partially bogus as Attr has no parent.  For duck typing with
+  # RDoc::AnyMethod.
+
+  def full_name
+    @full_name ||= "#{@parent ? @parent.full_name : '(unknown)'}##{name}"
+  end
+
   ##
   # An HTML id-friendly representation of #name
 
@@ -64,6 +95,43 @@ class RDoc::Attr < RDoc::CodeObject
       ]
   end
 
+  ##
+  # Dumps this Attr for use by ri.  See also #marshal_load
+
+  def marshal_dump
+    [ MARSHAL_VERSION,
+      @name,
+      full_name,
+      @rw,
+      @visibility,
+      parse(@comment),
+    ]
+  end
+
+  ##
+  # Loads this AnyMethod from +array+.  For a loaded AnyMethod the following
+  # methods will return cached values:
+  #
+  # * #full_name
+  # * #parent_name
+
+  def marshal_load array
+    @name       = array[1]
+    @full_name  = array[2]
+    @rw         = array[3]
+    @visibility = array[4]
+    @comment    = array[5]
+
+    @parent_name = @full_name
+  end
+
+  ##
+  # Name of our parent with special handling for un-marshaled methods
+
+  def parent_name
+    @parent_name || super
+  end
+
   ##
   # URL path for this attribute
 
@@ -71,8 +139,26 @@ class RDoc::Attr < RDoc::CodeObject
     "#{@parent.path}##{@name}"
   end
 
+  ##
+  # For duck typing with RDoc::AnyMethod
+
+  def singleton
+    false
+  end
+
   def to_s # :nodoc:
-    "attr: #{self.name} #{self.rw}\n#{self.comment}"
+    "#{type} #{name}\n#{comment}"
+  end
+
+  ##
+  # Returns attr_reader, attr_writer or attr_accessor as appropriate
+
+  def type
+    case @rw
+    when 'RW' then 'attr_accessor'
+    when 'R'  then 'attr_reader'
+    when 'W'  then 'attr_writer'
+    end
   end
 
 end

data/lib/rdoc/class_module.rb

@@ -6,6 +6,8 @@ require 'rdoc/context'
 
 class RDoc::ClassModule < RDoc::Context
 
+  MARSHAL_VERSION = 0 # :nodoc:
+
   attr_accessor :diagram
 
   ##
@@ -19,13 +21,37 @@ class RDoc::ClassModule < RDoc::Context
     super()
   end
 
+  ##
+  # Ancestors list for this ClassModule (abstract)
+
+  def ancestors
+    raise NotImplementedError
+  end
+
+  ##
+  # Appends +comment+ to the current comment, but separated by a rule.  Works
+  # more like <tt>+=</tt>.
+
+  def comment=(comment)
+    return if comment.empty?
+
+    comment = "#{@comment}\n---\n#{normalize_comment comment}" unless
+      @comment.empty?
+
+    super
+  end
+
   ##
   # Finds a class or module with +name+ in this namespace or its descendents
 
   def find_class_named(name)
     return self if full_name == name
-    @classes.each_value {|c| return c if c.find_class_named(name) }
-    nil
+    return self if @name == name
+
+    @classes.values.find do |klass|
+      next if klass == self
+      klass.find_class_named name
+    end
   end
 
   ##
@@ -46,6 +72,108 @@ class RDoc::ClassModule < RDoc::Context
     module? ? 'module' : 'class'
   end
 
+  def marshal_dump # :nodoc:
+    attrs = attributes.sort.map do |attr|
+      [attr.name, attr.rw]
+    end
+
+    method_types = methods_by_type.map do |type, visibilities|
+      visibilities = visibilities.map do |visibility, methods|
+        method_names = methods.map do |method|
+          method.name
+        end
+
+        [visibility, method_names.uniq]
+      end
+
+      [type, visibilities]
+    end
+
+    [ MARSHAL_VERSION,
+      @name,
+      full_name,
+      @superclass,
+      parse(@comment),
+      attrs,
+      constants.map do |const|
+        [const.name, parse(const.comment)]
+      end,
+      includes.map do |incl|
+        [incl.name, parse(incl.comment)]
+      end,
+      method_types,
+    ]
+  end
+
+  def marshal_load array # :nodoc:
+    initialize_methods_etc
+    @document_self    = true
+    @done_documenting = false
+    @current_section  = nil
+
+    @name       = array[1]
+    @full_name  = array[2]
+    @superclass = array[3]
+    @comment    = array[4]
+
+    array[5].each do |name, rw|
+      add_attribute RDoc::Attr.new(nil, name, rw, nil)
+    end
+
+    array[6].each do |name, comment|
+      add_constant RDoc::Constant.new(name, nil, comment)
+    end
+
+    array[7].each do |name, comment|
+      add_include RDoc::Include.new(name, comment)
+    end
+
+    array[8].each do |type, visibilities|
+      visibilities.each do |visibility, methods|
+        @visibility = visibility
+
+        methods.each do |name|
+          method = RDoc::AnyMethod.new nil, name
+          method.singleton = true if type == 'class'
+          add_method method
+        end
+      end
+    end
+  end
+
+  ##
+  # Merges +class_module+ into this ClassModule
+
+  def merge class_module
+    if class_module.comment then
+      document = parse @comment
+
+      class_module.comment.parts.push(*document.parts)
+
+      @comment = class_module.comment
+    end
+
+    class_module.each_attribute do |attr|
+      if match = attributes.find { |a| a.name == attr.name } then
+        match.rw = [match.rw, attr.rw].compact.join
+      else
+        add_attribute attr
+      end
+    end
+
+    class_module.each_constant do |const|
+      add_constant const
+    end
+
+    class_module.each_include do |incl|
+      add_include incl
+    end
+
+    class_module.each_method do |meth|
+      add_method meth
+    end
+  end
+
   ##
   # Does this object represent a module?
 
@@ -65,9 +193,7 @@ class RDoc::ClassModule < RDoc::Context
   # object, returns the name if it is not known.
 
   def superclass
-    raise NoMethodError, "#{full_name} is a module" if module?
-
-    RDoc::TopLevel.find_class_named(@superclass) || @superclass
+    RDoc::TopLevel.find_class_named_from(@superclass, parent) || @superclass
   end
 
   ##