mega-max-hub 0.0.1

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

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+##
+# Subclass of the RDoc::Markup::ToHtml class that supports looking up method
+# names, classes, etc to create links.  RDoc::CrossReference is used to
+# generate those links based on the current context.
+
+class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
+
+  # :stopdoc:
+  ALL_CROSSREF_REGEXP = RDoc::CrossReference::ALL_CROSSREF_REGEXP
+  CROSSREF_REGEXP     = RDoc::CrossReference::CROSSREF_REGEXP
+  # :startdoc:
+
+  ##
+  # RDoc::CodeObject for generating references
+
+  attr_accessor :context
+
+  ##
+  # Should we show '#' characters on method references?
+
+  attr_accessor :show_hash
+
+  ##
+  # Creates a new crossref resolver that generates links relative to +context+
+  # which lives at +from_path+ in the generated files.  '#' characters on
+  # references are removed unless +show_hash+ is true.  Only method names
+  # preceded by '#' or '::' are linked, unless +hyperlink_all+ is true.
+
+  def initialize(from_path, context, pipe: false, output_decoration: true,
+                 hyperlink_all: false, show_hash: false,
+                 autolink_excluded_words: [], warn_missing_rdoc_ref: true)
+    raise ArgumentError, 'from_path cannot be nil' if from_path.nil?
+
+    super(pipe: pipe, output_decoration: output_decoration)
+
+    @context       = context
+    @from_path     = from_path
+    @hyperlink_all = hyperlink_all
+    @show_hash     = show_hash
+    @autolink_excluded_words = autolink_excluded_words
+    @warn_missing_rdoc_ref = warn_missing_rdoc_ref
+
+    @cross_reference = RDoc::CrossReference.new @context
+  end
+
+  # :nodoc:
+  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 = @hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
+    @markup.add_regexp_handling crossref_re, :CROSSREF
+  end
+
+  ##
+  # Creates a link to the reference +name+ if the name exists.  If +text+ is
+  # given it is used as the link text, otherwise +name+ is used.
+  # Returns +nil+ if the link target could not be resolved.
+
+  def cross_reference(name, text = nil, code = true, rdoc_ref: false)
+    # Strip '#' for link display text (e.g. #method shows as "method" in links)
+    display = !@show_hash && name.start_with?('#') ? name[1..] : name
+
+    if !display.end_with?('+@', '-@') && match = display.match(/(.*[^#:])?@(.*)/)
+      context_name = match[1]
+      label = convert_string(RDoc::Text.decode_legacy_label(match[2]))
+      text ||= "#{label} at <code>#{convert_string(context_name)}</code>" if context_name
+      text ||= label
+      code = false
+    else
+      text ||= convert_string(display)
+    end
+
+    link(name, text, code, rdoc_ref: rdoc_ref)
+  end
+
+  ##
+  # We're invoked when any text matches the CROSSREF pattern.  If we find the
+  # corresponding reference, generate a link.  If the name we're looking for
+  # contains no punctuation, we look for it up the module/class chain.  For
+  # example, ToHtml is found, even without the <tt>RDoc::Markup::</tt> prefix,
+  # because we look for it in module Markup first.
+
+  def handle_regexp_CROSSREF(name)
+    return convert_string(name) if in_tidylink_label?
+    return name if @autolink_excluded_words&.include?(name)
+
+    return name if name =~ /@[\w-]+\.[\w-]/ # labels that look like emails
+
+    unless @hyperlink_all then
+      # This ensures that words entirely consisting of lowercase letters will
+      # not have cross-references generated (to suppress lots of erroneous
+      # cross-references to "new" in text, for instance)
+      return name if name =~ /\A[a-z]*\z/
+    end
+    cross_reference(name, rdoc_ref: false) || convert_string(name)
+  end
+
+  ##
+  # Handles <tt>rdoc-ref:</tt> scheme links and allows RDoc::Markup::ToHtml to
+  # handle other schemes.
+
+  def handle_regexp_HYPERLINK(url)
+    return convert_string(url) if in_tidylink_label?
+
+    case url
+    when /\Ardoc-ref:/
+      ref = $'
+      cross_reference(ref, rdoc_ref: true) || convert_string(ref)
+    else
+      super
+    end
+  end
+
+  ##
+  # +target+ is an rdoc-schemed link that will be converted into a hyperlink.
+  # For the rdoc-ref scheme the cross-reference will be looked up and the
+  # given name will be used.
+  #
+  # All other contents are handled by
+  # {the superclass}[rdoc-ref:RDoc::Markup::ToHtml#handle_regexp_RDOCLINK]
+
+  def handle_regexp_RDOCLINK(url)
+    case url
+    when /\Ardoc-ref:/
+      if in_tidylink_label?
+        convert_string(url)
+      else
+        ref = $'
+        cross_reference(ref, rdoc_ref: true) || convert_string(ref)
+      end
+    else
+      super
+    end
+  end
+
+  ##
+  # Generates links for <tt>rdoc-ref:</tt> scheme URLs and allows
+  # RDoc::Markup::ToHtml to handle other schemes.
+
+  def gen_url(url, text)
+    if url =~ /\Ardoc-ref:/
+      name = $'
+      cross_reference(name, text, name == text, rdoc_ref: true) || text
+    else
+      super
+    end
+  end
+
+  ##
+  # Creates an HTML link to +name+ with the given +html_string+.
+  # +html_string+ should be already escaped and may contain HTML tags.
+  # Returns the link HTML string, or +nil+ if the reference could not be resolved.
+
+  def link(name, html_string, code = true, rdoc_ref: false)
+    if !(name.end_with?('+@', '-@')) and name =~ /(.*[^#:])?@/
+      name = $1
+      label = $'
+    end
+
+    ref = @cross_reference.resolve name if name
+
+    # Non-text source files (C, Ruby, etc.) don't get HTML pages generated,
+    # so don't auto-link to them. Explicit rdoc-ref: links are still allowed.
+    if !rdoc_ref && RDoc::TopLevel === ref && !ref.text?
+      return
+    end
+
+    if ref
+      path = ref.as_href(@from_path)
+
+      if code and RDoc::CodeObject === ref and !(RDoc::TopLevel === ref)
+        html_string = "<code>#{html_string}</code>"
+      end
+    elsif name
+      if rdoc_ref && @warn_missing_rdoc_ref
+        puts "#{@from_path}: `rdoc-ref:#{name}` can't be resolved for `#{html_string}`"
+      end
+      return
+    else
+      # A bare label reference like @foo still produces a valid anchor link
+      return unless label
+      path = +""
+    end
+
+    if label
+      # Decode legacy labels (e.g., "What-27s+Here" -> "What's Here")
+      # then convert to GitHub-style anchor format
+      decoded_label = RDoc::Text.decode_legacy_label(label)
+      formatted_label = RDoc::Text.to_anchor(decoded_label)
+
+      # Case 1: Path already has an anchor (e.g., method link)
+      #   Input:  C1#method@label -> path="C1.html#method-i-m"
+      #   Output: C1.html#method-i-m-label
+      if path =~ /#/
+        path << "-#{formatted_label}"
+
+      # Case 2: Label matches a section title
+      #   Input:  C1@Section -> path="C1.html", section "Section" exists
+      #   Output: C1.html#section (uses section.aref for GitHub-style)
+      elsif (section = ref&.sections&.find { |s| decoded_label == s.title })
+        path << "##{section.aref}"
+
+      # Case 3: Ref has an aref (class/module context)
+      #   Input:  C1@heading -> path="C1.html", ref=C1 class
+      #   Output: C1.html#class-c1-heading
+      elsif ref.respond_to?(:aref)
+        path << "##{ref.aref}-#{formatted_label}"
+
+      # Case 4: No context, just the label (e.g., TopLevel/file)
+      #   Input:  README@section -> path="README_md.html"
+      #   Output: README_md.html#section
+      else
+        path << "##{formatted_label}"
+      end
+    end
+
+    "<a href=\"#{path}\">#{html_string}</a>"
+  end
+
+  def handle_TT(code)
+    emit_inline(tt_cross_reference(code) || "<code>#{convert_string(code)}</code>")
+  end
+
+  # Applies additional special handling on top of the one defined in ToHtml.
+  # When a tidy link is <tt>{Foo}[rdoc-ref:Foo]</tt>, the label part is surrounded by <tt><code></code></tt>.
+  # TODO: reconsider this workaround.
+  def apply_tidylink_label_special_handling(label, url)
+    if url == "rdoc-ref:#{label}" && cross_reference(label)&.include?('<code>')
+      "<code>#{convert_string(label)}</code>"
+    else
+      super
+    end
+  end
+
+  # Handles cross-reference and suppressed-crossref inside tt tag.
+  # Returns nil if code is not an existing cross-reference nor a suppressed-crossref.
+  def tt_cross_reference(code)
+    return if in_tidylink_label?
+
+    crossref_regexp = @hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
+    # REGEXP sometimes matches a string that starts with a backslash but is not a
+    # suppressed cross-reference (for example, `\+`), so the backslash-removed
+    # part needs to be checked against crossref_regexp.
+    match = crossref_regexp.match(code.delete_prefix('\\'))
+    return unless match && match.begin(1).zero?
+    return unless match.post_match.match?(/\A[[:punct:]\s]*\z/)
+
+    # cross_reference(file_page) may return a link without code tag.
+    # We need to check it because this method shouldn't return an html text without code tag.
+    if code.start_with?('\\')
+      # Remove leading backslash if crossref exists
+      "<code>#{convert_string(code[1..])}</code>" if cross_reference(code[1..])&.include?('<code>')
+    else
+      html = cross_reference(code)
+      html if html&.include?('<code>')
+    end
+  end
+end

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

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+##
+# Outputs RDoc markup as paragraphs with inline markup only.
+
+class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
+
+  ##
+  # After this many characters the input will be cut off.
+
+  attr_reader :character_limit
+
+  ##
+  # The number of characters seen so far.
+
+  attr_reader :characters # :nodoc:
+
+  ##
+  # The attribute bitmask
+
+  attr_reader :mask
+
+  ##
+  # After this many paragraphs the input will be cut off.
+
+  attr_reader :paragraph_limit
+
+  ##
+  # Count of paragraphs found
+
+  attr_reader :paragraphs
+
+  ##
+  # Creates a new ToHtmlSnippet formatter that will cut off the input on the
+  # next word boundary after the given number of +characters+ or +paragraphs+
+  # of text have been encountered.
+
+  def initialize(characters = 100, paragraphs = 3)
+    super()
+
+    @character_limit = characters
+    @paragraph_limit = paragraphs
+
+    @characters = 0
+    @mask       = 0
+    @paragraphs = 0
+
+    @markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
+  end
+
+  ##
+  # Adds +heading+ to the output as a paragraph
+
+  def accept_heading(heading)
+    @res << "<p>#{to_html heading.text}\n"
+
+    add_paragraph
+  end
+
+  ##
+  # Raw sections are untrusted and ignored
+
+  alias accept_raw ignore
+
+  ##
+  # Rules are ignored
+
+  alias accept_rule ignore
+
+  ##
+  # Adds +paragraph+ to the output
+
+  def accept_paragraph(paragraph)
+    para = @in_list_entry.last || "<p>"
+
+    text = paragraph.text @hard_break
+
+    @res << "#{para}#{to_html text}\n"
+
+    add_paragraph
+  end
+
+  ##
+  # Finishes consumption of +list_item+
+
+  def accept_list_item_end(list_item)
+  end
+
+  ##
+  # Prepares the visitor for consuming +list_item+
+
+  def accept_list_item_start(list_item)
+    @res << list_item_start(list_item, @list.last)
+  end
+
+  ##
+  # Prepares the visitor for consuming +list+
+
+  def accept_list_start(list)
+    @list << list.type
+    @res << html_list_name(list.type, true)
+    @in_list_entry.push ''
+  end
+
+  ##
+  # Adds +verbatim+ to the output
+
+  def accept_verbatim(verbatim)
+    throw :done if @characters >= @character_limit
+    input = verbatim.text.rstrip
+    text = truncate(input, @character_limit - @characters)
+    @characters += input.length
+    text << " #{TO_HTML_CHARACTERS[text.encoding][:ellipsis]}" unless text == input
+
+    super RDoc::Markup::Verbatim.new text
+
+    add_paragraph
+  end
+
+  ##
+  # Prepares the visitor for HTML snippet generation
+
+  def start_accepting
+    super
+
+    @characters = 0
+  end
+
+  ##
+  # Removes escaping from the cross-references in +target+
+
+  def handle_regexp_CROSSREF(text)
+    text.sub(/\A\\/, '')
+  end
+
+  ##
+  # Lists are paragraphs, but notes and labels have a separator
+
+  def list_item_start(list_item, list_type)
+    throw :done if @characters >= @character_limit
+
+    case list_type
+    when :BULLET, :LALPHA, :NUMBER, :UALPHA then
+      "<p>"
+    when :LABEL, :NOTE then
+      labels = Array(list_item.label).map do |label|
+        to_html label
+      end.join ', '
+
+      labels << " &mdash; " unless labels.empty?
+
+      start = "<p>#{labels}"
+      @characters += 1 # try to include the label
+      start
+    else
+      raise RDoc::Error, "Invalid list type: #{list_type.inspect}"
+    end
+  end
+
+  ##
+  # Returns just the text of +link+, +url+ is only used to determine the link
+  # type.
+
+  def gen_url(url, text)
+    if url =~ /^rdoc-label:([^:]*)(?::(.*))?/ then
+      type = "link"
+    elsif url =~ /([A-Za-z]+):(.*)/ then
+      type = $1
+    else
+      type = "http"
+    end
+
+    if (type == "http" or type == "https" or type == "link") and
+       url =~ /\.(gif|png|jpg|jpeg|bmp)$/ then
+      ''
+    else
+      text.sub(%r%^#{type}:/*%, '')
+    end
+  end
+
+  ##
+  # In snippets, there are no lists
+
+  def html_list_name(list_type, open_tag)
+    ''
+  end
+
+  ##
+  # Throws +:done+ when paragraph_limit paragraphs have been encountered
+
+  def add_paragraph
+    @paragraphs += 1
+
+    throw :done if @paragraphs >= @paragraph_limit
+  end
+
+  ##
+  # Marks up +content+
+
+  def convert(content)
+    catch :done do
+      return super
+    end
+
+    end_accepting
+  end
+
+  def handle_PLAIN_TEXT(text) # :nodoc:
+    return if inline_limit_reached?
+
+    truncated = truncate(text, @inline_character_limit)
+    @inline_character_limit -= text.size
+    emit_inline(convert_string(truncated))
+  end
+
+  def handle_REGEXP_HANDLING_TEXT(text) # :nodoc:
+    return if inline_limit_reached?
+
+    # We can't truncate text including html tags.
+    # Just emit as is, and count all characters including html tag part.
+    emit_inline(text)
+    @inline_character_limit -= text.size
+  end
+
+  def handle_BOLD(nodes)
+    super unless inline_limit_reached?
+  end
+
+  def handle_BOLD_WORD(word)
+    super unless inline_limit_reached?
+  end
+
+  def handle_EM(nodes)
+    super unless inline_limit_reached?
+  end
+
+  def handle_EM_WORD(word)
+    super unless inline_limit_reached?
+  end
+
+  def handle_TT(code)
+    super unless inline_limit_reached?
+  end
+
+  def handle_STRIKE(nodes)
+    super unless inline_limit_reached?
+  end
+
+  def handle_HARD_BREAK
+    super unless inline_limit_reached?
+  end
+
+  def handle_TIDYLINK(label_part, url)
+    traverse_inline_nodes(label_part) unless inline_limit_reached?
+  end
+
+  def inline_limit_reached?
+    @inline_character_limit <= 0
+  end
+
+  def handle_inline(text)
+    limit = @character_limit - @characters
+    return ['', 0] if limit <= 0
+    @inline_character_limit = limit
+    res = super
+    res << " #{TO_HTML_CHARACTERS[text.encoding][:ellipsis]}" if @inline_character_limit <= 0
+    @characters += limit - @inline_character_limit
+    res
+  end
+
+  def to_html(item)
+    throw :done if @characters >= @character_limit
+    handle_inline(item)
+  end
+
+  ##
+  # Truncates +text+ at the end of the first word after the limit.
+
+  def truncate(text, limit)
+    return text if limit >= text.size
+    return '' if limit <= 0
+
+    text =~ /\A(.{#{limit},}?)(\s|$)/m # TODO word-break instead of \s?
+
+    $1
+  end
+
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+##
+# Joins the parts of an RDoc::Markup::Paragraph into a single String.
+#
+# This allows for easier maintenance and testing of Markdown support.
+#
+# This formatter only works on Paragraph instances.  Attempting to process
+# other markup syntax items will not work.
+
+class RDoc::Markup::ToJoinedParagraph < RDoc::Markup::Formatter
+  def start_accepting # :nodoc:
+  end
+
+  def end_accepting # :nodoc:
+  end
+
+  ##
+  # Converts the parts of +paragraph+ to a single entry.
+
+  def accept_paragraph(paragraph)
+    parts = paragraph.parts.chunk do |part|
+      String === part
+    end.flat_map do |string, chunk|
+      string ? chunk.join.rstrip : chunk
+    end
+
+    paragraph.parts.replace parts
+  end
+
+  alias accept_block_quote     ignore
+  alias accept_heading         ignore
+  alias accept_list_end        ignore
+  alias accept_list_item_end   ignore
+  alias accept_list_item_start ignore
+  alias accept_list_start      ignore
+  alias accept_raw             ignore
+  alias accept_rule            ignore
+  alias accept_verbatim        ignore
+  alias accept_table           ignore
+
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+require 'cgi/escape'
+require 'cgi/util' unless defined?(CGI::EscapeExt)
+
+##
+# Creates HTML-safe labels suitable for use in id attributes.  Tidylinks are
+# converted to their link part and cross-reference links have the suppression
+# marks removed (\\SomeClass is converted to SomeClass).
+
+class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
+
+  attr_reader :res # :nodoc:
+
+  ##
+  # Creates a new formatter that will output HTML-safe labels
+
+  def initialize
+    super
+
+    @markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
+
+    @res = []
+  end
+
+  def handle_PLAIN_TEXT(text)
+    @res << text
+  end
+
+  def handle_REGEXP_HANDLING_TEXT(text)
+    @res << text
+  end
+
+  def handle_TT(text)
+    @res << text
+  end
+
+  def extract_plaintext(text)
+    @res = []
+    handle_inline(text)
+    @res.join
+  end
+
+  ##
+  # Converts +text+ to an HTML-safe label using GitHub-style anchor formatting.
+
+  def convert(text)
+    label = extract_plaintext(text)
+
+    RDoc::Text.to_anchor(label)
+  end
+
+  ##
+  # Converts +text+ to an HTML-safe label using legacy RDoc formatting.
+  # Used for generating backward-compatible anchor aliases.
+
+  def convert_legacy(text)
+    label = extract_plaintext(text)
+
+    CGI.escape(label).gsub('%', '-').sub(/^-/, '')
+  end
+
+  ##
+  # Converts the CROSSREF +target+ to plain text, removing the suppression
+  # marker, if any
+
+  def handle_regexp_CROSSREF(text)
+    text.sub(/^\\/, '')
+  end
+
+  alias accept_blank_line         ignore
+  alias accept_block_quote        ignore
+  alias accept_heading            ignore
+  alias accept_list_end           ignore
+  alias accept_list_item_end      ignore
+  alias accept_list_item_start    ignore
+  alias accept_list_start         ignore
+  alias accept_paragraph          ignore
+  alias accept_raw                ignore
+  alias accept_rule               ignore
+  alias accept_verbatim           ignore
+  alias end_accepting             ignore
+  alias start_accepting           ignore
+
+end