honeybadger 5.3.0 → 5.4.0

data/vendor/bundle/ruby/3.2.0/gems/rdoc-6.6.0/lib/rdoc/markup/to_html_snippet.rb

@@ -0,0 +1,284 @@
+# 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 options, characters = 100, paragraphs = 3, markup = nil
+    super options, markup
+
+    @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
+
+  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
+    text << ' ...' 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 target
+    target.text.sub(/\A\\/, '')
+  end
+
+  ##
+  # +target+ is a <code><br></code>
+
+  def handle_regexp_HARD_BREAK target
+    @characters -= 4
+    '<br>'
+  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
+
+  ##
+  # Converts flow items +flow+
+
+  def convert_flow flow
+    throw :done if @characters >= @character_limit
+
+    res = []
+    @mask = 0
+
+    flow.each do |item|
+      case item
+      when RDoc::Markup::AttrChanger then
+        off_tags res, item
+        on_tags  res, item
+      when String then
+        text = convert_string item
+        res << truncate(text)
+      when RDoc::Markup::RegexpHandling then
+        text = convert_regexp_handling item
+        res << truncate(text)
+      else
+        raise "Unknown flow element: #{item.inspect}"
+      end
+
+      if @characters >= @character_limit then
+        off_tags res, RDoc::Markup::AttrChanger.new(0, @mask)
+        break
+      end
+    end
+
+    res << ' ...' if @characters >= @character_limit
+
+    res.join
+  end
+
+  ##
+  # Maintains a bitmask to allow HTML elements to be closed properly.  See
+  # RDoc::Markup::Formatter.
+
+  def on_tags res, item
+    @mask ^= item.turn_on
+
+    super
+  end
+
+  ##
+  # Maintains a bitmask to allow HTML elements to be closed properly.  See
+  # RDoc::Markup::Formatter.
+
+  def off_tags res, item
+    @mask ^= item.turn_off
+
+    super
+  end
+
+  ##
+  # Truncates +text+ at the end of the first word after the character_limit.
+
+  def truncate text
+    length = text.length
+    characters = @characters
+    @characters += length
+
+    return text if @characters < @character_limit
+
+    remaining = @character_limit - characters
+
+    text =~ /\A(.{#{remaining},}?)(\s|$)/m # TODO word-break instead of \s?
+
+    $1
+  end
+
+end

data/vendor/bundle/ruby/3.2.0/gems/rdoc-6.6.0/lib/rdoc/markup/to_joined_paragraph.rb

@@ -0,0 +1,46 @@
+# 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 initialize # :nodoc:
+    super nil
+  end
+
+  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/vendor/bundle/ruby/3.2.0/gems/rdoc-6.6.0/lib/rdoc/markup/to_label.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require 'cgi/util'
+
+##
+# 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 markup = nil
+    super nil, markup
+
+    @markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
+    @markup.add_regexp_handling(/(((\{.*?\})|\b\S+?)\[\S+?\])/, :TIDYLINK)
+
+    add_tag :BOLD, '', ''
+    add_tag :TT,   '', ''
+    add_tag :EM,   '', ''
+
+    @res = []
+  end
+
+  ##
+  # Converts +text+ to an HTML-safe label
+
+  def convert text
+    label = convert_flow @am.flow text
+
+    CGI.escape(label).gsub('%', '-').sub(/^-/, '')
+  end
+
+  ##
+  # Converts the CROSSREF +target+ to plain text, removing the suppression
+  # marker, if any
+
+  def handle_regexp_CROSSREF target
+    text = target.text
+
+    text.sub(/^\\/, '')
+  end
+
+  ##
+  # Converts the TIDYLINK +target+ to just the text part
+
+  def handle_regexp_TIDYLINK target
+    text = target.text
+
+    return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
+
+    $1
+  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 handle_regexp_HARD_BREAK  ignore
+  alias start_accepting           ignore
+
+end

data/vendor/bundle/ruby/3.2.0/gems/rdoc-6.6.0/lib/rdoc/markup/to_markdown.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+# :markup: markdown
+
+##
+# Outputs parsed markup as Markdown
+
+class RDoc::Markup::ToMarkdown < RDoc::Markup::ToRdoc
+
+  ##
+  # Creates a new formatter that will output Markdown format text
+
+  def initialize markup = nil
+    super
+
+    @headings[1] = ['# ',      '']
+    @headings[2] = ['## ',     '']
+    @headings[3] = ['### ',    '']
+    @headings[4] = ['#### ',   '']
+    @headings[5] = ['##### ',  '']
+    @headings[6] = ['###### ', '']
+
+    add_regexp_handling_RDOCLINK
+    add_regexp_handling_TIDYLINK
+
+    @hard_break = "  \n"
+  end
+
+  ##
+  # Maps attributes to HTML sequences
+
+  def init_tags
+    add_tag :BOLD, '**', '**'
+    add_tag :EM,   '*',  '*'
+    add_tag :TT,   '`',  '`'
+  end
+
+  ##
+  # Adds a newline to the output
+
+  def handle_regexp_HARD_BREAK target
+    "  \n"
+  end
+
+  ##
+  # Finishes consumption of `list`
+
+  def accept_list_end list
+    @res << "\n"
+
+    super
+  end
+
+  ##
+  # Finishes consumption of `list_item`
+
+  def accept_list_item_end list_item
+    width = case @list_type.last
+            when :BULLET then
+              4
+            when :NOTE, :LABEL then
+              use_prefix
+
+              4
+            else
+              @list_index[-1] = @list_index.last.succ
+              4
+            end
+
+    @indent -= width
+  end
+
+  ##
+  # Prepares the visitor for consuming `list_item`
+
+  def accept_list_item_start list_item
+    type = @list_type.last
+
+    case type
+    when :NOTE, :LABEL then
+      bullets = Array(list_item.label).map do |label|
+        attributes(label).strip
+      end.join "\n"
+
+      bullets << "\n:"
+
+      @prefix = ' ' * @indent
+      @indent += 4
+      @prefix << bullets + (' ' * (@indent - 1))
+    else
+      bullet = type == :BULLET ? '*' : @list_index.last.to_s + '.'
+      @prefix = (' ' * @indent) + bullet.ljust(4)
+
+      @indent += 4
+    end
+  end
+
+  ##
+  # Prepares the visitor for consuming `list`
+
+  def accept_list_start list
+    case list.type
+    when :BULLET, :LABEL, :NOTE then
+      @list_index << nil
+    when :LALPHA, :NUMBER, :UALPHA then
+      @list_index << 1
+    else
+      raise RDoc::Error, "invalid list type #{list.type}"
+    end
+
+    @list_width << 4
+    @list_type << list.type
+  end
+
+  ##
+  # Adds `rule` to the output
+
+  def accept_rule rule
+    use_prefix or @res << ' ' * @indent
+    @res << '-' * 3
+    @res << "\n"
+  end
+
+  ##
+  # Outputs `verbatim` indented 4 columns
+
+  def accept_verbatim verbatim
+    indent = ' ' * (@indent + 4)
+
+    verbatim.parts.each do |part|
+      @res << indent unless part == "\n"
+      @res << part
+    end
+
+    @res << "\n"
+  end
+
+  ##
+  # Creates a Markdown-style URL from +url+ with +text+.
+
+  def gen_url url, text
+    scheme, url, = parse_url url
+
+    "[#{text.sub(%r{^#{scheme}:/*}i, '')}](#{url})"
+  end
+
+  ##
+  # Handles <tt>rdoc-</tt> type links for footnotes.
+
+  def handle_rdoc_link url
+    case url
+    when /^rdoc-ref:/ then
+      $'
+    when /^rdoc-label:footmark-(\d+)/ then
+      "[^#{$1}]:"
+    when /^rdoc-label:foottext-(\d+)/ then
+      "[^#{$1}]"
+    when /^rdoc-label:label-/ then
+      gen_url url, $'
+    when /^rdoc-image:/ then
+      "![](#{$'})"
+    when /^rdoc-[a-z]+:/ then
+      $'
+    end
+  end
+
+  ##
+  # Converts the RDoc markup tidylink into a Markdown.style link.
+
+  def handle_regexp_TIDYLINK target
+    text = target.text
+
+    return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
+
+    label = $1
+    url   = $2
+
+    if url =~ /^rdoc-label:foot/ then
+      handle_rdoc_link url
+    else
+      gen_url url, label
+    end
+  end
+
+  ##
+  # Converts the rdoc-...: links into a Markdown.style links.
+
+  def handle_regexp_RDOCLINK target
+    handle_rdoc_link target.text
+  end
+
+end