RubyGems - honeybadger - Versions diffs - 5.3.0 → 5.4.0 - Mend

honeybadger 5.3.0 → 5.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (513) hide show

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

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+##
+# RDoc::Markup parses plain text documents and attempts to decompose them into
+# their constituent parts.  Some of these parts are high-level: paragraphs,
+# chunks of verbatim text, list entries and the like.  Other parts happen at
+# the character level: a piece of bold text, a word in code font.  This markup
+# is similar in spirit to that used on WikiWiki webs, where folks create web
+# pages using a simple set of formatting rules.
+#
+# RDoc::Markup and other markup formats do no output formatting, this is
+# handled by the RDoc::Markup::Formatter subclasses.
+#
+# = Supported Formats
+#
+# Besides the RDoc::Markup format, the following formats are built in to RDoc:
+#
+# markdown::
+#   The markdown format as described by
+#   http://daringfireball.net/projects/markdown/.  See RDoc::Markdown for
+#   details on the parser and supported extensions.
+# rd::
+#   The rdtool format.  See RDoc::RD for details on the parser and format.
+# tomdoc::
+#   The TomDoc format as described by http://tomdoc.org/.  See RDoc::TomDoc
+#   for details on the parser and supported extensions.
+#
+# You can choose a markup format using the following methods:
+#
+# per project::
+#   If you build your documentation with rake use RDoc::Task#markup.
+#
+#   If you build your documentation by hand run:
+#
+#      rdoc --markup your_favorite_format --write-options
+#
+#   and commit <tt>.rdoc_options</tt> and ship it with your packaged gem.
+# per file::
+#   At the top of the file use the <tt>:markup:</tt> directive to set the
+#   default format for the rest of the file.
+# per comment::
+#   Use the <tt>:markup:</tt> directive at the top of a comment you want
+#   to write in a different format.
+#
+# = RDoc::Markup
+#
+# RDoc::Markup is extensible at runtime: you can add \new markup elements to
+# be recognized in the documents that RDoc::Markup parses.
+#
+# RDoc::Markup is intended to be the basis for a family of tools which share
+# the common requirement that simple, plain-text should be rendered in a
+# variety of different output formats and media.  It is envisaged that
+# RDoc::Markup could be the basis for formatting RDoc style comment blocks,
+# Wiki entries, and online FAQs.
+#
+# == Synopsis
+#
+# This code converts +input_string+ to HTML.  The conversion takes place in
+# the +convert+ method, so you can use the same RDoc::Markup converter to
+# convert multiple input strings.
+#
+#   require 'rdoc'
+#
+#   h = RDoc::Markup::ToHtml.new(RDoc::Options.new)
+#
+#   puts h.convert(input_string)
+#
+# You can extend the RDoc::Markup parser to recognize new markup
+# sequences, and to add regexp handling. Here we make WikiWords significant to
+# the parser, and also make the sequences {word} and \<no>text...</no> signify
+# strike-through text.  We then subclass the HTML output class to deal
+# with these:
+#
+#   require 'rdoc'
+#
+#   class WikiHtml < RDoc::Markup::ToHtml
+#     def handle_regexp_WIKIWORD(target)
+#       "<font color=red>" + target.text + "</font>"
+#     end
+#   end
+#
+#   markup = RDoc::Markup.new
+#   markup.add_word_pair("{", "}", :STRIKE)
+#   markup.add_html("no", :STRIKE)
+#
+#   markup.add_regexp_handling(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
+#
+#   wh = WikiHtml.new RDoc::Options.new, markup
+#   wh.add_tag(:STRIKE, "<strike>", "</strike>")
+#
+#   puts "<body>#{wh.convert ARGF.read}</body>"
+#
+# == Encoding
+#
+# Where Encoding support is available, RDoc will automatically convert all
+# documents to the same output encoding.  The output encoding can be set via
+# RDoc::Options#encoding and defaults to Encoding.default_external.
+#
+# = \RDoc Markup Reference
+#
+# See RDoc::MarkupReference.
+#
+#--
+# Original Author:: Dave Thomas,  dave@pragmaticprogrammer.com
+# License:: Ruby license
+class RDoc::Markup
+  ##
+  # An AttributeManager which handles inline markup.
+  attr_reader :attribute_manager
+  ##
+  # Parses +str+ into an RDoc::Markup::Document.
+  def self.parse str
+    RDoc::Markup::Parser.parse str
+  rescue RDoc::Markup::Parser::Error => e
+    $stderr.puts <<-EOF
+While parsing markup, RDoc encountered a #{e.class}:
+#{e}
+\tfrom #{e.backtrace.join "\n\tfrom "}
+---8<---
+#{text}
+---8<---
+RDoc #{RDoc::VERSION}
+Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} #{RUBY_RELEASE_DATE}
+Please file a bug report with the above information at:
+https://github.com/ruby/rdoc/issues
+    EOF
+    raise
+  end
+  ##
+  # Take a block of text and use various heuristics to determine its
+  # structure (paragraphs, lists, and so on).  Invoke an event handler as we
+  # identify significant chunks.
+  def initialize attribute_manager = nil
+    @attribute_manager = attribute_manager || RDoc::Markup::AttributeManager.new
+    @output = nil
+  end
+  ##
+  # Add to the sequences used to add formatting to an individual word (such
+  # as *bold*).  Matching entries will generate attributes that the output
+  # formatters can recognize by their +name+.
+  def add_word_pair(start, stop, name)
+    @attribute_manager.add_word_pair(start, stop, name)
+  end
+  ##
+  # Add to the sequences recognized as general markup.
+  def add_html(tag, name)
+    @attribute_manager.add_html(tag, name)
+  end
+  ##
+  # Add to other inline sequences.  For example, we could add WikiWords using
+  # something like:
+  #
+  #    parser.add_regexp_handling(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
+  #
+  # Each wiki word will be presented to the output formatter.
+  def add_regexp_handling(pattern, name)
+    @attribute_manager.add_regexp_handling(pattern, name)
+  end
+  ##
+  # We take +input+, parse it if necessary, then invoke the output +formatter+
+  # using a Visitor to render the result.
+  def convert input, formatter
+    document = case input
+               when RDoc::Markup::Document then
+                 input
+               else
+                 RDoc::Markup::Parser.parse input
+               end
+    document.accept formatter
+  end
+  autoload :Parser,                "#{__dir__}/markup/parser"
+  autoload :PreProcess,            "#{__dir__}/markup/pre_process"
+  # Inline markup classes
+  autoload :AttrChanger,           "#{__dir__}/markup/attr_changer"
+  autoload :AttrSpan,              "#{__dir__}/markup/attr_span"
+  autoload :Attributes,            "#{__dir__}/markup/attributes"
+  autoload :AttributeManager,      "#{__dir__}/markup/attribute_manager"
+  autoload :RegexpHandling,        "#{__dir__}/markup/regexp_handling"
+  # RDoc::Markup AST
+  autoload :BlankLine,             "#{__dir__}/markup/blank_line"
+  autoload :BlockQuote,            "#{__dir__}/markup/block_quote"
+  autoload :Document,              "#{__dir__}/markup/document"
+  autoload :HardBreak,             "#{__dir__}/markup/hard_break"
+  autoload :Heading,               "#{__dir__}/markup/heading"
+  autoload :Include,               "#{__dir__}/markup/include"
+  autoload :IndentedParagraph,     "#{__dir__}/markup/indented_paragraph"
+  autoload :List,                  "#{__dir__}/markup/list"
+  autoload :ListItem,              "#{__dir__}/markup/list_item"
+  autoload :Paragraph,             "#{__dir__}/markup/paragraph"
+  autoload :Table,                 "#{__dir__}/markup/table"
+  autoload :Raw,                   "#{__dir__}/markup/raw"
+  autoload :Rule,                  "#{__dir__}/markup/rule"
+  autoload :Verbatim,              "#{__dir__}/markup/verbatim"
+  # Formatters
+  autoload :Formatter,             "#{__dir__}/markup/formatter"
+  autoload :ToAnsi,                "#{__dir__}/markup/to_ansi"
+  autoload :ToBs,                  "#{__dir__}/markup/to_bs"
+  autoload :ToHtml,                "#{__dir__}/markup/to_html"
+  autoload :ToHtmlCrossref,        "#{__dir__}/markup/to_html_crossref"
+  autoload :ToHtmlSnippet,         "#{__dir__}/markup/to_html_snippet"
+  autoload :ToLabel,               "#{__dir__}/markup/to_label"
+  autoload :ToMarkdown,            "#{__dir__}/markup/to_markdown"
+  autoload :ToRdoc,                "#{__dir__}/markup/to_rdoc"
+  autoload :ToTableOfContents,     "#{__dir__}/markup/to_table_of_contents"
+  autoload :ToTest,                "#{__dir__}/markup/to_test"
+  autoload :ToTtOnly,              "#{__dir__}/markup/to_tt_only"
+end

data/vendor/bundle/ruby/3.2.0/gems/rdoc-6.6.0/lib/rdoc/meta_method.rb ADDED Viewed

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+##
+# MetaMethod represents a meta-programmed method
+class RDoc::MetaMethod < RDoc::AnyMethod
+end

data/vendor/bundle/ruby/3.2.0/gems/rdoc-6.6.0/lib/rdoc/method_attr.rb ADDED Viewed

@@ -0,0 +1,418 @@
+# frozen_string_literal: true
+##
+# Abstract class representing either a method or an attribute.
+class RDoc::MethodAttr < RDoc::CodeObject
+  include Comparable
+  ##
+  # Name of this method/attribute.
+  attr_accessor :name
+  ##
+  # public, protected, private
+  attr_accessor :visibility
+  ##
+  # Is this a singleton method/attribute?
+  attr_accessor :singleton
+  ##
+  # Source file token stream
+  attr_reader :text
+  ##
+  # Array of other names for this method/attribute
+  attr_reader :aliases
+  ##
+  # The method/attribute we're aliasing
+  attr_accessor :is_alias_for
+  #--
+  # The attributes below are for AnyMethod only.
+  # They are left here for the time being to
+  # allow ri to operate.
+  # TODO modify ri to avoid calling these on attributes.
+  #++
+  ##
+  # Parameters yielded by the called block
+  attr_reader :block_params
+  ##
+  # Parameters for this method
+  attr_accessor :params
+  ##
+  # Different ways to call this method
+  attr_accessor :call_seq
+  ##
+  # The call_seq or the param_seq with method name, if there is no call_seq.
+  attr_reader :arglists
+  ##
+  # Pretty parameter list for this method
+  attr_reader :param_seq
+  ##
+  # Creates a new MethodAttr from token stream +text+ and method or attribute
+  # name +name+.
+  #
+  # Usually this is called by super from a subclass.
+  def initialize text, name
+    super()
+    @text = text
+    @name = name
+    @aliases      = []
+    @is_alias_for = nil
+    @parent_name  = nil
+    @singleton    = nil
+    @visibility   = :public
+    @see = false
+    @arglists     = nil
+    @block_params = nil
+    @call_seq     = nil
+    @param_seq    = nil
+    @params       = nil
+  end
+  ##
+  # Resets cached data for the object so it can be rebuilt by accessor methods
+  def initialize_copy other # :nodoc:
+    @full_name = nil
+  end
+  def initialize_visibility # :nodoc:
+    super
+    @see = nil
+  end
+  ##
+  # Order by #singleton then #name
+  def <=>(other)
+    return unless other.respond_to?(:singleton) &&
+                  other.respond_to?(:name)
+    [     @singleton ? 0 : 1,       name] <=>
+    [other.singleton ? 0 : 1, other.name]
+  end
+  def == other # :nodoc:
+    equal?(other) or self.class == other.class and full_name == other.full_name
+  end
+  ##
+  # A method/attribute is documented if any of the following is true:
+  # - it was marked with :nodoc:;
+  # - it has a comment;
+  # - it is an alias for a documented method;
+  # - it has a +#see+ method that is documented.
+  def documented?
+    super or
+      (is_alias_for and is_alias_for.documented?) or
+      (see and see.documented?)
+  end
+  ##
+  # A method/attribute to look at,
+  # in particular if this method/attribute has no documentation.
+  #
+  # It can be a method/attribute of the superclass or of an included module,
+  # including the Kernel module, which is always appended to the included
+  # modules.
+  #
+  # Returns +nil+ if there is no such method/attribute.
+  # The +#is_alias_for+ method/attribute, if any, is not included.
+  #
+  # Templates may generate a "see also ..." if this method/attribute
+  # has documentation, and "see ..." if it does not.
+  def see
+    @see = find_see if @see == false
+    @see
+  end
+  ##
+  # Sets the store for this class or module and its contained code objects.
+  def store= store
+    super
+    @file = @store.add_file @file.full_name if @file
+  end
+  def find_see # :nodoc:
+    return nil if singleton || is_alias_for
+    # look for the method
+    other = find_method_or_attribute name
+    return other if other
+    # if it is a setter, look for a getter
+    return nil unless name =~ /[a-z_]=$/i   # avoid == or ===
+    return find_method_or_attribute name[0..-2]
+  end
+  def find_method_or_attribute name # :nodoc:
+    return nil unless parent.respond_to? :ancestors
+    searched = parent.ancestors
+    kernel = @store.modules_hash['Kernel']
+    searched << kernel if kernel &&
+      parent != kernel && !searched.include?(kernel)
+    searched.each do |ancestor|
+      next if String === ancestor
+      next if parent == ancestor
+      other = ancestor.find_method_named('#' + name) ||
+              ancestor.find_attribute_named(name)
+      return other if other
+    end
+    nil
+  end
+  ##
+  # Abstract method. Contexts in their building phase call this
+  # to register a new alias for this known method/attribute.
+  #
+  # - creates a new AnyMethod/Attribute named <tt>an_alias.new_name</tt>;
+  # - adds +self+ as an alias for the new method or attribute
+  # - adds the method or attribute to #aliases
+  # - adds the method or attribute to +context+.
+  def add_alias(an_alias, context)
+    raise NotImplementedError
+  end
+  ##
+  # HTML fragment reference for this method
+  def aref
+    type = singleton ? 'c' : 'i'
+    # % characters are not allowed in html names => dash instead
+    "#{aref_prefix}-#{type}-#{html_name}"
+  end
+  ##
+  # Prefix for +aref+, defined by subclasses.
+  def aref_prefix
+    raise NotImplementedError
+  end
+  ##
+  # Attempts to sanitize the content passed by the Ruby parser:
+  # remove outer parentheses, etc.
+  def block_params=(value)
+    # 'yield.to_s' or 'assert yield, msg'
+    return @block_params = '' if value =~ /^[\.,]/
+    # remove trailing 'if/unless ...'
+    return @block_params = '' if value =~ /^(if|unless)\s/
+    value = $1.strip if value =~ /^(.+)\s(if|unless)\s/
+    # outer parentheses
+    value = $1 if value =~ /^\s*\((.*)\)\s*$/
+    value = value.strip
+    # proc/lambda
+    return @block_params = $1 if value =~ /^(proc|lambda)(\s*\{|\sdo)/
+    # surrounding +...+ or [...]
+    value = $1.strip if value =~ /^\+(.*)\+$/
+    value = $1.strip if value =~ /^\[(.*)\]$/
+    return @block_params = '' if value.empty?
+    # global variable
+    return @block_params = 'str' if value =~ /^\$[&0-9]$/
+    # wipe out array/hash indices
+    value.gsub!(/(\w)\[[^\[]+\]/, '\1')
+    # remove @ from class/instance variables
+    value.gsub!(/@@?([a-z0-9_]+)/, '\1')
+    # method calls => method name
+    value.gsub!(/([A-Z:a-z0-9_]+)\.([a-z0-9_]+)(\s*\(\s*[a-z0-9_.,\s]*\s*\)\s*)?/) do
+      case $2
+      when 'to_s'      then $1
+      when 'const_get' then 'const'
+      when 'new' then
+        $1.split('::').last.  # ClassName => class_name
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          downcase
+      else
+        $2
+      end
+    end
+    # class prefixes
+    value.gsub!(/[A-Za-z0-9_:]+::/, '')
+    # simple expressions
+    value = $1 if value =~ /^([a-z0-9_]+)\s*[-*+\/]/
+    @block_params = value.strip
+  end
+  ##
+  # HTML id-friendly method/attribute name
+  def html_name
+    require 'cgi/util'
+    CGI.escape(@name.gsub('-', '-2D')).gsub('%','-').sub(/^-/, '')
+  end
+  ##
+  # Full method/attribute name including namespace
+  def full_name
+    @full_name ||= "#{parent_name}#{pretty_name}"
+  end
+  def inspect # :nodoc:
+    alias_for = @is_alias_for ? " (alias for #{@is_alias_for.name})" : nil
+    visibility = self.visibility
+    visibility = "forced #{visibility}" if force_documentation
+    "#<%s:0x%x %s (%s)%s>" % [
+      self.class, object_id,
+      full_name,
+      visibility,
+      alias_for,
+    ]
+  end
+  ##
+  # '::' for a class method/attribute, '#' for an instance method.
+  def name_prefix
+    @singleton ? '::' : '#'
+  end
+  ##
+  # Name for output to HTML.  For class methods the full name with a "." is
+  # used like +SomeClass.method_name+.  For instance methods the class name is
+  # used if +context+ does not match the parent.
+  #
+  # This is to help prevent people from using :: to call class methods.
+  def output_name context
+    return "#{name_prefix}#{@name}" if context == parent
+    "#{parent_name}#{@singleton ? '.' : '#'}#{@name}"
+  end
+  ##
+  # Method/attribute name with class/instance indicator
+  def pretty_name
+    "#{name_prefix}#{@name}"
+  end
+  ##
+  # Type of method/attribute (class or instance)
+  def type
+    singleton ? 'class' : 'instance'
+  end
+  ##
+  # Path to this method for use with HTML generator output.
+  def path
+    "#{@parent.path}##{aref}"
+  end
+  ##
+  # Name of our parent with special handling for un-marshaled methods
+  def parent_name
+    @parent_name || super
+  end
+  def pretty_print q # :nodoc:
+    alias_for =
+      if @is_alias_for.respond_to? :name then
+        "alias for #{@is_alias_for.name}"
+      elsif Array === @is_alias_for then
+        "alias for #{@is_alias_for.last}"
+      end
+    q.group 2, "[#{self.class.name} #{full_name} #{visibility}", "]" do
+      if alias_for then
+        q.breakable
+        q.text alias_for
+      end
+      if text then
+        q.breakable
+        q.text "text:"
+        q.breakable
+        q.pp @text
+      end
+      unless comment.empty? then
+        q.breakable
+        q.text "comment:"
+        q.breakable
+        q.pp @comment
+      end
+    end
+  end
+  ##
+  # Used by RDoc::Generator::JsonIndex to create a record for the search
+  # engine.
+  def search_record
+    [
+      @name,
+      full_name,
+      @name,
+      @parent.full_name,
+      path,
+      params,
+      snippet(@comment),
+    ]
+  end
+  def to_s # :nodoc:
+    if @is_alias_for
+      "#{self.class.name}: #{full_name} -> #{is_alias_for}"
+    else
+      "#{self.class.name}: #{full_name}"
+    end
+  end
+end