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

honeybadger 5.3.0 → 5.4.0

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