rdoc 3.12.2 → 4.0.0.preview2

data/lib/rdoc/context/section.rb

@@ -11,11 +11,18 @@ class RDoc::Context::Section
 
   include RDoc::Text
 
+  MARSHAL_VERSION = 0 # :nodoc:
+
   ##
   # Section comment
 
   attr_reader :comment
 
+  ##
+  # Section comments
+
+  attr_reader :comments
+
   ##
   # Context this Section lives in
 
@@ -38,8 +45,9 @@ class RDoc::Context::Section
     @@sequence.succ!
     @sequence = @@sequence.dup
 
-    @comment = nil
-    @comment = extract_comment comment if comment
+    @comments = []
+
+    add_comment comment
   end
 
   ##
@@ -50,30 +58,34 @@ class RDoc::Context::Section
   end
 
   ##
-  # Anchor reference for linking to this section
-
-  def aref
-    title = @title || '[untitled]'
-
-    CGI.escape(title).gsub('%', '-').sub(/^-/, '')
-  end
-
-  ##
-  # Appends +comment+ to the current comment separated by a rule.
+  # Adds +comment+ to this section
 
-  def comment= comment
+  def add_comment comment
     comment = extract_comment comment
 
     return if comment.empty?
 
-    if @comment then
-      # HACK should section comments get joined?
-      @comment.text += "\n# ---\n#{comment.text}"
+    case comment
+    when RDoc::Comment then
+      @comments << comment
+    when RDoc::Markup::Document then
+      @comments.concat comment.parts
+    when Array then
+      @comments.concat comment
     else
-      @comment = comment
+      raise TypeError, "unknown comment type: #{comment.inspect}"
     end
   end
 
+  ##
+  # Anchor reference for linking to this section
+
+  def aref
+    title = @title || '[untitled]'
+
+    CGI.escape(title).gsub('%', '-').sub(/^-/, '')
+  end
+
   ##
   # Extracts the comment for this section from the original comment block.
   # If the first line contains :section:, strip it and use the rest.
@@ -84,24 +96,106 @@ class RDoc::Context::Section
   #   # The body
 
   def extract_comment comment
-    if comment.text =~ /^#[ \t]*:section:.*\n/ then
-      start = $`
-      rest = $'
-
-      comment.text = if start.empty? then
-                       rest
-                     else
-                       rest.sub(/#{start.chomp}\Z/, '')
-                     end
+    case comment
+    when Array then
+      comment.map do |c|
+        extract_comment c
+      end
+    when nil
+      RDoc::Comment.new ''
+    when RDoc::Comment then
+      if comment.text =~ /^#[ \t]*:section:.*\n/ then
+        start = $`
+        rest = $'
+
+        comment.text = if start.empty? then
+                         rest
+                       else
+                         rest.sub(/#{start.chomp}\Z/, '')
+                       end
+      end
+
+      comment
+    when RDoc::Markup::Document then
+      comment
+    else
+      raise TypeError, "unknown comment #{comment.inspect}"
     end
-
-    comment
   end
 
   def inspect # :nodoc:
     "#<%s:0x%x %p>" % [self.class, object_id, title]
   end
 
+  ##
+  # The files comments in this section come from
+
+  def in_files
+    return [] if @comments.empty?
+
+    case @comments
+    when Array then
+      @comments.map do |comment|
+        comment.file
+      end
+    when RDoc::Markup::Document then
+      @comment.parts.map do |document|
+        document.file
+      end
+    else
+      raise RDoc::Error, "BUG: unknown comment class #{@comments.class}"
+    end
+  end
+
+  ##
+  # Serializes this Section.  The title and parsed comment are saved, but not
+  # the section parent which must be restored manually.
+
+  def marshal_dump
+    [
+      MARSHAL_VERSION,
+      @title,
+      parse,
+    ]
+  end
+
+  ##
+  # De-serializes this Section.  The section parent must be restored manually.
+
+  def marshal_load array
+    @parent  = nil
+
+    @title    = array[1]
+    @comments = array[2]
+  end
+
+  ##
+  # Parses +comment_location+ into an RDoc::Markup::Document composed of
+  # multiple RDoc::Markup::Documents with their file set.
+
+  def parse
+    case @comments
+    when String then
+      super
+    when Array then
+      docs = @comments.map do |comment, location|
+        doc = super comment
+        doc.file = location if location
+        doc
+      end
+
+      RDoc::Markup::Document.new(*docs)
+    when RDoc::Comment then
+      doc = super @comments.text, comments.format
+      doc.file = @comments.location
+      doc
+    when RDoc::Markup::Document then
+      return @comments
+    else
+      raise ArgumentError, "unknown comment class #{comments.class}"
+    end
+  end
+
   ##
   # The section's title, or 'Top Section' if the title is nil.
   #
@@ -111,6 +205,27 @@ class RDoc::Context::Section
     @title || 'Top Section'
   end
 
+  ##
+  # Removes a comment from this section if it is from the same file as
+  # +comment+
+
+  def remove_comment comment
+    return if @comments.empty?
+
+    case @comments
+    when Array then
+      @comments.delete_if do |my_comment|
+        my_comment.file == comment.file
+      end
+    when RDoc::Markup::Document then
+      @comments.parts.delete_if do |document|
+        document.file == comment.file.name
+      end
+    else
+      raise RDoc::Error, "BUG: unknown comment class #{@comments.class}"
+    end
+  end
+
   ##
   # Section sequence number (deprecated)
 

data/lib/rdoc/cross_reference.rb

@@ -27,69 +27,76 @@ class RDoc::CrossReference
   # have been suppressed, since the suppression characters are removed by the
   # code that is triggered.
 
-  CROSSREF_REGEXP = /(
-                      # A::B::C.meth
-                      #{CLASS_REGEXP_STR}(?:[.#]|::)#{METHOD_REGEXP_STR}
-
-                      # Stand-alone method (preceded by a #)
-                      | \\?\##{METHOD_REGEXP_STR}
-
-                      # Stand-alone method (preceded by ::)
-                      | ::#{METHOD_REGEXP_STR}
-
-                      # A::B::C
-                      # The stuff after CLASS_REGEXP_STR is a
-                      # nasty hack.  CLASS_REGEXP_STR unfortunately matches
-                      # words like dog and cat (these are legal "class"
-                      # names in Fortran 95).  When a word is flagged as a
-                      # potential cross-reference, limitations in the markup
-                      # engine suppress other processing, such as typesetting.
-                      # This is particularly noticeable for contractions.
-                      # In order that words like "can't" not
-                      # be flagged as potential cross-references, only
-                      # flag potential class cross-references if the character
-                      # after the cross-reference is a space, sentence
-                      # punctuation, tag start character, or attribute
-                      # marker.
-                      | #{CLASS_REGEXP_STR}(?=[@\s).?!,;<\000]|\z)
-
-                      # Things that look like filenames
-                      # The key thing is that there must be at least
-                      # one special character (period, slash, or
-                      # underscore).
-                      | (?:\.\.\/)*[-\/\w]+[_\/.][-\w\/.]+
-
-                      # Things that have markup suppressed
-                      # Don't process things like '\<' in \<tt>, though.
-                      # TODO: including < is a hack, not very satisfying.
-                      | \\[^\s<]
+  CROSSREF_REGEXP = /(?:^|\s)
+                     (
+                      (?:
+                       # A::B::C.meth
+                       #{CLASS_REGEXP_STR}(?:[.#]|::)#{METHOD_REGEXP_STR}
+
+                       # Stand-alone method (preceded by a #)
+                       | \\?\##{METHOD_REGEXP_STR}
+
+                       # Stand-alone method (preceded by ::)
+                       | ::#{METHOD_REGEXP_STR}
+
+                       # A::B::C
+                       # The stuff after CLASS_REGEXP_STR is a
+                       # nasty hack.  CLASS_REGEXP_STR unfortunately matches
+                       # words like dog and cat (these are legal "class"
+                       # names in Fortran 95).  When a word is flagged as a
+                       # potential cross-reference, limitations in the markup
+                       # engine suppress other processing, such as typesetting.
+                       # This is particularly noticeable for contractions.
+                       # In order that words like "can't" not
+                       # be flagged as potential cross-references, only
+                       # flag potential class cross-references if the character
+                       # after the cross-reference is a space, sentence
+                       # punctuation, tag start character, or attribute
+                       # marker.
+                       | #{CLASS_REGEXP_STR}(?=[@\s).?!,;<\000]|\z)
+
+                       # Things that look like filenames
+                       # The key thing is that there must be at least
+                       # one special character (period, slash, or
+                       # underscore).
+                       | (?:\.\.\/)*[-\/\w]+[_\/.][-\w\/.]+
+
+                       # Things that have markup suppressed
+                       # Don't process things like '\<' in \<tt>, though.
+                       # TODO: including < is a hack, not very satisfying.
+                       | \\[^\s<]
                       )
 
                       # labels for headings
-                      (?:@[\w+%-]+)?/x
+                      (?:@[\w+%-]+(?:\.[\w|%-]+)?)?
+                     )/x
 
   ##
   # Version of CROSSREF_REGEXP used when <tt>--hyperlink-all</tt> is specified.
 
-  ALL_CROSSREF_REGEXP = /(
-                      # A::B::C.meth
-                      #{CLASS_REGEXP_STR}(?:[.#]|::)#{METHOD_REGEXP_STR}
+  ALL_CROSSREF_REGEXP = /
+                     (?:^|\s)
+                     (
+                      (?:
+                       # A::B::C.meth
+                       #{CLASS_REGEXP_STR}(?:[.#]|::)#{METHOD_REGEXP_STR}
 
-                      # Stand-alone method
-                      | \\?#{METHOD_REGEXP_STR}
+                       # Stand-alone method
+                       | \\?#{METHOD_REGEXP_STR}
 
-                      # A::B::C
-                      | #{CLASS_REGEXP_STR}(?=[@\s).?!,;<\000]|\z)
+                       # A::B::C
+                       | #{CLASS_REGEXP_STR}(?=[@\s).?!,;<\000]|\z)
 
-                      # Things that look like filenames
-                      | (?:\.\.\/)*[-\/\w]+[_\/.][-\w\/.]+
+                       # Things that look like filenames
+                       | (?:\.\.\/)*[-\/\w]+[_\/.][-\w\/.]+
 
-                      # Things that have markup suppressed
-                      | \\[^\s<]
+                       # Things that have markup suppressed
+                       | \\[^\s<]
                       )
 
                       # labels for headings
-                      (?:@[\w+%-]+)?/x
+                      (?:@[\w+%-]+)?
+                     )/x
 
   ##
   # Hash of references that have been looked-up to their replacements
@@ -102,6 +109,7 @@ class RDoc::CrossReference
 
   def initialize context
     @context = context
+    @store   = context.store
 
     @seen = {}
   end
@@ -146,7 +154,7 @@ class RDoc::CrossReference
           end unless ref
 
     # Try a page name
-    ref = RDoc::TopLevel.page name if not ref and name =~ /^\w+$/
+    ref = @store.page name if not ref and name =~ /^\w+$/
 
     ref = nil if RDoc::Alias === ref # external alias, can't link to it
 

data/lib/rdoc/encoding.rb

@@ -25,26 +25,40 @@ module RDoc::Encoding
     RDoc::Encoding.set_encoding content
 
     if Object.const_defined? :Encoding then
-      encoding ||= Encoding.default_external
-      orig_encoding = content.encoding
-
-      if utf8 then
-        content.force_encoding Encoding::UTF_8
-        content.encode! encoding
-      else
-        # assume the content is in our output encoding
-        content.force_encoding encoding
-      end
-
-      unless content.valid_encoding? then
-        # revert and try to transcode
-        content.force_encoding orig_encoding
-        content.encode! encoding
-      end
-
-      unless content.valid_encoding? then
-        warn "unable to convert #{filename} to #{encoding}, skipping"
-        content = nil
+      begin
+        encoding ||= Encoding.default_external
+        orig_encoding = content.encoding
+
+        if utf8 then
+          content.force_encoding Encoding::UTF_8
+          content.encode! encoding
+        else
+          # assume the content is in our output encoding
+          content.force_encoding encoding
+        end
+
+        unless content.valid_encoding? then
+          # revert and try to transcode
+          content.force_encoding orig_encoding
+          content.encode! encoding
+        end
+
+        unless content.valid_encoding? then
+          warn "unable to convert #{filename} to #{encoding}, skipping"
+          content = nil
+        end
+      rescue Encoding::InvalidByteSequenceError,
+             Encoding::UndefinedConversionError => e
+        if force_transcode then
+          content.force_encoding orig_encoding
+          content.encode!(encoding,
+                          :invalid => :replace, :undef => :replace,
+                          :replace => '?')
+          return content
+        else
+          warn "unable to convert #{e.message} for #{filename}, skipping"
+          return nil
+        end
       end
     end
 
@@ -53,15 +67,6 @@ module RDoc::Encoding
     raise unless e.message =~ /unknown encoding name - (.*)/
     warn "unknown encoding name \"#{$1}\" for #{filename}, skipping"
     nil
-  rescue Encoding::UndefinedConversionError => e
-    if force_transcode then
-      content.force_encoding orig_encoding
-      content.encode! encoding, :undef => :replace, :replace => '?'
-      content
-    else
-      warn "unable to convert #{e.message} for #{filename}, skipping"
-      nil
-    end
   rescue Errno::EISDIR, Errno::ENOENT
     nil
   end

data/lib/rdoc/erb_partial.rb

@@ -0,0 +1,18 @@
+##
+# Allows an ERB template to be rendered in the context (binding) of an
+# existing ERB template evaluation.
+
+class RDoc::ERBPartial < ERB
+
+  ##
+  # Overrides +compiler+ startup to set the +eoutvar+ to an empty string only
+  # if it isn't already set.
+
+  def set_eoutvar compiler, eoutvar = '_erbout'
+    super
+
+    compiler.pre_cmd = ["#{eoutvar} ||= ''"]
+  end
+
+end
+