gitlab-rdoc 6.3.2

data/lib/rdoc/markup/attributes.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+##
+# We manage a set of attributes.  Each attribute has a symbol name and a bit
+# value.
+
+class RDoc::Markup::Attributes
+
+  ##
+  # The regexp handling attribute type. See RDoc::Markup#add_regexp_handling
+
+  attr_reader :regexp_handling
+
+  ##
+  # Creates a new attributes set.
+
+  def initialize
+    @regexp_handling = 1
+
+    @name_to_bitmap = [
+      [:_REGEXP_HANDLING_, @regexp_handling],
+    ]
+
+    @next_bitmap = @regexp_handling << 1
+  end
+
+  ##
+  # Returns a unique bit for +name+
+
+  def bitmap_for name
+    bitmap = @name_to_bitmap.assoc name
+
+    unless bitmap then
+      bitmap = @next_bitmap
+      @next_bitmap <<= 1
+      @name_to_bitmap << [name, bitmap]
+    else
+      bitmap = bitmap.last
+    end
+
+    bitmap
+  end
+
+  ##
+  # Returns a string representation of +bitmap+
+
+  def as_string bitmap
+    return 'none' if bitmap.zero?
+    res = []
+
+    @name_to_bitmap.each do |name, bit|
+      res << name if (bitmap & bit) != 0
+    end
+
+    res.join ','
+  end
+
+  ##
+  # yields each attribute name in +bitmap+
+
+  def each_name_of bitmap
+    return enum_for __method__, bitmap unless block_given?
+
+    @name_to_bitmap.each do |name, bit|
+      next if bit == @regexp_handling
+
+      yield name.to_s if (bitmap & bit) != 0
+    end
+  end
+
+end
+

data/lib/rdoc/markup/blank_line.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+##
+# An empty line.  This class is a singleton.
+
+class RDoc::Markup::BlankLine
+
+  @instance = new
+
+  ##
+  # RDoc::Markup::BlankLine is a singleton
+
+  def self.new
+    @instance
+  end
+
+  ##
+  # Calls #accept_blank_line on +visitor+
+
+  def accept visitor
+    visitor.accept_blank_line self
+  end
+
+  def pretty_print q # :nodoc:
+    q.text 'blankline'
+  end
+
+end
+

data/lib/rdoc/markup/block_quote.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+##
+# A quoted section which contains markup items.
+
+class RDoc::Markup::BlockQuote < RDoc::Markup::Raw
+
+  ##
+  # Calls #accept_block_quote on +visitor+
+
+  def accept visitor
+    visitor.accept_block_quote self
+  end
+
+end
+

data/lib/rdoc/markup/document.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+##
+# A Document containing lists, headings, paragraphs, etc.
+
+class RDoc::Markup::Document
+
+  include Enumerable
+
+  ##
+  # The file this document was created from.  See also
+  # RDoc::ClassModule#add_comment
+
+  attr_reader :file
+
+  ##
+  # If a heading is below the given level it will be omitted from the
+  # table_of_contents
+
+  attr_accessor :omit_headings_below
+
+  ##
+  # The parts of the Document
+
+  attr_reader :parts
+
+  ##
+  # Creates a new Document with +parts+
+
+  def initialize *parts
+    @parts = []
+    @parts.concat parts
+
+    @file = nil
+    @omit_headings_from_table_of_contents_below = nil
+  end
+
+  ##
+  # Appends +part+ to the document
+
+  def << part
+    case part
+    when RDoc::Markup::Document then
+      unless part.empty? then
+        parts.concat part.parts
+        parts << RDoc::Markup::BlankLine.new
+      end
+    when String then
+      raise ArgumentError,
+            "expected RDoc::Markup::Document and friends, got String" unless
+        part.empty?
+    else
+      parts << part
+    end
+  end
+
+  def == other # :nodoc:
+    self.class == other.class and
+      @file == other.file and
+      @parts == other.parts
+  end
+
+  ##
+  # Runs this document and all its #items through +visitor+
+
+  def accept visitor
+    visitor.start_accepting
+
+    visitor.accept_document self
+
+    visitor.end_accepting
+  end
+
+  ##
+  # Concatenates the given +parts+ onto the document
+
+  def concat parts
+    self.parts.concat parts
+  end
+
+  ##
+  # Enumerator for the parts of this document
+
+  def each &block
+    @parts.each(&block)
+  end
+
+  ##
+  # Does this document have no parts?
+
+  def empty?
+    @parts.empty? or (@parts.length == 1 and merged? and @parts.first.empty?)
+  end
+
+  ##
+  # The file this Document was created from.
+
+  def file= location
+    @file = case location
+            when RDoc::TopLevel then
+              location.relative_name
+            else
+              location
+            end
+  end
+
+  ##
+  # When this is a collection of documents (#file is not set and this document
+  # contains only other documents as its direct children) #merge replaces
+  # documents in this class with documents from +other+ when the file matches
+  # and adds documents from +other+ when the files do not.
+  #
+  # The information in +other+ is preferred over the receiver
+
+  def merge other
+    if empty? then
+      @parts = other.parts
+      return self
+    end
+
+    other.parts.each do |other_part|
+      self.parts.delete_if do |self_part|
+        self_part.file and self_part.file == other_part.file
+      end
+
+      self.parts << other_part
+    end
+
+    self
+  end
+
+  ##
+  # Does this Document contain other Documents?
+
+  def merged?
+    RDoc::Markup::Document === @parts.first
+  end
+
+  def pretty_print q # :nodoc:
+    start = @file ? "[doc (#{@file}): " : '[doc: '
+
+    q.group 2, start, ']' do
+      q.seplist @parts do |part|
+        q.pp part
+      end
+    end
+  end
+
+  ##
+  # Appends +parts+ to the document
+
+  def push *parts
+    self.parts.concat parts
+  end
+
+  ##
+  # Returns an Array of headings in the document.
+  #
+  # Require 'rdoc/markup/formatter' before calling this method.
+
+  def table_of_contents
+    accept RDoc::Markup::ToTableOfContents.to_toc
+  end
+
+end
+

data/lib/rdoc/markup/formatter.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+##
+# Base class for RDoc markup formatters
+#
+# Formatters are a visitor that converts an RDoc::Markup tree (from a comment)
+# into some kind of output.  RDoc ships with formatters for converting back to
+# rdoc, ANSI text, HTML, a Table of Contents and other formats.
+#
+# If you'd like to write your own Formatter use
+# RDoc::Markup::FormatterTestCase.  If you're writing a text-output formatter
+# use RDoc::Markup::TextFormatterTestCase which provides extra test cases.
+
+class RDoc::Markup::Formatter
+
+  ##
+  # Tag for inline markup containing a +bit+ for the bitmask and the +on+ and
+  # +off+ triggers.
+
+  InlineTag = Struct.new(:bit, :on, :off)
+
+  ##
+  # Converts a target url to one that is relative to a given path
+
+  def self.gen_relative_url path, target
+    from        = File.dirname path
+    to, to_file = File.split target
+
+    from = from.split "/"
+    to   = to.split "/"
+
+    from.delete '.'
+    to.delete '.'
+
+    while from.size > 0 and to.size > 0 and from[0] == to[0] do
+      from.shift
+      to.shift
+    end
+
+    from.fill ".."
+    from.concat to
+    from << to_file
+    File.join(*from)
+  end
+
+  ##
+  # Creates a new Formatter
+
+  def initialize options, markup = nil
+    @options = options
+
+    @markup = markup || RDoc::Markup.new
+    @am     = @markup.attribute_manager
+    @am.add_regexp_handling(/<br>/, :HARD_BREAK)
+
+    @attributes = @am.attributes
+
+    @attr_tags = []
+
+    @in_tt = 0
+    @tt_bit = @attributes.bitmap_for :TT
+
+    @hard_break = ''
+    @from_path = '.'
+  end
+
+  ##
+  # Adds +document+ to the output
+
+  def accept_document document
+    document.parts.each do |item|
+      case item
+      when RDoc::Markup::Document then # HACK
+        accept_document item
+      else
+        item.accept self
+      end
+    end
+  end
+
+  ##
+  # Adds a regexp handling for links of the form rdoc-...:
+
+  def add_regexp_handling_RDOCLINK
+    @markup.add_regexp_handling(/rdoc-[a-z]+:[^\s\]]+/, :RDOCLINK)
+  end
+
+  ##
+  # Adds a regexp handling for links of the form {<text>}[<url>] and
+  # <word>[<url>]
+
+  def add_regexp_handling_TIDYLINK
+    @markup.add_regexp_handling(/(?:
+                                  \{.*?\} |    # multi-word label
+                                  \b[^\s{}]+? # single-word label
+                                 )
+
+                                 \[\S+?\]     # link target
+                                /x, :TIDYLINK)
+  end
+
+  ##
+  # Add a new set of tags for an attribute. We allow separate start and end
+  # tags for flexibility
+
+  def add_tag(name, start, stop)
+    attr = @attributes.bitmap_for name
+    @attr_tags << InlineTag.new(attr, start, stop)
+  end
+
+  ##
+  # Allows +tag+ to be decorated with additional information.
+
+  def annotate(tag)
+    tag
+  end
+
+  ##
+  # Marks up +content+
+
+  def convert content
+    @markup.convert content, self
+  end
+
+  ##
+  # Converts flow items +flow+
+
+  def convert_flow(flow)
+    res = []
+
+    flow.each do |item|
+      case item
+      when String then
+        res << convert_string(item)
+      when RDoc::Markup::AttrChanger then
+        off_tags res, item
+        on_tags res, item
+      when RDoc::Markup::RegexpHandling then
+        res << convert_regexp_handling(item)
+      else
+        raise "Unknown flow element: #{item.inspect}"
+      end
+    end
+
+    res.join
+  end
+
+  ##
+  # Converts added regexp handlings. See RDoc::Markup#add_regexp_handling
+
+  def convert_regexp_handling target
+    return target.text if in_tt?
+
+    handled = false
+
+    @attributes.each_name_of target.type do |name|
+      method_name = "handle_regexp_#{name}"
+
+      if respond_to? method_name then
+        target.text = public_send method_name, target
+        handled = true
+      end
+    end
+
+    unless handled then
+      target_name = @attributes.as_string target.type
+
+      raise RDoc::Error, "Unhandled regexp handling #{target_name}: #{target}"
+    end
+
+    target.text
+  end
+
+  ##
+  # Converts a string to be fancier if desired
+
+  def convert_string string
+    string
+  end
+
+  ##
+  # Use ignore in your subclass to ignore the content of a node.
+  #
+  #   ##
+  #   # We don't support raw nodes in ToNoRaw
+  #
+  #   alias accept_raw ignore
+
+  def ignore *node
+  end
+
+  ##
+  # Are we currently inside tt tags?
+
+  def in_tt?
+    @in_tt > 0
+  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
+    end
+  end
+
+  ##
+  # Turns off tags for +item+ on +res+
+
+  def off_tags res, item
+    attr_mask = item.turn_off
+    return if attr_mask.zero?
+
+    @attr_tags.reverse_each do |tag|
+      if attr_mask & tag.bit != 0 then
+        @in_tt -= 1 if tt? tag
+        res << annotate(tag.off)
+      end
+    end
+  end
+
+  ##
+  # Extracts and a scheme, url and an anchor id from +url+ and returns them.
+
+  def parse_url url
+    case url
+    when /^rdoc-label:([^:]*)(?::(.*))?/ then
+      scheme = 'link'
+      path   = "##{$1}"
+      id     = " id=\"#{$2}\"" if $2
+    when /([A-Za-z]+):(.*)/ then
+      scheme = $1.downcase
+      path   = $2
+    when /^#/ then
+    else
+      scheme = 'http'
+      path   = url
+      url    = url
+    end
+
+    if scheme == 'link' then
+      url = if path[0, 1] == '#' then # is this meaningful?
+              path
+            else
+              self.class.gen_relative_url @from_path, path
+            end
+    end
+
+    [scheme, url, id]
+  end
+
+  ##
+  # Is +tag+ a tt tag?
+
+  def tt? tag
+    tag.bit == @tt_bit
+  end
+
+end
+