rdoc 5.1.0 → 6.13.1

data/lib/rdoc/markup/attr_changer.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 class RDoc::Markup
 
   AttrChanger = Struct.new :turn_on, :turn_off # :nodoc:
@@ -20,4 +20,3 @@ class RDoc::Markup::AttrChanger
   end
 
 end
-

data/lib/rdoc/markup/attr_span.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # An array of attributes which parallels the characters in a string.
 
@@ -7,16 +7,22 @@ class RDoc::Markup::AttrSpan
   ##
   # Creates a new AttrSpan for +length+ characters
 
-  def initialize(length)
+  def initialize(length, exclusive)
     @attrs = Array.new(length, 0)
+    @exclusive = exclusive
   end
 
   ##
   # Toggles +bits+ from +start+ to +length+
   def set_attrs(start, length, bits)
+    updated = false
     for i in start ... (start+length)
-      @attrs[i] |= bits
+      if (@exclusive & @attrs[i]) == 0 || (@exclusive & bits) != 0
+        @attrs[i] |= bits
+        updated = true
+      end
     end
+    updated
   end
 
   ##
@@ -27,4 +33,3 @@ class RDoc::Markup::AttrSpan
   end
 
 end
-

data/lib/rdoc/markup/attribute_manager.rb

@@ -1,8 +1,19 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
+
 ##
 # Manages changes of attributes in a block of text
 
 class RDoc::Markup::AttributeManager
+  unless ::MatchData.method_defined?(:match_length)
+    using ::Module.new {
+      refine(::MatchData) {
+        def match_length(nth) # :nodoc:
+          b, e = offset(nth)
+          e - b if b
+        end
+      }
+    }
+  end
 
   ##
   # The NUL character
@@ -53,10 +64,14 @@ class RDoc::Markup::AttributeManager
   attr_reader :protectable
 
   ##
-  # And this maps _special_ sequences to a name. A special sequence is
-  # something like a WikiWord
+  # And this maps _regexp handling_ sequences to a name. A regexp handling
+  # sequence is something like a WikiWord
+
+  attr_reader :regexp_handlings
 
-  attr_reader :special
+  ##
+  # A bits of exclusive maps
+  attr_reader :exclusive_bitmap
 
   ##
   # Creates a new attribute manager that understands bold, emphasized and
@@ -66,19 +81,20 @@ class RDoc::Markup::AttributeManager
     @html_tags = {}
     @matching_word_pairs = {}
     @protectable = %w[<]
-    @special = []
+    @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 +138,63 @@ class RDoc::Markup::AttributeManager
     res
   end
 
+  # :nodoc:
+  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)
-    # first do matching ones
-    tags = @matching_word_pairs.keys.join("")
-
-    re = /(^|\W)([#{tags}])([#\\]?[\w:.\/-]+?\S?)\2(\W|$)/
+  def convert_attrs(str, attrs, exclusive = false)
+    convert_attrs_matching_word_pairs(str, attrs, exclusive)
+    convert_attrs_word_pair_map(str, attrs, exclusive)
+  end
 
-    1 while str.gsub!(re) do
-      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
+  # :nodoc:
+  def convert_attrs_matching_word_pairs(str, attrs, exclusive)
+    # first do matching ones
+    tags = @matching_word_pairs.select { |start, bitmap|
+      exclusive == exclusive?(bitmap)
+    }.keys
+    return if tags.empty?
+    tags = "[#{tags.join("")}](?!#{PROTECT_ATTR})"
+    all_tags = "[#{@matching_word_pairs.keys.join("")}](?!#{PROTECT_ATTR})"
+
+    re = /(?:^|\W|#{all_tags})\K(#{tags})(\1*[#\\]?[\w:#{PROTECT_ATTR}.\/\[\]-]+?\S?)\1(?!\1)(?=#{all_tags}|\W|$)/
+
+    1 while str.gsub!(re) { |orig|
+      a, w = (m = $~).values_at(1, 2)
+      attr = @matching_word_pairs[a]
+      if attrs.set_attrs(m.begin(2), w.length, attr)
+        a = NULL * a.length
+      else
+        a = NON_PRINTING_START + a + NON_PRINTING_END
+      end
+      a + w + a
+    }
+    str.delete!(NON_PRINTING_START + NON_PRINTING_END)
+  end
 
+  # :nodoc:
+  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
+        next unless exclusive == exclusive?(attr)
+        1 while str.gsub!(regexp) { |orig|
+          w = (m = ($~))[2]
+          updated = attrs.set_attrs(m.begin(2), w.length, attr)
+          if updated
+            NULL * m.match_length(1) + w + NULL * m.match_length(3)
+          else
+            orig
+          end
         }
       end
     end
@@ -153,35 +203,38 @@ 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|
+      exclusive == exclusive?(bitmap)
+    }.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
+      html_length = $~.match_length(1) + 2 # "<>".length
       seq = NULL * html_length
-      attrs.set_attrs($`.length + html_length, $2.length, attr)
+      attrs.set_attrs($~.begin(2), $~.match_length(2), attr)
       seq + $2 + seq + NULL
     }
   end
 
   ##
-  # Converts special sequences to RDoc attributes
+  # Converts regexp handling sequences to RDoc attributes
 
-  def convert_specials str, attrs
-    @special.each do |regexp, attribute|
+  def convert_regexp_handlings str, attrs, exclusive = false
+    @regexp_handlings.each do |regexp, attribute|
+      next unless exclusive == exclusive?(attribute)
       str.scan(regexp) do
         capture = $~.size == 1 ? 0 : 1
 
         s, e = $~.offset capture
 
-        attrs.set_attrs s, e - s, attribute | @attributes.special
+        attrs.set_attrs s, e - s, attribute | @attributes.regexp_handling
       end
     end
   end
 
   ##
-  # Escapes special sequences of text to prevent conversion to RDoc
+  # Escapes regexp handling sequences of text to prevent conversion to RDoc
 
   def mask_protected_sequences
     # protect __send__, __FILE__, etc.
@@ -193,7 +246,7 @@ class RDoc::Markup::AttributeManager
   end
 
   ##
-  # Unescapes special sequences of text
+  # Unescapes regexp handling sequences of text
 
   def unmask_protected_sequences
     @str.gsub!(/(.)#{PROTECT_ATTR}/, "\\1\000")
@@ -205,9 +258,9 @@ 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] == '<'
+      start[0, 1] == '<'
 
     bitmap = @attributes.bitmap_for name
 
@@ -218,8 +271,10 @@ class RDoc::Markup::AttributeManager
       @word_pair_map[pattern] = bitmap
     end
 
-    @protectable << start[0,1]
+    @protectable << start[0, 1]
     @protectable.uniq!
+
+    @exclusive_bitmap |= bitmap if exclusive
   end
 
   ##
@@ -228,33 +283,40 @@ 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
 
   ##
-  # Adds a special handler for +pattern+ with +name+.  A simple URL handler
+  # Adds a regexp handling for +pattern+ with +name+.  A simple URL handler
   # would be:
   #
-  #   @am.add_special(/((https?:)\S+\w)/, :HYPERLINK)
+  #   @am.add_regexp_handling(/((https?:)\S+\w)/, :HYPERLINK)
 
-  def add_special pattern, name
-    @special << [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
 
   ##
-  # Processes +str+ converting attributes, HTML and specials
+  # Processes +str+ converting attributes, HTML and regexp handlings
 
   def flow str
-    @str = str
+    @str = str.dup
 
     mask_protected_sequences
 
-    @attrs = RDoc::Markup::AttrSpan.new @str.length
+    @attrs = RDoc::Markup::AttrSpan.new @str.length, @exclusive_bitmap
 
-    convert_attrs    @str, @attrs
-    convert_html     @str, @attrs
-    convert_specials @str, @attrs
+    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
 
     unmask_protected_sequences
 
@@ -312,12 +374,12 @@ class RDoc::Markup::AttributeManager
         res << change_attribute(current_attr, new_attr)
         current_attr = new_attr
 
-        if (current_attr & @attributes.special) != 0 then
+        if (current_attr & @attributes.regexp_handling) != 0 then
           i += 1 while
-            i < str_len and (@attrs[i] & @attributes.special) != 0
+            i < str_len and (@attrs[i] & @attributes.regexp_handling) != 0
 
-          res << RDoc::Markup::Special.new(current_attr,
-                                           copy_string(start_pos, i))
+          res << RDoc::Markup::RegexpHandling.new(current_attr,
+                                                  copy_string(start_pos, i))
           start_pos = i
           next
         end
@@ -341,4 +403,3 @@ class RDoc::Markup::AttributeManager
   end
 
 end
-

data/lib/rdoc/markup/attributes.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # We manage a set of attributes.  Each attribute has a symbol name and a bit
 # value.
@@ -6,21 +6,21 @@
 class RDoc::Markup::Attributes
 
   ##
-  # The special attribute type.  See RDoc::Markup#add_special
+  # The regexp handling attribute type. See RDoc::Markup#add_regexp_handling
 
-  attr_reader :special
+  attr_reader :regexp_handling
 
   ##
   # Creates a new attributes set.
 
   def initialize
-    @special = 1
+    @regexp_handling = 1
 
     @name_to_bitmap = [
-      [:_SPECIAL_, @special],
+      [:_REGEXP_HANDLING_, @regexp_handling],
     ]
 
-    @next_bitmap = @special << 1
+    @next_bitmap = @regexp_handling << 1
   end
 
   ##
@@ -61,11 +61,10 @@ class RDoc::Markup::Attributes
     return enum_for __method__, bitmap unless block_given?
 
     @name_to_bitmap.each do |name, bit|
-      next if bit == @special
+      next if bit == @regexp_handling
 
       yield name.to_s if (bitmap & bit) != 0
     end
   end
 
 end
-

data/lib/rdoc/markup/blank_line.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # An empty line.  This class is a singleton.
 
@@ -25,4 +25,3 @@ class RDoc::Markup::BlankLine
   end
 
 end
-

data/lib/rdoc/markup/block_quote.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A quoted section which contains markup items.
 
@@ -12,4 +12,3 @@ class RDoc::Markup::BlockQuote < RDoc::Markup::Raw
   end
 
 end
-

data/lib/rdoc/markup/document.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A Document containing lists, headings, paragraphs, etc.
 
@@ -162,4 +162,3 @@ class RDoc::Markup::Document
   end
 
 end
-

data/lib/rdoc/markup/formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # Base class for RDoc markup formatters
 #
@@ -50,7 +50,7 @@ class RDoc::Markup::Formatter
 
     @markup = markup || RDoc::Markup.new
     @am     = @markup.attribute_manager
-    @am.add_special(/<br>/, :HARD_BREAK)
+    @am.add_regexp_handling(/<br>/, :HARD_BREAK)
 
     @attributes = @am.attributes
 
@@ -78,23 +78,24 @@ class RDoc::Markup::Formatter
   end
 
   ##
-  # Adds a special for links of the form rdoc-...:
+  # Adds a regexp handling for links of the form rdoc-...:
 
-  def add_special_RDOCLINK
-    @markup.add_special(/rdoc-[a-z]+:[^\s\]]+/, :RDOCLINK)
+  def add_regexp_handling_RDOCLINK
+    @markup.add_regexp_handling(/rdoc-[a-z]+:[^\s\]]+/, :RDOCLINK)
   end
 
   ##
-  # Adds a special for links of the form {<text>}[<url>] and <word>[<url>]
+  # Adds a regexp handling for links of the form {<text>}[<url>] and
+  # <word>[<url>]
 
-  def add_special_TIDYLINK
-    @markup.add_special(/(?:
-                          \{.*?\} |    # multi-word label
-                          \b[^\s{}]+? # single-word label
-                         )
+  def add_regexp_handling_TIDYLINK
+    @markup.add_regexp_handling(/(?:
+                                  \{[^{}]*\} | # multi-word label
+                                  \b[^\s{}]+? # single-word label
+                                 )
 
-                         \[\S+?\]     # link target
-                        /x, :TIDYLINK)
+                                 \[\S+?\]     # link target
+                                /x, :TIDYLINK)
   end
 
   ##
@@ -133,8 +134,8 @@ class RDoc::Markup::Formatter
       when RDoc::Markup::AttrChanger then
         off_tags res, item
         on_tags res, item
-      when RDoc::Markup::Special then
-        res << convert_special(item)
+      when RDoc::Markup::RegexpHandling then
+        res << convert_regexp_handling(item)
       else
         raise "Unknown flow element: #{item.inspect}"
       end
@@ -144,29 +145,29 @@ class RDoc::Markup::Formatter
   end
 
   ##
-  # Converts added specials.  See RDoc::Markup#add_special
+  # Converts added regexp handlings. See RDoc::Markup#add_regexp_handling
 
-  def convert_special special
-    return special.text if in_tt?
+  def convert_regexp_handling target
+    return target.text if in_tt?
 
     handled = false
 
-    @attributes.each_name_of special.type do |name|
-      method_name = "handle_special_#{name}"
+    @attributes.each_name_of target.type do |name|
+      method_name = "handle_regexp_#{name}"
 
       if respond_to? method_name then
-        special.text = send method_name, special
+        target.text = public_send method_name, target
         handled = true
       end
     end
 
     unless handled then
-      special_name = @attributes.as_string special.type
+      target_name = @attributes.as_string target.type
 
-      raise RDoc::Error, "Unhandled special #{special_name}: #{special}"
+      raise RDoc::Error, "Unhandled regexp handling #{target_name}: #{target}"
     end
 
-    special.text
+    target.text
   end
 
   ##
@@ -194,18 +195,20 @@ class RDoc::Markup::Formatter
     @in_tt > 0
   end
 
+  def tt_tag? attr_mask, reverse = false
+    each_attr_tag(attr_mask, reverse) do |tag|
+      return true if tt? tag
+    end
+    false
+  end
+
   ##
   # Turns on tags for +item+ on +res+
 
   def on_tags res, item
-    attr_mask = item.turn_on
-    return if attr_mask.zero?
-
-    @attr_tags.each do |tag|
-      if attr_mask & tag.bit != 0 then
-        res << annotate(tag.on)
-        @in_tt += 1 if tt? tag
-      end
+    each_attr_tag(item.turn_on) do |tag|
+      res << annotate(tag.on)
+      @in_tt += 1 if tt? tag
     end
   end
 
@@ -213,13 +216,18 @@ class RDoc::Markup::Formatter
   # Turns off tags for +item+ on +res+
 
   def off_tags res, item
-    attr_mask = item.turn_off
+    each_attr_tag(item.turn_off, true) do |tag|
+      @in_tt -= 1 if tt? tag
+      res << annotate(tag.off)
+    end
+  end
+
+  def each_attr_tag attr_mask, reverse = false
     return if attr_mask.zero?
 
-    @attr_tags.reverse_each do |tag|
+    @attr_tags.public_send(reverse ? :reverse_each : :each) do |tag|
       if attr_mask & tag.bit != 0 then
-        @in_tt -= 1 if tt? tag
-        res << annotate(tag.off)
+        yield tag
       end
     end
   end
@@ -262,4 +270,3 @@ class RDoc::Markup::Formatter
   end
 
 end
-

data/lib/rdoc/markup/hard_break.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A hard-break in the middle of a paragraph.
 
@@ -29,4 +29,3 @@ class RDoc::Markup::HardBreak
   end
 
 end
-

data/lib/rdoc/markup/heading.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A heading with a level (1-6) and text
 
@@ -23,12 +23,12 @@ RDoc::Markup::Heading =
     return @to_html if @to_html
 
     markup = RDoc::Markup.new
-    markup.add_special RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
+    markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
 
     @to_html = RDoc::Markup::ToHtml.new nil
 
-    def @to_html.handle_special_CROSSREF special
-      special.text.sub(/^\\/, '')
+    def @to_html.handle_regexp_CROSSREF target
+      target.text.sub(/^\\/, '')
     end
 
     @to_html
@@ -66,7 +66,13 @@ RDoc::Markup::Heading =
   # element.
 
   def plain_html
-    self.class.to_html.to_html(text.dup)
+    text = self.text.dup
+
+    if matched = text.match(/rdoc-image:[^:]+:(.*)/)
+      text = matched[1]
+    end
+
+    self.class.to_html.to_html(text)
   end
 
   def pretty_print q # :nodoc:
@@ -76,4 +82,3 @@ RDoc::Markup::Heading =
   end
 
 end
-

data/lib/rdoc/markup/include.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A file included at generation time.  Objects of this class are created by
 # RDoc::RD for an extension-less include.
@@ -40,4 +40,3 @@ class RDoc::Markup::Include
   end
 
 end
-

data/lib/rdoc/markup/indented_paragraph.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # An Indented Paragraph of text
 
@@ -45,4 +45,3 @@ class RDoc::Markup::IndentedParagraph < RDoc::Markup::Raw
   end
 
 end
-

data/lib/rdoc/markup/list.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A List is a homogeneous set of ListItems.
 #
@@ -99,4 +99,3 @@ class RDoc::Markup::List
   end
 
 end
-

data/lib/rdoc/markup/list_item.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # An item within a List that contains paragraphs, headings, etc.
 #
@@ -97,4 +97,3 @@ class RDoc::Markup::ListItem
   end
 
 end
-