super-quick-rb 0.0.1

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

@@ -0,0 +1,215 @@
+# 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
+    super
+
+    @headings[1] = ['# ',      '']
+    @headings[2] = ['## ',     '']
+    @headings[3] = ['### ',    '']
+    @headings[4] = ['#### ',   '']
+    @headings[5] = ['##### ',  '']
+    @headings[6] = ['###### ', '']
+
+    add_regexp_handling_RDOCLINK
+
+    @hard_break = "  \n"
+  end
+
+  ##
+  # Finishes consumption of `list`
+
+  def accept_list_end(list)
+    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
+
+              @res << "\n"
+
+              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" unless bullets.empty?
+
+      @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
+
+  def add_tag(tag, simple_tag, content)
+    if content.match?(/\A[\w\s]+\z/)
+      emit_inline("#{simple_tag}#{content}#{simple_tag}")
+    else
+      emit_inline("<#{tag}>#{content}</#{tag}>")
+    end
+  end
+
+  def handle_tag(nodes, simple_tag, tag)
+    if nodes.size == 1 && String === nodes[0]
+      content = apply_regexp_handling(nodes[0]).map do |text, converted|
+        converted ? text : convert_string(text)
+      end.join
+      add_tag(tag, simple_tag, content)
+    else
+      emit_inline("<#{tag}>")
+      traverse_inline_nodes(nodes)
+      emit_inline("</#{tag}>")
+    end
+  end
+
+  def handle_TIDYLINK(label_part, url)
+    if url =~ /^rdoc-label:foot/ then
+      emit_inline(handle_rdoc_link(url))
+    else
+      emit_inline('[')
+      traverse_inline_nodes(label_part)
+      emit_inline("](#{url})")
+    end
+  end
+
+  def handle_BOLD(nodes)
+    handle_tag(nodes, '**', 'strong')
+  end
+
+  def handle_EM(nodes)
+    handle_tag(nodes, '*', 'em')
+  end
+
+  def handle_BOLD_WORD(word)
+    add_tag('strong', '**', convert_string(word))
+  end
+
+  def handle_EM_WORD(word)
+    add_tag('em', '*', convert_string(word))
+  end
+
+  def handle_TT(text)
+    add_tag('code', '`', convert_string(text))
+  end
+
+  def handle_STRIKE(nodes)
+    handle_tag(nodes, '~~', 's')
+  end
+
+  def handle_HARD_BREAK
+    emit_inline("  \n")
+  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-...: links into a Markdown.style links.
+
+  def handle_regexp_RDOCLINK(text)
+    handle_rdoc_link text
+  end
+
+end

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

@@ -0,0 +1,421 @@
+# frozen_string_literal: true
+##
+# Outputs RDoc markup as RDoc markup! (mostly)
+
+class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
+  DEFAULT_HEADINGS = {
+      1 => ['= ',      ''],
+      2 => ['== ',     ''],
+      3 => ['=== ',    ''],
+      4 => ['==== ',   ''],
+      5 => ['===== ',  ''],
+      6 => ['====== ', '']
+  }
+  DEFAULT_HEADINGS.default = []
+  DEFAULT_HEADINGS.freeze
+
+  ##
+  # Current indent amount for output in characters
+
+  attr_accessor :indent
+
+  ##
+  # Output width in characters
+
+  attr_accessor :width
+
+  ##
+  # Stack of current list indexes for alphabetic and numeric lists
+
+  attr_reader :list_index
+
+  ##
+  # Stack of list types
+
+  attr_reader :list_type
+
+  ##
+  # Stack of list widths for indentation
+
+  attr_reader :list_width
+
+  ##
+  # Prefix for the next list item.  See #use_prefix
+
+  attr_reader :prefix
+
+  ##
+  # Output accumulator
+
+  attr_reader :res
+
+  ##
+  # Creates a new formatter that will output (mostly) \RDoc markup
+
+  def initialize
+    super
+
+    @markup.add_regexp_handling(/\\\S/, :SUPPRESSED_CROSSREF)
+    @width = 78
+
+    @headings = DEFAULT_HEADINGS.dup
+    @hard_break = "\n"
+  end
+
+  ##
+  # Adds +blank_line+ to the output
+
+  def accept_blank_line(blank_line)
+    @res << "\n"
+  end
+
+  ##
+  # Adds +paragraph+ to the output
+
+  def accept_block_quote(block_quote)
+    @indent += 2
+
+    block_quote.parts.each do |part|
+      @prefix = '> '
+
+      part.accept self
+    end
+
+    @indent -= 2
+  end
+
+  ##
+  # Adds +heading+ to the output
+
+  def accept_heading(heading)
+    use_prefix or @res << ' ' * @indent
+    @res << @headings[heading.level][0]
+    @res << attributes(heading.text)
+    @res << @headings[heading.level][1]
+    @res << "\n"
+  end
+
+  ##
+  # Finishes consumption of +list+
+
+  def accept_list_end(list)
+    @list_index.pop
+    @list_type.pop
+    @list_width.pop
+  end
+
+  ##
+  # Finishes consumption of +list_item+
+
+  def accept_list_item_end(list_item)
+    width = case @list_type.last
+            when :BULLET then
+              2
+            when :NOTE, :LABEL then
+              if @prefix then
+                @res << @prefix.strip
+                @prefix = nil
+              end
+
+              @res << "\n"
+              2
+            else
+              bullet = @list_index.last.to_s
+              @list_index[-1] = @list_index.last.succ
+              bullet.length + 2
+            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
+      stripped_labels = Array(list_item.label).map do |label|
+        attributes(label).strip
+      end
+
+      bullets = case type
+      when :NOTE
+        stripped_labels.map { |b| "#{b}::" }
+      when :LABEL
+        stripped_labels.map { |b| "[#{b}]" }
+      end
+
+      bullets = bullets.join("\n")
+      bullets << "\n" unless stripped_labels.empty?
+
+      @prefix = ' ' * @indent
+      @indent += 2
+      @prefix << bullets + (' ' * @indent)
+    else
+      bullet = type == :BULLET ? '*' :  @list_index.last.to_s + '.'
+      @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
+      width = bullet.length + 1
+      @indent += width
+    end
+  end
+
+  ##
+  # Prepares the visitor for consuming +list+
+
+  def accept_list_start(list)
+    case list.type
+    when :BULLET then
+      @list_index << nil
+      @list_width << 1
+    when :LABEL, :NOTE then
+      @list_index << nil
+      @list_width << 2
+    when :LALPHA then
+      @list_index << 'a'
+      @list_width << list.items.length.to_s.length
+    when :NUMBER then
+      @list_index << 1
+      @list_width << list.items.length.to_s.length
+    when :UALPHA then
+      @list_index << 'A'
+      @list_width << list.items.length.to_s.length
+    else
+      raise RDoc::Error, "invalid list type #{list.type}"
+    end
+
+    @list_type << list.type
+  end
+
+  ##
+  # Adds +paragraph+ to the output
+
+  def accept_paragraph(paragraph)
+    text = paragraph.text @hard_break
+    wrap attributes text
+  end
+
+  ##
+  # Adds +paragraph+ to the output
+
+  def accept_indented_paragraph(paragraph)
+    @indent += paragraph.indent
+    text = paragraph.text @hard_break
+    wrap attributes text
+    @indent -= paragraph.indent
+  end
+
+  ##
+  # Adds +raw+ to the output
+
+  def accept_raw(raw)
+    @res << raw.parts.join("\n")
+  end
+
+  ##
+  # Adds +rule+ to the output
+
+  def accept_rule(rule)
+    use_prefix or @res << ' ' * @indent
+    @res << '-' * (@width - @indent)
+    @res << "\n"
+  end
+
+  ##
+  # Outputs +verbatim+ indented 2 columns
+
+  def accept_verbatim(verbatim)
+    indent = ' ' * (@indent + 2)
+
+    verbatim.parts.each do |part|
+      @res << indent unless part == "\n"
+      @res << part
+    end
+
+    @res << "\n"
+  end
+
+  ##
+  # Adds +table+ to the output
+
+  def accept_table(header, body, aligns)
+    header = header.map { |h| attributes h }
+    body = body.map { |row| row.map { |t| attributes t } }
+    widths = header.zip(*body).map do |cols|
+      cols.compact.map { |col| calculate_text_width(col) }.max
+    end
+    aligns = aligns.map do |a|
+      case a
+      when nil, :center
+        :center
+      when :left
+        :ljust
+      when :right
+        :rjust
+      end
+    end
+    @res << header.zip(widths, aligns).map do |h, w, a|
+      extra_width = h.size - calculate_text_width(h)
+      h.__send__(a, w + extra_width)
+    end.join("|").rstrip << "\n"
+    @res << widths.map {|w| "-" * w }.join("|") << "\n"
+    body.each do |row|
+      @res << widths.zip(aligns).each_with_index.map do |(w, a), i|
+        t = row[i] || ""
+        extra_width = t.size - calculate_text_width(t)
+        t.__send__(a, w + extra_width)
+      end.join("|").rstrip << "\n"
+    end
+  end
+
+  def calculate_text_width(text)
+    text.size
+  end
+
+  def handle_PLAIN_TEXT(text)
+    add_text(text)
+  end
+
+  def handle_REGEXP_HANDLING_TEXT(text)
+    add_text(text)
+  end
+
+  def handle_BOLD(target)
+    on(:BOLD)
+    super
+    off(:BOLD)
+  end
+
+  def handle_EM(target)
+    on(:EM)
+    super
+    off(:EM)
+  end
+
+  def handle_BOLD_WORD(word)
+    on(:BOLD)
+    super
+    off(:BOLD)
+  end
+
+  def handle_EM_WORD(word)
+    on(:EM)
+    super
+    off(:EM)
+  end
+
+  def handle_TT(code)
+    on(:TT)
+    super
+    off(:TT)
+  end
+
+  def handle_STRIKE(target)
+    on(:STRIKE)
+    super
+    off(:STRIKE)
+  end
+
+  def handle_HARD_BREAK
+    add_text("\n")
+  end
+
+  def handle_TIDYLINK(label_part, url)
+    super
+    add_text("( #{url} )")
+  end
+
+  def handle_inline(text, initial_attributes = [])
+    @attributes = Hash.new(0)
+    initial_attributes.each { |attr| on(attr) }
+    out = @inline_output = +''
+    super(text)
+    @inline_output = nil
+    out
+  end
+
+  def on(attr)
+    @attributes[attr] += 1
+  end
+
+  def off(attr)
+    @attributes[attr] -= 1
+    @attributes.delete(attr) if @attributes[attr] == 0
+  end
+
+  def add_text(text)
+    emit_inline(text)
+  end
+
+  def emit_inline(text)
+    @inline_output << text
+  end
+
+  ##
+  # Applies attribute-specific markup to +text+ using RDoc::Markup::InlineParser
+
+  def attributes(text)
+    handle_inline(text)
+  end
+
+  ##
+  # Returns the generated output
+
+  def end_accepting
+    @res.join
+  end
+
+  ##
+  # Removes preceding \\ from the suppressed crossref +target+
+
+  def handle_regexp_SUPPRESSED_CROSSREF(text)
+    text.sub('\\', '')
+  end
+
+  ##
+  # Prepares the visitor for text generation
+
+  def start_accepting
+    @res = [""]
+    @indent = 0
+    @prefix = nil
+
+    @list_index = []
+    @list_type  = []
+    @list_width = []
+  end
+
+  ##
+  # Adds the stored #prefix to the output and clears it.  Lists generate a
+  # prefix for later consumption.
+
+  def use_prefix
+    prefix, @prefix = @prefix, nil
+    @res << prefix if prefix
+
+    prefix
+  end
+
+  ##
+  # Wraps +text+ to #width
+
+  def wrap(text)
+    return unless text && !text.empty?
+
+    text_len = @width - @indent
+
+    text_len = 20 if text_len < 20
+
+    next_prefix = ' ' * @indent
+
+    prefix = @prefix || next_prefix
+    @prefix = nil
+
+    text.scan(/\G(?:([^ \n]{#{text_len}})(?=[^ \n])|(.{1,#{text_len}})(?:[ \n]|\z))/) do
+      @res << prefix << ($1 || $2) << "\n"
+      prefix = next_prefix
+    end
+  end
+
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+##
+# Extracts just the RDoc::Markup::Heading elements from a
+# RDoc::Markup::Document to help build a table of contents
+
+class RDoc::Markup::ToTableOfContents < RDoc::Markup::Formatter
+
+  @to_toc = nil
+
+  ##
+  # Singleton for table-of-contents generation
+
+  def self.to_toc
+    @to_toc ||= new
+  end
+
+  ##
+  # Output accumulator
+
+  attr_reader :res
+
+  ##
+  # Omits headings with a level less than the given level.
+
+  attr_accessor :omit_headings_below
+
+  def initialize # :nodoc:
+    super
+
+    @omit_headings_below = nil
+  end
+
+  ##
+  # Adds +document+ to the output, using its heading cutoff if present
+
+  def accept_document(document)
+    @omit_headings_below = document.omit_headings_below
+
+    super
+  end
+
+  ##
+  # Adds +heading+ to the table of contents
+
+  def accept_heading(heading)
+    @res << heading unless suppressed? heading
+  end
+
+  ##
+  # Returns the table of contents
+
+  def end_accepting
+    @res
+  end
+
+  ##
+  # Prepares the visitor for text generation
+
+  def start_accepting
+    @omit_headings_below = nil
+    @res = []
+  end
+
+  ##
+  # Returns true if +heading+ is below the display threshold
+
+  def suppressed?(heading)
+    return false unless @omit_headings_below
+
+    heading.level > @omit_headings_below
+  end
+
+  # :stopdoc:
+  alias accept_block_quote     ignore
+  alias accept_raw             ignore
+  alias accept_rule            ignore
+  alias accept_blank_line      ignore
+  alias accept_paragraph       ignore
+  alias accept_verbatim        ignore
+  alias accept_list_end        ignore
+  alias accept_list_item_start ignore
+  alias accept_list_item_end   ignore
+  alias accept_list_end_bullet ignore
+  alias accept_list_start      ignore
+  alias accept_table           ignore
+  # :startdoc:
+
+end