super-quick-rb 0.0.1

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+##
+# This Markup outputter is used for testing purposes.
+
+class RDoc::Markup::ToTest < RDoc::Markup::Formatter
+
+  # :stopdoc:
+
+  ##
+  # :section: Visitor
+
+  def start_accepting
+    @res = []
+    @list = []
+  end
+
+  def end_accepting
+    @res
+  end
+
+  def handle_PLAIN_TEXT(text)
+    @res << text
+  end
+
+  def handle_REGEXP_HANDLING_TEXT(text)
+    @res << text
+  end
+
+  def accept_paragraph(paragraph)
+    handle_inline(paragraph.text)
+  end
+
+  def accept_raw(raw)
+    @res << raw.parts.join
+  end
+
+  def accept_verbatim(verbatim)
+    @res << verbatim.text.gsub(/^(\S)/, '  \1')
+  end
+
+  def accept_list_start(list)
+    @list << case list.type
+             when :BULLET then
+               '*'
+             when :NUMBER then
+               '1'
+             else
+               list.type
+             end
+  end
+
+  def accept_list_end(list)
+    @list.pop
+  end
+
+  def accept_list_item_start(list_item)
+    @res << "#{' ' * (@list.size - 1)}#{@list.last}: "
+  end
+
+  def accept_list_item_end(list_item)
+  end
+
+  def accept_blank_line(blank_line)
+    @res << "\n"
+  end
+
+  def accept_heading(heading)
+    @res << "#{'=' * heading.level} #{heading.text}"
+  end
+
+  def accept_rule(rule)
+    @res << '-' * rule.weight
+  end
+
+  # :startdoc:
+
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+##
+# Extracts sections of text enclosed in plus, tt or code.  Used to discover
+# undocumented parameters.
+
+class RDoc::Markup::ToTtOnly < RDoc::Markup::Formatter
+
+  ##
+  # Stack of list types
+
+  attr_reader :list_type
+
+  ##
+  # Output accumulator
+
+  attr_reader :res
+
+  ##
+  # Adds tts from +block_quote+ to the output
+
+  def accept_block_quote(block_quote)
+    tt_sections block_quote.text
+  end
+
+  ##
+  # Pops the list type for +list+ from #list_type
+
+  def accept_list_end(list)
+    @list_type.pop
+  end
+
+  ##
+  # Pushes the list type for +list+ onto #list_type
+
+  def accept_list_start(list)
+    @list_type << list.type
+  end
+
+  ##
+  # Prepares the visitor for consuming +list_item+
+
+  def accept_list_item_start(list_item)
+    case @list_type.last
+    when :NOTE, :LABEL then
+      Array(list_item.label).map do |label|
+        tt_sections label
+      end.flatten
+    end
+  end
+
+  ##
+  # Adds +paragraph+ to the output
+
+  def accept_paragraph(paragraph)
+    tt_sections(paragraph.text)
+  end
+
+  ##
+  # Does nothing to +markup_item+ because it doesn't have any user-built
+  # content
+
+  def do_nothing(markup_item)
+  end
+
+  alias accept_blank_line    do_nothing # :nodoc:
+  alias accept_heading       do_nothing # :nodoc:
+  alias accept_list_item_end do_nothing # :nodoc:
+  alias accept_raw           do_nothing # :nodoc:
+  alias accept_rule          do_nothing # :nodoc:
+  alias accept_verbatim      do_nothing # :nodoc:
+
+  ##
+  # Extracts tt sections from +text+
+
+  def tt_sections(text)
+    parsed = RDoc::Markup::InlineParser.new(text).parse
+    traverse = -> node {
+      next if String === node
+      if node[:type] == :TT
+        res << nil
+        res << node[:children][0] || ''
+        res << nil
+      else
+        node[:children].each(&traverse)
+      end
+    }
+    parsed.each(&traverse)
+    res
+  end
+
+  ##
+  # Returns an Array of items that were wrapped in plus, tt or code.
+
+  def end_accepting
+    @res.compact
+  end
+
+  ##
+  # Prepares the visitor for gathering tt sections
+
+  def start_accepting
+    @res = []
+
+    @list_type = []
+  end
+
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+##
+# A section of verbatim text
+
+class RDoc::Markup::Verbatim < RDoc::Markup::Raw
+
+  ##
+  # Format of this verbatim section
+
+  attr_accessor :format
+
+  def initialize(*parts) # :nodoc:
+    super
+
+    @format = nil
+  end
+
+  def ==(other) # :nodoc:
+    super and @format == other.format
+  end
+
+  ##
+  # Calls #accept_verbatim on +visitor+
+
+  def accept(visitor)
+    visitor.accept_verbatim self
+  end
+
+  ##
+  # Collapses 3+ newlines into two newlines
+
+  def normalize
+    parts = []
+
+    newlines = 0
+
+    @parts.each do |part|
+      case part
+      when /^\s*\n/ then
+        newlines += 1
+        parts << part if newlines == 1
+      else
+        newlines = 0
+        parts << part
+      end
+    end
+
+    parts.pop if parts.last =~ /\A\r?\n\z/
+
+    @parts = parts
+  end
+
+  def pretty_print(q) # :nodoc:
+    self.class.name =~ /.*::(\w{1,4})/i
+
+    q.group 2, "[#{$1.downcase}: ", ']' do
+      if @format then
+        q.text "format: #{@format}"
+        q.breakable
+      end
+
+      q.seplist @parts do |part|
+        q.pp part
+      end
+    end
+  end
+
+  ##
+  # Is this verbatim section Ruby code?
+
+  def ruby?
+    @format ||= nil # TODO for older ri data, switch the tree to marshal_dump
+    @format == :ruby || @format == :rb
+  end
+
+  ##
+  # The text of the section
+
+  def text
+    @parts.join
+  end
+
+end

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

@@ -0,0 +1,219 @@
+# 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.
+#
+# = Markup Formats
+#
+# +RDoc+ supports these markup formats:
+#
+# - +rdoc+:
+#   the +RDoc+ markup format;
+#   see {RDoc Markup Reference}[rdoc-ref:doc/markup_reference/rdoc.rdoc]
+# - +markdown+:
+#   The +markdown+ markup format as described in
+#   the {Markdown Guide}[https://www.markdownguide.org];
+#   see RDoc::Markdown.
+# - +rd+:
+#   the +rd+ markup format format;
+#   see RDoc::RD.
+# - +tomdoc+:
+#   the TomDoc format as described in
+#   {TomDoc for Ruby}[http://tomdoc.org];
+#   see RDoc::TomDoc.
+#
+# 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 + "</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 Markup Reference}[rdoc-ref:doc/markup_reference/rdoc.rdoc]
+#
+#--
+# Original Author:: Dave Thomas,  dave@pragmaticprogrammer.com
+# License:: Ruby license
+
+class RDoc::Markup
+
+  # Array of regexp handling pattern and its name. A regexp handling
+  # sequence is something like a WikiWord
+
+  attr_reader :regexp_handlings
+
+  ##
+  # 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
+    @regexp_handlings = []
+    @output = nil
+  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)
+    @regexp_handlings << [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 :InlineParser,          "#{__dir__}/markup/inline_parser"
+  autoload :PreProcess,            "#{__dir__}/markup/pre_process"
+
+  # RDoc::Markup AST
+  autoload :BlankLine,             "#{__dir__}/markup/blank_line"
+  autoload :BlockQuote,            "#{__dir__}/markup/block_quote"
+  autoload :Document,              "#{__dir__}/markup/document"
+  autoload :Element,               "#{__dir__}/markup/element"
+  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