rdoc 6.1.2 → 6.3.1

data/lib/rdoc/markup/attribute_manager.rb

@@ -58,6 +58,10 @@ class RDoc::Markup::AttributeManager
 
   attr_reader :regexp_handlings
 
+  ##
+  # A bits of exclusive maps
+  attr_reader :exclusive_bitmap
+
   ##
   # Creates a new attribute manager that understands bold, emphasized and
   # teletype text.
@@ -68,17 +72,18 @@ class RDoc::Markup::AttributeManager
     @protectable = %w[<]
     @regexp_handlings = []
     @word_pair_map = {}
+    @exclusive_bitmap = 0
     @attributes = RDoc::Markup::Attributes.new
 
-    add_word_pair "*", "*", :BOLD
-    add_word_pair "_", "_", :EM
-    add_word_pair "+", "+", :TT
+    add_word_pair "*", "*", :BOLD, true
+    add_word_pair "_", "_", :EM, true
+    add_word_pair "+", "+", :TT, true
 
-    add_html "em", :EM
-    add_html "i",  :EM
-    add_html "b",  :BOLD
-    add_html "tt",   :TT
-    add_html "code", :TT
+    add_html "em", :EM, true
+    add_html "i",  :EM, true
+    add_html "b",  :BOLD, true
+    add_html "tt",   :TT, true
+    add_html "code", :TT, true
   end
 
   ##
@@ -122,29 +127,67 @@ class RDoc::Markup::AttributeManager
     res
   end
 
+  def exclusive?(attr)
+    (attr & @exclusive_bitmap) != 0
+  end
+
+  NON_PRINTING_START = "\1" # :nodoc:
+  NON_PRINTING_END = "\2" # :nodoc:
+
   ##
   # Map attributes like <b>text</b>to the sequence
   # \001\002<char>\001\003<char>, where <char> is a per-attribute specific
   # character
 
-  def convert_attrs(str, attrs)
+  def convert_attrs(str, attrs, exclusive = false)
+    convert_attrs_matching_word_pairs(str, attrs, exclusive)
+    convert_attrs_word_pair_map(str, attrs, exclusive)
+  end
+
+  def convert_attrs_matching_word_pairs(str, attrs, exclusive)
     # first do matching ones
-    tags = @matching_word_pairs.keys.join("")
+    tags = @matching_word_pairs.select { |start, bitmap|
+      if exclusive && exclusive?(bitmap)
+        true
+      elsif !exclusive && !exclusive?(bitmap)
+        true
+      else
+        false
+      end
+    }.keys
+    return if tags.empty?
+    all_tags = @matching_word_pairs.keys
 
-    re = /(^|\W)([#{tags}])([#\\]?[\w:.\/-]+?\S?)\2(\W|$)/
+    re = /(^|\W|[#{all_tags.join("")}])([#{tags.join("")}])(\2*[#\\]?[\w:.\/\[\]-]+?\S?)\2(?!\2)([#{all_tags.join("")}]|\W|$)/
 
-    1 while str.gsub!(re) do
+    1 while str.gsub!(re) { |orig|
       attr = @matching_word_pairs[$2]
-      attrs.set_attrs($`.length + $1.length + $2.length, $3.length, attr)
-      $1 + NULL * $2.length + $3 + NULL * $2.length + $4
-    end
+      attr_updated = attrs.set_attrs($`.length + $1.length + $2.length, $3.length, attr)
+      if attr_updated
+        $1 + NULL * $2.length + $3 + NULL * $2.length + $4
+      else
+        $1 + NON_PRINTING_START + $2 + NON_PRINTING_END + $3 + NON_PRINTING_START + $2 + NON_PRINTING_END + $4
+      end
+    }
+    str.delete!(NON_PRINTING_START + NON_PRINTING_END)
+  end
 
+  def convert_attrs_word_pair_map(str, attrs, exclusive)
     # then non-matching
     unless @word_pair_map.empty? then
       @word_pair_map.each do |regexp, attr|
-        str.gsub!(regexp) {
-          attrs.set_attrs($`.length + $1.length, $2.length, attr)
-          NULL * $1.length + $2 + NULL * $3.length
+        if !exclusive
+          next if exclusive?(attr)
+        else
+          next if !exclusive?(attr)
+        end
+        1 while str.gsub!(regexp) { |orig|
+          updated = attrs.set_attrs($`.length + $1.length, $2.length, attr)
+          if updated
+            NULL * $1.length + $2 + NULL * $3.length
+          else
+            orig
+          end
         }
       end
     end
@@ -153,10 +196,18 @@ class RDoc::Markup::AttributeManager
   ##
   # Converts HTML tags to RDoc attributes
 
-  def convert_html(str, attrs)
-    tags = @html_tags.keys.join '|'
+  def convert_html(str, attrs, exclusive = false)
+    tags = @html_tags.select { |start, bitmap|
+      if exclusive && exclusive?(bitmap)
+        true
+      elsif !exclusive && !exclusive?(bitmap)
+        true
+      else
+        false
+      end
+    }.keys.join '|'
 
-    1 while str.gsub!(/<(#{tags})>(.*?)<\/\1>/i) {
+    1 while str.gsub!(/<(#{tags})>(.*?)<\/\1>/i) { |orig|
       attr = @html_tags[$1.downcase]
       html_length = $1.length + 2
       seq = NULL * html_length
@@ -168,8 +219,13 @@ class RDoc::Markup::AttributeManager
   ##
   # Converts regexp handling sequences to RDoc attributes
 
-  def convert_regexp_handlings str, attrs
+  def convert_regexp_handlings str, attrs, exclusive = false
     @regexp_handlings.each do |regexp, attribute|
+      if exclusive
+        next if !exclusive?(attribute)
+      else
+        next if exclusive?(attribute)
+      end
       str.scan(regexp) do
         capture = $~.size == 1 ? 0 : 1
 
@@ -205,7 +261,7 @@ class RDoc::Markup::AttributeManager
   #
   #   am.add_word_pair '*', '*', :BOLD
 
-  def add_word_pair(start, stop, name)
+  def add_word_pair(start, stop, name, exclusive = false)
     raise ArgumentError, "Word flags may not start with '<'" if
       start[0,1] == '<'
 
@@ -220,6 +276,8 @@ class RDoc::Markup::AttributeManager
 
     @protectable << start[0,1]
     @protectable.uniq!
+
+    @exclusive_bitmap |= bitmap if exclusive
   end
 
   ##
@@ -228,8 +286,10 @@ class RDoc::Markup::AttributeManager
   #
   #   am.add_html 'em', :EM
 
-  def add_html(tag, name)
-    @html_tags[tag.downcase] = @attributes.bitmap_for name
+  def add_html(tag, name, exclusive = false)
+    bitmap = @attributes.bitmap_for name
+    @html_tags[tag.downcase] = bitmap
+    @exclusive_bitmap |= bitmap if exclusive
   end
 
   ##
@@ -238,8 +298,10 @@ class RDoc::Markup::AttributeManager
   #
   #   @am.add_regexp_handling(/((https?:)\S+\w)/, :HYPERLINK)
 
-  def add_regexp_handling pattern, name
-    @regexp_handlings << [pattern, @attributes.bitmap_for(name)]
+  def add_regexp_handling pattern, name, exclusive = false
+    bitmap = @attributes.bitmap_for(name)
+    @regexp_handlings << [pattern, bitmap]
+    @exclusive_bitmap |= bitmap if exclusive
   end
 
   ##
@@ -250,8 +312,11 @@ class RDoc::Markup::AttributeManager
 
     mask_protected_sequences
 
-    @attrs = RDoc::Markup::AttrSpan.new @str.length
+    @attrs = RDoc::Markup::AttrSpan.new @str.length, @exclusive_bitmap
 
+    convert_attrs            @str, @attrs, true
+    convert_html             @str, @attrs, true
+    convert_regexp_handlings @str, @attrs, true
     convert_attrs            @str, @attrs
     convert_html             @str, @attrs
     convert_regexp_handlings @str, @attrs

data/lib/rdoc/markup/formatter.rb

@@ -156,7 +156,7 @@ class RDoc::Markup::Formatter
       method_name = "handle_regexp_#{name}"
 
       if respond_to? method_name then
-        target.text = send method_name, target
+        target.text = public_send method_name, target
         handled = true
       end
     end

data/lib/rdoc/markup/parser.rb

@@ -80,10 +80,6 @@ class RDoc::Markup::Parser
     @binary_input   = nil
     @current_token  = nil
     @debug          = false
-    @input          = nil
-    @input_encoding = nil
-    @line           = 0
-    @line_pos       = 0
     @s              = nil
     @tokens         = []
   end
@@ -319,13 +315,6 @@ class RDoc::Markup::Parser
     verbatim
   end
 
-  ##
-  # The character offset for the input string at the given +byte_offset+
-
-  def char_pos byte_offset
-    @input.byteslice(0, byte_offset).length
-  end
-
   ##
   # Pulls the next token from the stream.
 
@@ -424,15 +413,53 @@ class RDoc::Markup::Parser
     token
   end
 
+  ##
+  # A simple wrapper of StringScanner that is aware of the current column and lineno
+
+  class MyStringScanner
+    def initialize(input)
+      @line = @column = 0
+      @s = StringScanner.new input
+    end
+
+    def scan(re)
+      ret = @s.scan(re)
+      @column += ret.length if ret
+      ret
+    end
+
+    def unscan(s)
+      @s.pos -= s.bytesize
+      @column -= s.length
+    end
+
+    def pos
+      [@column, @line]
+    end
+
+    def newline!
+      @column = 0
+      @line += 1
+    end
+
+    def eos?
+      @s.eos?
+    end
+
+    def matched
+      @s.matched
+    end
+
+    def [](i)
+      @s[i]
+    end
+  end
+
   ##
   # Creates the StringScanner
 
   def setup_scanner input
-    @line     = 0
-    @line_pos = 0
-    @input    = input.dup
-
-    @s = StringScanner.new input
+    @s = MyStringScanner.new input
   end
 
   ##
@@ -467,31 +494,30 @@ class RDoc::Markup::Parser
       @tokens << case
                  # [CR]LF => :NEWLINE
                  when @s.scan(/\r?\n/) then
-                   token = [:NEWLINE, @s.matched, *token_pos(pos)]
-                   @line_pos = char_pos @s.pos
-                   @line += 1
+                   token = [:NEWLINE, @s.matched, *pos]
+                   @s.newline!
                    token
                  # === text => :HEADER then :TEXT
                  when @s.scan(/(=+)(\s*)/) then
                    level = @s[1].length
-                   header = [:HEADER, level, *token_pos(pos)]
+                   header = [:HEADER, level, *pos]
 
                    if @s[2] =~ /^\r?\n/ then
-                     @s.pos -= @s[2].length
+                     @s.unscan(@s[2])
                      header
                    else
                      pos = @s.pos
                      @s.scan(/.*/)
                      @tokens << header
-                     [:TEXT, @s.matched.sub(/\r$/, ''), *token_pos(pos)]
+                     [:TEXT, @s.matched.sub(/\r$/, ''), *pos]
                    end
                  # --- (at least 3) and nothing else on the line => :RULE
                  when @s.scan(/(-{3,}) *\r?$/) then
-                   [:RULE, @s[1].length - 2, *token_pos(pos)]
+                   [:RULE, @s[1].length - 2, *pos]
                  # * or - followed by white space and text => :BULLET
                  when @s.scan(/([*-]) +(\S)/) then
-                   @s.pos -= @s[2].bytesize # unget \S
-                   [:BULLET, @s[1], *token_pos(pos)]
+                   @s.unscan(@s[2])
+                   [:BULLET, @s[1], *pos]
                  # A. text, a. text, 12. text => :UALPHA, :LALPHA, :NUMBER
                  when @s.scan(/([a-z]|\d+)\. +(\S)/i) then
                    # FIXME if tab(s), the column will be wrong
@@ -500,7 +526,7 @@ class RDoc::Markup::Parser
                    # before (and provide a check for that at least in debug
                    # mode)
                    list_label = @s[1]
-                   @s.pos -= @s[2].bytesize # unget \S
+                   @s.unscan(@s[2])
                    list_type =
                      case list_label
                      when /[a-z]/ then :LALPHA
@@ -509,24 +535,24 @@ class RDoc::Markup::Parser
                      else
                        raise ParseError, "BUG token #{list_label}"
                      end
-                   [list_type, list_label, *token_pos(pos)]
+                   [list_type, list_label, *pos]
                  # [text] followed by spaces or end of line => :LABEL
                  when @s.scan(/\[(.*?)\]( +|\r?$)/) then
-                   [:LABEL, @s[1], *token_pos(pos)]
+                   [:LABEL, @s[1], *pos]
                  # text:: followed by spaces or end of line => :NOTE
                  when @s.scan(/(.*?)::( +|\r?$)/) then
-                   [:NOTE, @s[1], *token_pos(pos)]
+                   [:NOTE, @s[1], *pos]
                  # >>> followed by end of line => :BLOCKQUOTE
                  when @s.scan(/>>> *(\w+)?$/) then
-                   [:BLOCKQUOTE, @s[1], *token_pos(pos)]
+                   [:BLOCKQUOTE, @s[1], *pos]
                  # anything else: :TEXT
                  else
                    @s.scan(/(.*?)(  )?\r?$/)
-                   token = [:TEXT, @s[1], *token_pos(pos)]
+                   token = [:TEXT, @s[1], *pos]
 
                    if @s[2] then
                      @tokens << token
-                     [:BREAK, @s[2], *token_pos(pos + @s[1].length)]
+                     [:BREAK, @s[2], pos[0] + @s[1].length, pos[1]]
                    else
                      token
                    end
@@ -536,16 +562,6 @@ class RDoc::Markup::Parser
     self
   end
 
-  ##
-  # Calculates the column (by character) and line of the current token based
-  # on +byte_offset+.
-
-  def token_pos byte_offset
-    offset = char_pos byte_offset
-
-    [offset - @line_pos, @line]
-  end
-
   ##
   # Returns the current token to the token stream
 

data/lib/rdoc/markup/pre_process.rb

@@ -178,7 +178,7 @@ class RDoc::Markup::PreProcess
 
       blankline
     when 'include' then
-      filename = param.split.first
+      filename = param.split(' ', 2).first
       include_file filename, prefix, encoding
     when 'main' then
       @options.main_page = param if @options.respond_to? :main_page

data/lib/rdoc/markup/to_html.rb

@@ -52,12 +52,7 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     @th = nil
     @hard_break = "<br>\n"
 
-    # external links
-    @markup.add_regexp_handling(/(?:link:|https?:|mailto:|ftp:|irc:|www\.)\S+\w/,
-                                :HYPERLINK)
-
-    add_regexp_handling_RDOCLINK
-    add_regexp_handling_TIDYLINK
+    init_regexp_handlings
 
     init_tags
   end
@@ -66,6 +61,24 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
   #
   # These methods are used by regexp handling markup added by RDoc::Markup#add_regexp_handling.
 
+  ##
+  # Adds regexp handlings.
+
+  def init_regexp_handlings
+    # external links
+    @markup.add_regexp_handling(/(?:link:|https?:|mailto:|ftp:|irc:|www\.)\S+\w/,
+                                :HYPERLINK)
+    init_link_notation_regexp_handlings
+  end
+
+  ##
+  # Adds regexp handlings about link notations.
+
+  def init_link_notation_regexp_handlings
+    add_regexp_handling_RDOCLINK
+    add_regexp_handling_TIDYLINK
+  end
+
   def handle_RDOCLINK url # :nodoc:
     case url
     when /^rdoc-ref:/
@@ -301,6 +314,29 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     @res << raw.parts.join("\n")
   end
 
+  ##
+  # Adds +table+ to the output
+
+  def accept_table header, body, aligns
+    @res << "\n<table role=\"table\">\n<thead>\n<tr>\n"
+    header.zip(aligns) do |text, align|
+      @res << '<th'
+      @res << ' align="' << align << '"' if align
+      @res << '>' << CGI.escapeHTML(text) << "</th>\n"
+    end
+    @res << "</tr>\n</thead>\n<tbody>\n"
+    body.each do |row|
+      @res << "<tr>\n"
+      row.zip(aligns) do |text, align|
+        @res << '<td'
+        @res << ' align="' << align << '"' if align
+        @res << '>' << CGI.escapeHTML(text) << "</td>\n"
+      end
+      @res << "</tr>\n"
+    end
+    @res << "</tbody>\n</table>\n"
+  end
+
   # :section: Utilities
 
   ##
@@ -321,6 +357,10 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
        url =~ /\.(gif|png|jpg|jpeg|bmp)$/ then
       "<img src=\"#{url}\" />"
     else
+      if scheme != 'link' and /\.(?:rb|rdoc|md)\z/i =~ url
+        url = url.sub(%r%\A([./]*)(.*)\z%) { "#$1#{$2.tr('.', '_')}.html" }
+      end
+
       text = text.sub %r%^#{scheme}:/*%i, ''
       text = text.sub %r%^[*\^](\d+)$%,   '\1'