rdoc 6.2.1 → 6.3.3

data/lib/rdoc/markup/attr_span.rb

@@ -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
 
   ##

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/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/table.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+##
+# A section of table
+
+class RDoc::Markup::Table
+  attr_accessor :header, :align, :body
+
+  def initialize header, align, body
+    @header, @align, @body = header, align, body
+  end
+
+  def == other
+    self.class == other.class and
+      @header == other.header and
+      @align == other.align and
+      @body == other.body
+  end
+
+  def accept visitor
+    visitor.accept_table @header, @body, @align
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[Table: ', ']' do
+      q.group 2, '[Head: ', ']' do
+        q.seplist @header.zip(@align) do |text, align|
+          q.pp text
+          if align
+            q.text ":"
+            q.breakable
+            q.text align.to_s
+          end
+        end
+      end
+      q.breakable
+      q.group 2, '[Body: ', ']' do
+        q.seplist @body do |body|
+          q.group 2, '[', ']' do
+            q.seplist body do |text|
+              q.pp text
+            end
+          end
+        end
+      end
+    end
+  end
+end

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'
 

data/lib/rdoc/markup/to_html_crossref.rb

@@ -39,10 +39,18 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
     @hyperlink_all = @options.hyperlink_all
     @show_hash     = @options.show_hash
 
-    crossref_re = @hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
+    @cross_reference = RDoc::CrossReference.new @context
+  end
+
+  def init_link_notation_regexp_handlings
+    add_regexp_handling_RDOCLINK
+
+    # The crossref must be linked before tidylink because Klass.method[:sym]
+    # will be processed as a tidylink first and will be broken.
+    crossref_re = @options.hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
     @markup.add_regexp_handling crossref_re, :CROSSREF
 
-    @cross_reference = RDoc::CrossReference.new @context
+    add_regexp_handling_TIDYLINK
   end
 
   ##
@@ -54,7 +62,7 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
 
     name = name[1..-1] unless @show_hash if name[0, 1] == '#'
 
-    if name =~ /(.*[^#:])@/
+    if !(name.end_with?('+@', '-@')) and name =~ /(.*[^#:])@/
       text ||= "#{CGI.unescape $'} at <code>#{$1}</code>"
       code = false
     else
@@ -130,7 +138,7 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
   # Creates an HTML link to +name+ with the given +text+.
 
   def link name, text, code = true
-    if name =~ /(.*[^#:])@/ then
+    if !(name.end_with?('+@', '-@')) and name =~ /(.*[^#:])@/
       name = $1
       label = $'
     end
@@ -144,7 +152,7 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
       path = ref.as_href @from_path
 
       if code and RDoc::CodeObject === ref and !(RDoc::TopLevel === ref)
-        text = "<code>#{text}</code>"
+        text = "<code>#{CGI.escapeHTML text}</code>"
       end
 
       if path =~ /#/ then

data/lib/rdoc/markup/to_joined_paragraph.rb

@@ -41,6 +41,7 @@ class RDoc::Markup::ToJoinedParagraph < RDoc::Markup::Formatter
   alias accept_raw             ignore
   alias accept_rule            ignore
   alias accept_verbatim        ignore
+  alias accept_table           ignore
 
 end
 

data/lib/rdoc/markup/to_rdoc.rb

@@ -237,6 +237,34 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
     @res << "\n"
   end
 
+  ##
+  # Adds +table+ to the output
+
+  def accept_table header, body, aligns
+    widths = header.zip(body) do |h, b|
+      [h.size, b.size].max
+    end
+    aligns = aligns.map do |a|
+      case a
+      when nil
+        :center
+      when :left
+        :ljust
+      when :right
+        :rjust
+      end
+    end
+    @res << header.zip(widths, aligns) do |h, w, a|
+      h.__send__(a, w)
+    end.join("|").rstrip << "\n"
+    @res << widths.map {|w| "-" * w }.join("|") << "\n"
+    body.each do |row|
+      @res << row.zip(widths, aligns) do |t, w, a|
+        t.__send__(a, w)
+      end.join("|").rstrip << "\n"
+    end
+  end
+
   ##
   # Applies attribute-specific markup to +text+ using RDoc::AttributeManager
 

data/lib/rdoc/markup/to_table_of_contents.rb

@@ -82,6 +82,7 @@ class RDoc::Markup::ToTableOfContents < RDoc::Markup::Formatter
   alias accept_list_item_end   ignore
   alias accept_list_end_bullet ignore
   alias accept_list_start      ignore
+  alias accept_table           ignore
   # :startdoc:
 
 end

data/lib/rdoc/markup.rb

@@ -843,6 +843,7 @@ https://github.com/ruby/rdoc/issues
   autoload :List,                  'rdoc/markup/list'
   autoload :ListItem,              'rdoc/markup/list_item'
   autoload :Paragraph,             'rdoc/markup/paragraph'
+  autoload :Table,                 'rdoc/markup/table'
   autoload :Raw,                   'rdoc/markup/raw'
   autoload :Rule,                  'rdoc/markup/rule'
   autoload :Verbatim,              'rdoc/markup/verbatim'

data/lib/rdoc/options.rb

@@ -338,8 +338,9 @@ class RDoc::Options
 
   attr_reader :visibility
 
-  def initialize # :nodoc:
+  def initialize loaded_options = nil # :nodoc:
     init_ivars
+    override loaded_options if loaded_options
   end
 
   def init_ivars # :nodoc:
@@ -417,6 +418,37 @@ class RDoc::Options
     init_with map
   end
 
+  def override map # :nodoc:
+    if map.has_key?('encoding')
+      encoding = map['encoding']
+      @encoding = encoding ? Encoding.find(encoding) : encoding
+    end
+
+    @charset        = map['charset']        if map.has_key?('charset')
+    @exclude        = map['exclude']        if map.has_key?('exclude')
+    @generator_name = map['generator_name'] if map.has_key?('generator_name')
+    @hyperlink_all  = map['hyperlink_all']  if map.has_key?('hyperlink_all')
+    @line_numbers   = map['line_numbers']   if map.has_key?('line_numbers')
+    @locale_name    = map['locale_name']    if map.has_key?('locale_name')
+    @locale_dir     = map['locale_dir']     if map.has_key?('locale_dir')
+    @main_page      = map['main_page']      if map.has_key?('main_page')
+    @markup         = map['markup']         if map.has_key?('markup')
+    @op_dir         = map['op_dir']         if map.has_key?('op_dir')
+    @show_hash      = map['show_hash']      if map.has_key?('show_hash')
+    @tab_width      = map['tab_width']      if map.has_key?('tab_width')
+    @template_dir   = map['template_dir']   if map.has_key?('template_dir')
+    @title          = map['title']          if map.has_key?('title')
+    @visibility     = map['visibility']     if map.has_key?('visibility')
+    @webcvs         = map['webcvs']         if map.has_key?('webcvs')
+
+    if map.has_key?('rdoc_include')
+      @rdoc_include = sanitize_path map['rdoc_include']
+    end
+    if map.has_key?('static_path')
+      @static_path  = sanitize_path map['static_path']
+    end
+  end
+
   def == other # :nodoc:
     self.class === other and
       @encoding       == other.encoding       and
@@ -755,7 +787,7 @@ Usage: #{opt.program_name} [options] [names...]
 
       opt.on("--[no-]force-update", "-U",
              "Forces rdoc to scan all sources even if",
-             "newer than the flag file.") do |value|
+             "no files are newer than the flag file.") do |value|
         @force_update = value
       end
 

data/lib/rdoc/parser/c.rb

@@ -209,48 +209,6 @@ class RDoc::Parser::C < RDoc::Parser
     end
   end
 
-  ##
-  # Removes duplicate call-seq entries for methods using the same
-  # implementation.
-
-  def deduplicate_call_seq
-    @methods.each do |var_name, functions|
-      class_name = @known_classes[var_name]
-      next unless class_name
-      class_obj  = find_class var_name, class_name
-
-      functions.each_value do |method_names|
-        next if method_names.length == 1
-
-        method_names.each do |method_name|
-          deduplicate_method_name class_obj, method_name
-        end
-      end
-    end
-  end
-
-  ##
-  # If two ruby methods share a C implementation (and comment) this
-  # deduplicates the examples in the call_seq for the method to reduce
-  # confusion in the output.
-
-  def deduplicate_method_name class_obj, method_name # :nodoc:
-    return unless
-      method = class_obj.method_list.find { |m| m.name == method_name }
-    return unless call_seq = method.call_seq
-
-    method_name = method_name[0, 1] if method_name =~ /\A\[/
-
-    entries = call_seq.split "\n"
-
-    matching = entries.select do |entry|
-      entry =~ /^\w*\.?#{Regexp.escape method_name}/ or
-        entry =~ /\s#{Regexp.escape method_name}\s/
-    end
-
-    method.call_seq = matching.join "\n"
-  end
-
   ##
   # Scans #content for rb_define_alias
 
@@ -269,23 +227,29 @@ class RDoc::Parser::C < RDoc::Parser
       end
 
       class_obj = find_class var_name, class_name
-
-      al = RDoc::Alias.new '', old_name, new_name, ''
-      al.singleton = @singleton_classes.key? var_name
-
       comment = find_alias_comment var_name, new_name, old_name
-
       comment.normalize
-
-      al.comment = comment
-
-      al.record_location @top_level
-
-      class_obj.add_alias al
-      @stats.add_alias al
+      if comment.to_s.empty? and existing_method = class_obj.method_list.find { |m| m.name == old_name}
+        comment = existing_method.comment
+      end
+      add_alias(var_name, class_obj, old_name, new_name, comment)
     end
   end
 
+  ##
+  # Add alias, either from a direct alias definition, or from two
+  # method that reference the same function.
+
+  def add_alias(var_name, class_obj, old_name, new_name, comment)
+    al = RDoc::Alias.new '', old_name, new_name, ''
+    al.singleton = @singleton_classes.key? var_name
+    al.comment = comment
+    al.record_location @top_level
+    class_obj.add_alias al
+    @stats.add_alias al
+    al
+  end
+
   ##
   # Scans #content for rb_attr and rb_define_attr
 
@@ -354,7 +318,7 @@ class RDoc::Parser::C < RDoc::Parser
                 \s*"(?<module_name_1>\w+)"\s*
               \)
             |
-              _under\s*\( # rb_define_module_under(module_under, module_name_1)
+              _under\s*\( # rb_define_module_under(module_under, module_name_2)
                 \s*(?<module_under>\w+),
                 \s*"(?<module_name_2>\w+)"
               \s*\)
@@ -608,7 +572,7 @@ class RDoc::Parser::C < RDoc::Parser
       ((?>/\*.*?\*/\s*)?)
       ((?:(?:\w+)\s+)?
         (?:intern\s+)?VALUE\s+(\w+)
-        \s*(?:\([^)]*\))(?:[^;]|$))
+        \s*(?:\([^)]*\))(?:[^\);]|$))
     | ((?>/\*.*?\*/\s*))^\s*(\#\s*define\s+(\w+)\s+(\w+))
     | ^\s*\#\s*define\s+(\w+)\s+(\w+)
     }xm) do
@@ -1021,6 +985,10 @@ class RDoc::Parser::C < RDoc::Parser
 
     class_obj = find_class var_name, class_name
 
+    if existing_method = class_obj.method_list.find { |m| m.c_function == function }
+      add_alias(var_name, class_obj, existing_method.name, meth_name, existing_method.comment)
+    end
+
     if class_obj then
       if meth_name == 'initialize' then
         meth_name = 'new'
@@ -1249,8 +1217,6 @@ class RDoc::Parser::C < RDoc::Parser
     do_aliases
     do_attrs
 
-    deduplicate_call_seq
-
     @store.add_c_variables self
 
     @top_level