gitlab-rdoc 6.3.2

data/lib/rdoc/token_stream.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+##
+# A TokenStream is a list of tokens, gathered during the parse of some entity
+# (say a method). Entities populate these streams by being registered with the
+# lexer. Any class can collect tokens by including TokenStream. From the
+# outside, you use such an object by calling the start_collecting_tokens
+# method, followed by calls to add_token and pop_token.
+
+module RDoc::TokenStream
+
+  ##
+  # Converts +token_stream+ to HTML wrapping various tokens with
+  # <tt><span></tt> elements. Some tokens types are wrapped in spans
+  # with the given class names. Other token types are not wrapped in spans.
+
+  def self.to_html token_stream
+    starting_title = false
+
+    token_stream.map do |t|
+      next unless t
+
+      style = case t[:kind]
+              when :on_const   then 'ruby-constant'
+              when :on_kw      then 'ruby-keyword'
+              when :on_ivar    then 'ruby-ivar'
+              when :on_cvar    then 'ruby-identifier'
+              when :on_gvar    then 'ruby-identifier'
+              when '=' != t[:text] && :on_op
+                               then 'ruby-operator'
+              when :on_tlambda then 'ruby-operator'
+              when :on_ident   then 'ruby-identifier'
+              when :on_label   then 'ruby-value'
+              when :on_backref, :on_dstring
+                               then 'ruby-node'
+              when :on_comment then 'ruby-comment'
+              when :on_embdoc  then 'ruby-comment'
+              when :on_regexp  then 'ruby-regexp'
+              when :on_tstring then 'ruby-string'
+              when :on_int, :on_float,
+                   :on_rational, :on_imaginary,
+                   :on_heredoc,
+                   :on_symbol, :on_CHAR then 'ruby-value'
+              when :on_heredoc_beg, :on_heredoc_end
+                               then 'ruby-identifier'
+              end
+
+      comment_with_nl = false
+      if :on_comment == t[:kind] or :on_embdoc == t[:kind] or :on_heredoc_end == t[:kind]
+        comment_with_nl = true if "\n" == t[:text][-1]
+        text = t[:text].rstrip
+      else
+        text = t[:text]
+      end
+
+      if :on_ident == t[:kind] && starting_title
+        starting_title = false
+        style = 'ruby-identifier ruby-title'
+      end
+
+      if :on_kw == t[:kind] and 'def' == t[:text]
+        starting_title = true
+      end
+
+      text = CGI.escapeHTML text
+
+      if style then
+        "<span class=\"#{style}\">#{text}</span>#{"\n" if comment_with_nl}"
+      else
+        text
+      end
+    end.join
+  end
+
+  ##
+  # Adds +tokens+ to the collected tokens
+
+  def add_tokens(tokens)
+    @token_stream.concat(tokens)
+  end
+
+  ##
+  # Adds one +token+ to the collected tokens
+
+  def add_token(token)
+    @token_stream.push(token)
+  end
+
+  ##
+  # Starts collecting tokens
+
+  def collect_tokens
+    @token_stream = []
+  end
+
+  alias start_collecting_tokens collect_tokens
+
+  ##
+  # Remove the last token from the collected tokens
+
+  def pop_token
+    @token_stream.pop
+  end
+
+  ##
+  # Current token stream
+
+  def token_stream
+    @token_stream
+  end
+
+  ##
+  # Returns a string representation of the token stream
+
+  def tokens_to_s
+    token_stream.compact.map { |token| token[:text] }.join ''
+  end
+
+end
+

data/lib/rdoc/tom_doc.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+# :markup: tomdoc
+
+# A parser for TomDoc based on TomDoc 1.0.0-rc1 (02adef9b5a)
+#
+# The TomDoc specification can be found at:
+#
+# http://tomdoc.org
+#
+# The latest version of the TomDoc specification can be found at:
+#
+# https://github.com/mojombo/tomdoc/blob/master/tomdoc.md
+#
+# To choose TomDoc as your only default format see RDoc::Options@Saved+Options
+# for instructions on setting up a <code>.rdoc_options</code> file to store
+# your project default.
+#
+# There are a few differences between this parser and the specification.  A
+# best-effort was made to follow the specification as closely as possible but
+# some choices to deviate were made.
+#
+# A future version of RDoc will warn when a MUST or MUST NOT is violated and
+# may warn when a SHOULD or SHOULD NOT is violated.  RDoc will always try
+# to emit documentation even if given invalid TomDoc.
+#
+# Here are some implementation choices this parser currently makes:
+#
+# This parser allows rdoc-style inline markup but you should not depended on
+# it.
+#
+# This parser allows a space between the comment and the method body.
+#
+# This parser does not require the default value to be described for an
+# optional argument.
+#
+# This parser does not examine the order of sections.  An Examples section may
+# precede the Arguments section.
+#
+# This class is documented in TomDoc format.  Since this is a subclass of the
+# RDoc markup parser there isn't much to see here, unfortunately.
+
+class RDoc::TomDoc < RDoc::Markup::Parser
+
+  # Internal: Token accessor
+
+  attr_reader :tokens
+
+  # Internal: Adds a post-processor which sets the RDoc section based on the
+  # comment's status.
+  #
+  # Returns nothing.
+
+  def self.add_post_processor # :nodoc:
+    RDoc::Markup::PreProcess.post_process do |comment, code_object|
+      next unless code_object and
+                  RDoc::Comment === comment and comment.format == 'tomdoc'
+
+      comment.text.gsub!(/(\A\s*# )(Public|Internal|Deprecated):\s+/) do
+        section = code_object.add_section $2
+        code_object.temporary_section = section
+
+        $1
+      end
+    end
+  end
+
+  add_post_processor
+
+  # Public: Parses TomDoc from text
+  #
+  # text - A String containing TomDoc-format text.
+  #
+  # Examples
+  #
+  #   RDoc::TomDoc.parse <<-TOMDOC
+  #   This method does some things
+  #
+  #   Returns nothing.
+  #   TOMDOC
+  #   # => #<RDoc::Markup::Document:0xXXX @parts=[...], @file=nil>
+  #
+  # Returns an RDoc::Markup::Document representing the TomDoc format.
+
+  def self.parse text
+    parser = new
+
+    parser.tokenize text
+    doc = RDoc::Markup::Document.new
+    parser.parse doc
+    doc
+  end
+
+  # Internal: Extracts the Signature section's method signature
+  #
+  # comment - An RDoc::Comment that will be parsed and have the signature
+  #           extracted
+  #
+  # Returns a String containing the signature and nil if not
+
+  def self.signature comment
+    return unless comment.tomdoc?
+
+    document = comment.parse
+
+    signature = nil
+    found_heading = false
+    found_signature = false
+
+    document.parts.delete_if do |part|
+      next false if found_signature
+
+      found_heading ||=
+        RDoc::Markup::Heading === part && part.text == 'Signature'
+
+      next false unless found_heading
+
+      next true if RDoc::Markup::BlankLine === part
+
+      if RDoc::Markup::Verbatim === part then
+        signature = part
+        found_signature = true
+      end
+    end
+
+    signature and signature.text
+  end
+
+  # Public: Creates a new TomDoc parser.  See also RDoc::Markup::parse
+
+  def initialize
+    super
+
+    @section      = nil
+    @seen_returns = false
+  end
+
+  # Internal: Builds a heading from the token stream
+  #
+  # level - The level of heading to create
+  #
+  # Returns an RDoc::Markup::Heading
+
+  def build_heading level
+    heading = super
+
+    @section = heading.text
+
+    heading
+  end
+
+  # Internal: Builds a verbatim from the token stream.  A verbatim in the
+  # Examples section will be marked as in Ruby format.
+  #
+  # margin - The indentation from the margin for lines that belong to this
+  #          verbatim section.
+  #
+  # Returns an RDoc::Markup::Verbatim
+
+  def build_verbatim margin
+    verbatim = super
+
+    verbatim.format = :ruby if @section == 'Examples'
+
+    verbatim
+  end
+
+  # Internal: Builds a paragraph from the token stream
+  #
+  # margin - Unused
+  #
+  # Returns an RDoc::Markup::Paragraph.
+
+  def build_paragraph margin
+    p :paragraph_start => margin if @debug
+
+    paragraph = RDoc::Markup::Paragraph.new
+
+    until @tokens.empty? do
+      type, data, = get
+
+      case type
+      when :TEXT then
+        @section = 'Returns' if data =~ /\A(Returns|Raises)/
+
+        paragraph << data
+      when :NEWLINE then
+        if :TEXT == peek_token[0] then
+          # Lines beginning with 'Raises' in the Returns section should not be
+          # treated as multiline text
+          if 'Returns' == @section and
+            peek_token[1].start_with?('Raises') then
+            break
+          else
+            paragraph << ' '
+          end
+        else
+          break
+        end
+      else
+        unget
+        break
+      end
+    end
+
+    p :paragraph_end => margin if @debug
+
+    paragraph
+  end
+
+  ##
+  # Detects a section change to "Returns" and adds a heading
+
+  def parse_text parent, indent # :nodoc:
+    paragraph = build_paragraph indent
+
+    if false == @seen_returns and 'Returns' == @section then
+      @seen_returns = true
+      parent << RDoc::Markup::Heading.new(3, 'Returns')
+      parent << RDoc::Markup::BlankLine.new
+    end
+
+    parent << paragraph
+  end
+
+  # Internal: Turns text into an Array of tokens
+  #
+  # text - A String containing TomDoc-format text.
+  #
+  # Returns self.
+
+  def tokenize text
+    text = text.sub(/\A(Public|Internal|Deprecated):\s+/, '')
+
+    setup_scanner text
+
+    until @s.eos? do
+      pos = @s.pos
+
+      # leading spaces will be reflected by the column of the next token
+      # the only thing we loose are trailing spaces at the end of the file
+      next if @s.scan(/ +/)
+
+      @tokens << case
+                 when @s.scan(/\r?\n/) then
+                   token = [:NEWLINE, @s.matched, *pos]
+                   @s.newline!
+                   token
+                 when @s.scan(/(Examples|Signature)$/) then
+                   @tokens << [:HEADER, 3, *pos]
+
+                   [:TEXT, @s[1], *pos]
+                 when @s.scan(/([:\w][\w\[\]]*)[ ]+- /) then
+                   [:NOTE, @s[1], *pos]
+                 else
+                   @s.scan(/.*/)
+                   [:TEXT, @s.matched.sub(/\r$/, ''), *pos]
+                 end
+    end
+
+    self
+  end
+
+end

data/lib/rdoc/top_level.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+##
+# A TopLevel context is a representation of the contents of a single file
+
+class RDoc::TopLevel < RDoc::Context
+
+  MARSHAL_VERSION = 0 # :nodoc:
+
+  ##
+  # This TopLevel's File::Stat struct
+
+  attr_accessor :file_stat
+
+  ##
+  # Relative name of this file
+
+  attr_accessor :relative_name
+
+  ##
+  # Absolute name of this file
+
+  attr_accessor :absolute_name
+
+  ##
+  # All the classes or modules that were declared in
+  # this file. These are assigned to either +#classes_hash+
+  # or +#modules_hash+ once we know what they really are.
+
+  attr_reader :classes_or_modules
+
+  attr_accessor :diagram # :nodoc:
+
+  ##
+  # The parser class that processed this file
+
+  attr_reader :parser
+
+  ##
+  # Creates a new TopLevel for the file at +absolute_name+.  If documentation
+  # is being generated outside the source dir +relative_name+ is relative to
+  # the source directory.
+
+  def initialize absolute_name, relative_name = absolute_name
+    super()
+    @name = nil
+    @absolute_name = absolute_name
+    @relative_name = relative_name
+    @file_stat     = File.stat(absolute_name) rescue nil # HACK for testing
+    @diagram       = nil
+    @parser        = nil
+
+    @classes_or_modules = []
+  end
+
+  def parser=(val)
+    @parser = val
+    @store.update_parser_of_file(absolute_name, val) if @store
+    @parser
+  end
+
+  ##
+  # An RDoc::TopLevel is equal to another with the same relative_name
+
+  def == other
+    self.class === other and @relative_name == other.relative_name
+  end
+
+  alias eql? ==
+
+  ##
+  # Adds +an_alias+ to +Object+ instead of +self+.
+
+  def add_alias(an_alias)
+    object_class.record_location self
+    return an_alias unless @document_self
+    object_class.add_alias an_alias
+  end
+
+  ##
+  # Adds +constant+ to +Object+ instead of +self+.
+
+  def add_constant constant
+    object_class.record_location self
+    return constant unless @document_self
+    object_class.add_constant constant
+  end
+
+  ##
+  # Adds +include+ to +Object+ instead of +self+.
+
+  def add_include(include)
+    object_class.record_location self
+    return include unless @document_self
+    object_class.add_include include
+  end
+
+  ##
+  # Adds +method+ to +Object+ instead of +self+.
+
+  def add_method(method)
+    object_class.record_location self
+    return method unless @document_self
+    object_class.add_method method
+  end
+
+  ##
+  # Adds class or module +mod+. Used in the building phase
+  # by the Ruby parser.
+
+  def add_to_classes_or_modules mod
+    @classes_or_modules << mod
+  end
+
+  ##
+  # Base name of this file
+
+  def base_name
+    File.basename @relative_name
+  end
+
+  alias name base_name
+
+  ##
+  # Only a TopLevel that contains text file) will be displayed.  See also
+  # RDoc::CodeObject#display?
+
+  def display?
+    text? and super
+  end
+
+  ##
+  # See RDoc::TopLevel::find_class_or_module
+  #--
+  # TODO Why do we search through all classes/modules found, not just the
+  #       ones of this instance?
+
+  def find_class_or_module name
+    @store.find_class_or_module name
+  end
+
+  ##
+  # Finds a class or module named +symbol+
+
+  def find_local_symbol(symbol)
+    find_class_or_module(symbol) || super
+  end
+
+  ##
+  # Finds a module or class with +name+
+
+  def find_module_named(name)
+    find_class_or_module(name)
+  end
+
+  ##
+  # Returns the relative name of this file
+
+  def full_name
+    @relative_name
+  end
+
+  ##
+  # An RDoc::TopLevel has the same hash as another with the same
+  # relative_name
+
+  def hash
+    @relative_name.hash
+  end
+
+  ##
+  # URL for this with a +prefix+
+
+  def http_url(prefix)
+    path = [prefix, @relative_name.tr('.', '_')]
+
+    File.join(*path.compact) + '.html'
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %p modules: %p classes: %p>" % [
+      self.class, object_id,
+      base_name,
+      @modules.map { |n,m| m },
+      @classes.map { |n,c| c }
+    ]
+  end
+
+  ##
+  # Time this file was last modified, if known
+
+  def last_modified
+    @file_stat ? file_stat.mtime : nil
+  end
+
+  ##
+  # Dumps this TopLevel for use by ri.  See also #marshal_load
+
+  def marshal_dump
+    [
+      MARSHAL_VERSION,
+      @relative_name,
+      @parser,
+      parse(@comment),
+    ]
+  end
+
+  ##
+  # Loads this TopLevel from +array+.
+
+  def marshal_load array # :nodoc:
+    initialize array[1]
+
+    @parser  = array[2]
+    @comment = array[3]
+
+    @file_stat          = nil
+  end
+
+  ##
+  # Returns the NormalClass "Object", creating it if not found.
+  #
+  # Records +self+ as a location in "Object".
+
+  def object_class
+    @object_class ||= begin
+      oc = @store.find_class_named('Object') || add_class(RDoc::NormalClass, 'Object')
+      oc.record_location self
+      oc
+    end
+  end
+
+  ##
+  # Base name of this file without the extension
+
+  def page_name
+    basename = File.basename @relative_name
+    basename =~ /\.(rb|rdoc|txt|md)$/i
+
+    $` || basename
+  end
+
+  ##
+  # Path to this file for use with HTML generator output.
+
+  def path
+    http_url @store.rdoc.generator.file_dir
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, "[#{self.class}: ", "]" do
+      q.text "base name: #{base_name.inspect}"
+      q.breakable
+
+      items = @modules.map { |n,m| m }
+      items.concat @modules.map { |n,c| c }
+      q.seplist items do |mod| q.pp mod end
+    end
+  end
+
+  ##
+  # Search record used by RDoc::Generator::JsonIndex
+
+  def search_record
+    return unless @parser < RDoc::Parser::Text
+
+    [
+      page_name,
+      '',
+      page_name,
+      '',
+      path,
+      '',
+      snippet(@comment),
+    ]
+  end
+
+  ##
+  # Is this TopLevel from a text file instead of a source code file?
+
+  def text?
+    @parser and @parser.include? RDoc::Parser::Text
+  end
+
+  def to_s # :nodoc:
+    "file #{full_name}"
+  end
+
+end
+