gitlab-rdoc 6.3.2

data/lib/rdoc/markup/pre_process.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+##
+# Handle common directives that can occur in a block of text:
+#
+#   \:include: filename
+#
+# Directives can be escaped by preceding them with a backslash.
+#
+# RDoc plugin authors can register additional directives to be handled by
+# using RDoc::Markup::PreProcess::register.
+#
+# Any directive that is not built-in to RDoc (including those registered via
+# plugins) will be stored in the metadata hash on the CodeObject the comment
+# is attached to.  See RDoc::Markup@Directives for the list of built-in
+# directives.
+
+class RDoc::Markup::PreProcess
+
+  ##
+  # An RDoc::Options instance that will be filled in with overrides from
+  # directives
+
+  attr_accessor :options
+
+  ##
+  # Adds a post-process handler for directives.  The handler will be called
+  # with the result RDoc::Comment (or text String) and the code object for the
+  # comment (if any).
+
+  def self.post_process &block
+    @post_processors << block
+  end
+
+  ##
+  # Registered post-processors
+
+  def self.post_processors
+    @post_processors
+  end
+
+  ##
+  # Registers +directive+ as one handled by RDoc.  If a block is given the
+  # directive will be replaced by the result of the block, otherwise the
+  # directive will be removed from the processed text.
+  #
+  # The block will be called with the directive name and the directive
+  # parameter:
+  #
+  #   RDoc::Markup::PreProcess.register 'my-directive' do |directive, param|
+  #     # replace text, etc.
+  #   end
+
+  def self.register directive, &block
+    @registered[directive] = block
+  end
+
+  ##
+  # Registered directives
+
+  def self.registered
+    @registered
+  end
+
+  ##
+  # Clears all registered directives and post-processors
+
+  def self.reset
+    @post_processors = []
+    @registered = {}
+  end
+
+  reset
+
+  ##
+  # Creates a new pre-processor for +input_file_name+ that will look for
+  # included files in +include_path+
+
+  def initialize(input_file_name, include_path)
+    @input_file_name = input_file_name
+    @include_path = include_path
+    @options = nil
+  end
+
+  ##
+  # Look for directives in the given +text+.
+  #
+  # Options that we don't handle are yielded.  If the block returns false the
+  # directive is restored to the text.  If the block returns nil or no block
+  # was given the directive is handled according to the registered directives.
+  # If a String was returned the directive is replaced with the string.
+  #
+  # If no matching directive was registered the directive is restored to the
+  # text.
+  #
+  # If +code_object+ is given and the directive is unknown then the
+  # directive's parameter is set as metadata on the +code_object+.  See
+  # RDoc::CodeObject#metadata for details.
+
+  def handle text, code_object = nil, &block
+    if RDoc::Comment === text then
+      comment = text
+      text = text.text
+    end
+
+    # regexp helper (square brackets for optional)
+    # $1      $2  $3        $4      $5
+    # [prefix][\]:directive:[spaces][param]newline
+    text = text.gsub(/^([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):(\w+):([ \t]*)(.+)?(\r?\n|$)/) do
+      # skip something like ':toto::'
+      next $& if $4.empty? and $5 and $5[0, 1] == ':'
+
+      # skip if escaped
+      next "#$1:#$3:#$4#$5\n" unless $2.empty?
+
+      # This is not in handle_directive because I didn't want to pass another
+      # argument into it
+      if comment and $3 == 'markup' then
+        next "#{$1.strip}\n" unless $5
+        comment.format = $5.downcase
+        next "#{$1.strip}\n"
+      end
+
+      handle_directive $1, $3, $5, code_object, text.encoding, &block
+    end
+
+    if comment then
+      comment.text = text
+    else
+      comment = text
+    end
+
+    self.class.post_processors.each do |handler|
+      handler.call comment, code_object
+    end
+
+    text
+  end
+
+  ##
+  # Performs the actions described by +directive+ and its parameter +param+.
+  #
+  # +code_object+ is used for directives that operate on a class or module.
+  # +prefix+ is used to ensure the replacement for handled directives is
+  # correct.  +encoding+ is used for the <tt>include</tt> directive.
+  #
+  # For a list of directives in RDoc see RDoc::Markup.
+  #--
+  # When 1.8.7 support is ditched prefix can be defaulted to ''
+
+  def handle_directive prefix, directive, param, code_object = nil,
+                       encoding = nil
+    blankline = "#{prefix.strip}\n"
+    directive = directive.downcase
+
+    case directive
+    when 'arg', 'args' then
+      return "#{prefix}:#{directive}: #{param}\n" unless code_object && code_object.kind_of?(RDoc::AnyMethod)
+
+      code_object.params = param
+
+      blankline
+    when 'category' then
+      if RDoc::Context === code_object then
+        section = code_object.add_section param
+        code_object.temporary_section = section
+      end
+
+      blankline # ignore category if we're not on an RDoc::Context
+    when 'doc' then
+      return blankline unless code_object
+      code_object.document_self = true
+      code_object.force_documentation = true
+
+      blankline
+    when 'enddoc' then
+      return blankline unless code_object
+      code_object.done_documenting = true
+
+      blankline
+    when 'include' then
+      filename = param.split(' ', 2).first
+      include_file filename, prefix, encoding
+    when 'main' then
+      @options.main_page = param if @options.respond_to? :main_page
+
+      blankline
+    when 'nodoc' then
+      return blankline unless code_object
+      code_object.document_self = nil # notify nodoc
+      code_object.document_children = param !~ /all/i
+
+      blankline
+    when 'notnew', 'not_new', 'not-new' then
+      return blankline unless RDoc::AnyMethod === code_object
+
+      code_object.dont_rename_initialize = true
+
+      blankline
+    when 'startdoc' then
+      return blankline unless code_object
+
+      code_object.start_doc
+      code_object.force_documentation = true
+
+      blankline
+    when 'stopdoc' then
+      return blankline unless code_object
+
+      code_object.stop_doc
+
+      blankline
+    when 'title' then
+      @options.default_title = param if @options.respond_to? :default_title=
+
+      blankline
+    when 'yield', 'yields' then
+      return blankline unless code_object
+      # remove parameter &block
+      code_object.params = code_object.params.sub(/,?\s*&\w+/, '') if code_object.params
+
+      code_object.block_params = param
+
+      blankline
+    else
+      result = yield directive, param if block_given?
+
+      case result
+      when nil then
+        code_object.metadata[directive] = param if code_object
+
+        if RDoc::Markup::PreProcess.registered.include? directive then
+          handler = RDoc::Markup::PreProcess.registered[directive]
+          result = handler.call directive, param if handler
+        else
+          result = "#{prefix}:#{directive}: #{param}\n"
+        end
+      when false then
+        result = "#{prefix}:#{directive}: #{param}\n"
+      end
+
+      result
+    end
+  end
+
+  ##
+  # Handles the <tt>:include: _filename_</tt> directive.
+  #
+  # If the first line of the included file starts with '#', and contains
+  # an encoding information in the form 'coding:' or 'coding=', it is
+  # removed.
+  #
+  # If all lines in the included file start with a '#', this leading '#'
+  # is removed before inclusion. The included content is indented like
+  # the <tt>:include:</tt> directive.
+  #--
+  # so all content will be verbatim because of the likely space after '#'?
+  # TODO shift left the whole file content in that case
+  # TODO comment stop/start #-- and #++ in included file must be processed here
+
+  def include_file name, indent, encoding
+    full_name = find_include_file name
+
+    unless full_name then
+      warn "Couldn't find file to include '#{name}' from #{@input_file_name}"
+      return ''
+    end
+
+    content = RDoc::Encoding.read_file full_name, encoding, true
+    content = RDoc::Encoding.remove_magic_comment content
+
+    # strip magic comment
+    content = content.sub(/\A# .*coding[=:].*$/, '').lstrip
+
+    # strip leading '#'s, but only if all lines start with them
+    if content =~ /^[^#]/ then
+      content.gsub(/^/, indent)
+    else
+      content.gsub(/^#?/, indent)
+    end
+  end
+
+  ##
+  # Look for the given file in the directory containing the current file,
+  # and then in each of the directories specified in the RDOC_INCLUDE path
+
+  def find_include_file(name)
+    to_search = [File.dirname(@input_file_name)].concat @include_path
+    to_search.each do |dir|
+      full_name = File.join(dir, name)
+      stat = File.stat(full_name) rescue next
+      return full_name if stat.readable?
+    end
+    nil
+  end
+
+end

data/lib/rdoc/markup/raw.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+##
+# A section of text that is added to the output document as-is
+
+class RDoc::Markup::Raw
+
+  ##
+  # The component parts of the list
+
+  attr_reader :parts
+
+  ##
+  # Creates a new Raw containing +parts+
+
+  def initialize *parts
+    @parts = []
+    @parts.concat parts
+  end
+
+  ##
+  # Appends +text+
+
+  def << text
+    @parts << text
+  end
+
+  def == other # :nodoc:
+    self.class == other.class and @parts == other.parts
+  end
+
+  ##
+  # Calls #accept_raw+ on +visitor+
+
+  def accept visitor
+    visitor.accept_raw self
+  end
+
+  ##
+  # Appends +other+'s parts
+
+  def merge other
+    @parts.concat other.parts
+  end
+
+  def pretty_print q # :nodoc:
+    self.class.name =~ /.*::(\w{1,4})/i
+
+    q.group 2, "[#{$1.downcase}: ", ']' do
+      q.seplist @parts do |part|
+        q.pp part
+      end
+    end
+  end
+
+  ##
+  # Appends +texts+ onto this Paragraph
+
+  def push *texts
+    self.parts.concat texts
+  end
+
+  ##
+  # The raw text
+
+  def text
+    @parts.join ' '
+  end
+
+end
+

data/lib/rdoc/markup/regexp_handling.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+##
+# Hold details of a regexp handling sequence
+
+class RDoc::Markup::RegexpHandling
+
+  ##
+  # Regexp handling type
+
+  attr_reader   :type
+
+  ##
+  # Regexp handling text
+
+  attr_accessor :text
+
+  ##
+  # Creates a new regexp handling sequence of +type+ with +text+
+
+  def initialize(type, text)
+    @type, @text = type, text
+  end
+
+  ##
+  # Regexp handlings are equal when the have the same text and type
+
+  def ==(o)
+    self.text == o.text && self.type == o.type
+  end
+
+  def inspect # :nodoc:
+    "#<RDoc::Markup::RegexpHandling:0x%x @type=%p, @text=%p>" % [
+      object_id, @type, text.dump]
+  end
+
+  def to_s # :nodoc:
+    "RegexpHandling: type=#{type} text=#{text.dump}"
+  end
+
+end
+

data/lib/rdoc/markup/rule.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+##
+# A horizontal rule with a weight
+
+class RDoc::Markup::Rule < Struct.new :weight
+
+  ##
+  # Calls #accept_rule on +visitor+
+
+  def accept visitor
+    visitor.accept_rule self
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[rule:', ']' do
+      q.pp weight
+    end
+  end
+
+end
+

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