mega-max-hub 0.0.1

data/rdoc-8.0.0/lib/rdoc/markup/blank_line.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RDoc
+  class Markup
+    # An empty line
+    class BlankLine < Element
+      @instance = new
+
+      # RDoc::Markup::BlankLine is a singleton
+      #: () -> BlankLine
+      def self.new
+        @instance
+      end
+
+      # Calls #accept_blank_line on +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_blank_line(self)
+      end
+
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        q.text("blankline")
+      end
+    end
+  end
+end

data/rdoc-8.0.0/lib/rdoc/markup/block_quote.rb

@@ -0,0 +1,14 @@
+# 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/rdoc-8.0.0/lib/rdoc/markup/document.rb

@@ -0,0 +1,164 @@
+# 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/rdoc-8.0.0/lib/rdoc/markup/element.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RDoc
+  class Markup
+    # Base class defining the interface for all markup elements found in documentation
+    # @abstract
+    class Element
+      # @abstract
+      #: (untyped) -> void
+      def accept(visitor)
+        raise NotImplementedError, "#{self.class} must implement the accept method"
+      end
+
+      # @abstract
+      #: (PP) -> void
+      def pretty_print(q)
+        raise NotImplementedError, "#{self.class} must implement the pretty_print method"
+      end
+    end
+  end
+end

data/rdoc-8.0.0/lib/rdoc/markup/formatter.rb

@@ -0,0 +1,285 @@
+# 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.
+
+require 'rdoc/markup/inline_parser'
+
+class RDoc::Markup::Formatter
+
+  ##
+  # 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
+    @markup = RDoc::Markup.new
+
+    @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
+
+  ##
+  # Allows +tag+ to be decorated with additional information.
+
+  def annotate(tag)
+    tag
+  end
+
+  ##
+  # Marks up +content+
+
+  def convert(content)
+    @markup.convert content, self
+  end
+
+  # Applies regexp handling to +text+ and returns an array of [text, converted?] pairs.
+
+  def apply_regexp_handling(text)
+    matched = []
+    @markup.regexp_handlings.each_with_index do |(pattern, name), priority|
+      text.scan(pattern) do
+        m = Regexp.last_match
+        idx = m[1] ? 1 : 0
+        matched << [m.begin(idx), m.end(idx), m[idx], name, priority]
+      end
+    end
+    # If the start positions are the same, prefer the earlier-registered one
+    # (lower numeric priority from each_with_index).
+    matched.sort_by! {|beg_pos, _, _, _, priority| [beg_pos, priority] }
+
+    pos = 0
+    output = []
+    matched.each do |beg_pos, end_pos, s, name|
+      next if beg_pos < pos
+
+      output << [text[pos...beg_pos], false] if beg_pos != pos
+      handled = public_send(:"handle_regexp_#{name}", s)
+      output << [handled, true]
+      pos = end_pos
+    end
+
+    output << [text[pos..], false] if pos < text.size
+    output
+  end
+
+  # Called when processing plain text while traversing inline nodes from handle_inline.
+  # +text+ may need proper escaping.
+
+  def handle_PLAIN_TEXT(text)
+  end
+
+  # Called when processing regexp-handling-processed text while traversing inline nodes from handle_inline.
+  # +text+ may contain markup tags.
+
+  def handle_REGEXP_HANDLING_TEXT(text)
+  end
+
+  # Called when processing text node while traversing inline nodes from handle_inline.
+  # Apply regexp handling and dispatch to the appropriate handler: handle_REGEXP_HANDLING_TEXT or handle_PLAIN_TEXT.
+
+  def handle_TEXT(text)
+    apply_regexp_handling(text).each do |part, converted|
+      if converted
+        handle_REGEXP_HANDLING_TEXT(part)
+      else
+        handle_PLAIN_TEXT(part)
+      end
+    end
+  end
+
+  # Called when processing a hard break while traversing inline nodes from handle_inline.
+
+  def handle_HARD_BREAK
+  end
+
+  # Called when processing bold nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
+
+  def handle_BOLD(nodes)
+    traverse_inline_nodes(nodes)
+  end
+
+  # Called when processing emphasis nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
+
+  def handle_EM(nodes)
+    traverse_inline_nodes(nodes)
+  end
+
+  # Called when processing bold word nodes while traversing inline nodes from handle_inline.
+  # +word+ may need proper escaping.
+
+  def handle_BOLD_WORD(word)
+    handle_PLAIN_TEXT(word)
+  end
+
+  # Called when processing emphasis word nodes while traversing inline nodes from handle_inline.
+  # +word+ may need proper escaping.
+
+  def handle_EM_WORD(word)
+    handle_PLAIN_TEXT(word)
+  end
+
+  # Called when processing tt nodes while traversing inline nodes from handle_inline.
+  # +code+ may need proper escaping.
+
+  def handle_TT(code)
+    handle_PLAIN_TEXT(code)
+  end
+
+  # Called when processing strike nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
+
+  def handle_STRIKE(nodes)
+    traverse_inline_nodes(nodes)
+  end
+
+  # Called when processing tidylink nodes while traversing inline nodes from handle_inline.
+  # +label_part+ is an array of strings or nodes representing the link label.
+  # +url+ is the link URL.
+  # Traverse the label_part nodes and dispatch to the appropriate handlers.
+
+  def handle_TIDYLINK(label_part, url)
+    traverse_inline_nodes(label_part)
+  end
+
+  # Parses inline +text+, traverse the resulting nodes, and calls the appropriate handler methods.
+
+  def handle_inline(text)
+    nodes = RDoc::Markup::InlineParser.new(text).parse
+    traverse_inline_nodes(nodes)
+  end
+
+  # Traverses +nodes+ and calls the appropriate handler methods
+  # Nodes formats are described in RDoc::Markup::InlineParser#parse
+
+  def traverse_inline_nodes(nodes)
+    nodes.each do |node|
+      next handle_TEXT(node) if String === node
+      case node[:type]
+      when :TIDYLINK
+        handle_TIDYLINK(node[:children], node[:url])
+      when :HARD_BREAK
+        handle_HARD_BREAK
+      when :BOLD
+        handle_BOLD(node[:children])
+      when :BOLD_WORD
+        handle_BOLD_WORD(node[:children][0] || '')
+      when :EM
+        handle_EM(node[:children])
+      when :EM_WORD
+        handle_EM_WORD(node[:children][0] || '')
+      when :TT
+        handle_TT(node[:children][0] || '')
+      when :STRIKE
+        handle_STRIKE(node[:children])
+      end
+    end
+  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
+
+  ##
+  # 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

data/rdoc-8.0.0/lib/rdoc/markup/hard_break.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RDoc
+  class Markup
+    # A hard-break in the middle of a paragraph.
+    class HardBreak < Element
+      @instance = new
+
+      # RDoc::Markup::HardBreak is a singleton
+      #: () -> HardBreak
+      def self.new
+        @instance
+      end
+
+      # Calls #accept_hard_break on +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_hard_break(self)
+      end
+
+      #: (top) -> bool
+      def ==(other) # :nodoc:
+        self.class === other
+      end
+
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        q.text("[break]")
+      end
+    end
+  end
+end

data/rdoc-8.0.0/lib/rdoc/markup/heading.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RDoc
+  class Markup
+    # IMPORTANT! This weird workaround is required to ensure that RDoc can correctly deserializing Marshal data from
+    # older rubies. Older rubies have `Heading` as a struct, so if we change it to a class, deserialization fails
+    if RUBY_VERSION.start_with?("4.")
+      class Heading < Element
+        #: String
+        attr_reader :text
+
+        #: Integer
+        attr_accessor :level
+
+        #: (Integer, String) -> void
+        def initialize(level, text)
+          super()
+
+          @level = level
+          @text = text
+        end
+
+        #: (Object) -> bool
+        def ==(other)
+          other.is_a?(Heading) && other.level == @level && other.text == @text
+        end
+      end
+    else
+      Heading = Struct.new(:level, :text)
+    end
+
+    # A heading with a level (1-6) and text
+    #
+    #  RDoc syntax:
+    #   = Heading 1
+    #   == Heading 2
+    #   === Heading 3
+    #
+    #  Markdown syntax:
+    #   # Heading 1
+    #   ## Heading 2
+    #   ### Heading 3
+    #
+    class Heading
+      # A singleton RDoc::Markup::ToLabel formatter for headings.
+      #: () -> RDoc::Markup::ToLabel
+      def self.to_label
+        @to_label ||= Markup::ToLabel.new
+      end
+
+      # A singleton plain HTML formatter for headings. Used for creating labels for the Table of Contents
+      #: () -> RDoc::Markup::ToHtml
+      def self.to_html
+        @to_html ||= begin
+          to_html = Markup::ToHtml.new
+
+          def to_html.handle_regexp_CROSSREF(text)
+            text.sub(/^\\/, '')
+          end
+
+          to_html
+        end
+      end
+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_heading(self)
+      end
+
+      # An HTML-safe anchor reference for this header using GitHub-style formatting:
+      # - Lowercase
+      # - Spaces converted to hyphens
+      # - Special characters removed (except hyphens)
+      #
+      # Examples:
+      #   "Hello"       -> "hello"
+      #   "Hello World" -> "hello-world"
+      #   "Foo Bar Baz" -> "foo-bar-baz"
+      #
+      #: () -> String
+      def aref
+        self.class.to_label.convert text.dup
+      end
+
+      # An HTML-safe anchor reference using legacy RDoc formatting:
+      # - Prefixed with "label-"
+      # - Original case preserved
+      # - Spaces converted to + (URL encoding style)
+      # - Special characters percent-encoded
+      #
+      # Returns nil if it would be the same as the GitHub-style aref (no alias needed).
+      #
+      # Examples:
+      #   "hello"       -> "label-hello" (different due to label- prefix)
+      #   "Hello"       -> "label-Hello"
+      #   "Hello World" -> "label-Hello+World"
+      #   "Foo Bar Baz" -> "label-Foo+Bar+Baz"
+      #
+      #: () -> String?
+      def legacy_aref
+        "label-#{self.class.to_label.convert_legacy text.dup}"
+      end
+
+      # Creates a fully-qualified label (GitHub-style) which includes the context's aref prefix.
+      # This helps keep IDs unique in HTML when headings appear within class/method documentation.
+      #
+      # Examples (without context):
+      #   "Hello World" -> "hello-world"
+      #
+      # Examples (with context being class Foo):
+      #   "Hello World" -> "class-foo-hello-world"
+      #
+      # Examples (with context being method #bar):
+      #   "Hello World" -> "method-i-bar-hello-world"
+      #
+      #: (RDoc::Context?) -> String
+      def label(context = nil)
+        result = +""
+        result << "#{context.aref}-" if context&.respond_to?(:aref)
+        result << aref
+        result
+      end
+
+      # Creates a fully-qualified legacy label for backward compatibility.
+      # This is used to generate a secondary ID attribute on the heading's inner anchor,
+      # allowing old-style links (e.g., #label-Hello+World) to continue working.
+      #
+      # Examples (without context):
+      #   "hello"       -> "label-hello"
+      #   "Hello World" -> "label-Hello+World"
+      #
+      # Examples (with context being class Foo):
+      #   "hello"       -> "class-Foo-label-hello"
+      #   "Hello World" -> "class-Foo-label-Hello+World"
+      #
+      #: (RDoc::Context?) -> String
+      def legacy_label(context = nil)
+        result = +""
+        if context&.respond_to?(:legacy_aref)
+          result << "#{context.legacy_aref}-"
+        elsif context&.respond_to?(:aref)
+          result << "#{context.aref}-"
+        end
+        result << legacy_aref
+        result
+      end
+
+      # HTML markup of the text of this label without the surrounding header element.
+      #: () -> String
+      def plain_html
+        no_image_text = text
+
+        if matched = no_image_text.match(/rdoc-image:[^:]+:(.*)/)
+          no_image_text = matched[1]
+        end
+
+        self.class.to_html.to_html(no_image_text)
+      end
+
+      # @override
+      #: (PP) -> void
+      def pretty_print(q)
+        q.group 2, "[head: #{level} ", ']' do
+          q.pp text
+        end
+      end
+    end
+  end
+end