super-quick-rb 0.0.1

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

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+##
+# Handle common directives that can occur in a block of text:
+#
+#   \:include: filename
+#
+# Directives can be escaped by preceding them with a backslash.
+#
+# RDoc plugin authors can register additional directives to be handled by
+# using RDoc::Markup::PreProcess::register.
+#
+# Any directive that is not built-in to RDoc (including those registered via
+# plugins) will be stored in the metadata hash on the CodeObject the comment
+# is attached to.  See RDoc::Markup@Directives for the list of built-in
+# directives.
+
+class RDoc::Markup::PreProcess
+
+  ##
+  # An RDoc::Options instance that will be filled in with overrides from
+  # directives
+
+  attr_accessor :options
+
+  ##
+  # Adds a post-process handler for directives.  The handler will be called
+  # with the result RDoc::Comment (or text String) and the code object for the
+  # comment (if any).
+
+  def self.post_process(&block)
+    @post_processors << block
+  end
+
+  ##
+  # Registered post-processors
+
+  def self.post_processors
+    @post_processors
+  end
+
+  ##
+  # Registers +directive+ as one handled by RDoc.  If a block is given the
+  # directive will be replaced by the result of the block, otherwise the
+  # directive will be removed from the processed text.
+  #
+  # The block will be called with the directive name and the directive
+  # parameter:
+  #
+  #   RDoc::Markup::PreProcess.register 'my-directive' do |directive, param|
+  #     # replace text, etc.
+  #   end
+
+  def self.register(directive, &block)
+    @registered[directive] = block
+  end
+
+  ##
+  # Registered directives
+
+  def self.registered
+    @registered
+  end
+
+  ##
+  # Clears all registered directives and post-processors
+
+  def self.reset
+    @post_processors = []
+    @registered = {}
+  end
+
+  reset
+
+  ##
+  # Creates a new pre-processor for +input_file_name+ that will look for
+  # included files in +include_path+
+
+  def initialize(input_file_name, include_path)
+    @input_file_name = input_file_name
+    @include_path = include_path
+    @options = nil
+  end
+
+  ##
+  # Look for directives in the given +text+.
+  #
+  # Options that we don't handle are yielded.  If the block returns false the
+  # directive is restored to the text.  If the block returns nil or no block
+  # was given the directive is handled according to the registered directives.
+  # If a String was returned the directive is replaced with the string.
+  #
+  # If no matching directive was registered the directive is restored to the
+  # text.
+  #
+  # If +code_object+ is given and the directive is unknown then the
+  # directive's parameter is set as metadata on the +code_object+.  See
+  # RDoc::CodeObject#metadata for details.
+
+  def handle(text, code_object = nil, &block)
+    if RDoc::Comment === text then
+      comment = text
+      text = text.text
+    end
+
+    # regexp helper (square brackets for optional)
+    # $1      $2  $3        $4      $5
+    # [prefix][\]:directive:[spaces][param]newline
+    text = text.gsub(/^([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):([\w-]+):([ \t]*)(.+)?(\r?\n|$)/) do
+      # skip something like ':toto::'
+      next $& if $4.empty? and $5 and $5[0, 1] == ':'
+
+      # skip if escaped
+      next "#$1:#$3:#$4#$5\n" unless $2.empty?
+
+      # This is not in handle_directive because I didn't want to pass another
+      # argument into it
+      if comment and $3 == 'markup' then
+        next "#{$1.strip}\n" unless $5
+        comment.format = $5.downcase
+        next "#{$1.strip}\n"
+      end
+      handle_directive $1, $3, $5, code_object, text.encoding, &block
+    end
+
+    if comment then
+      comment.text = text
+    else
+      comment = text
+    end
+
+    run_post_processes(comment, code_object)
+
+    text
+  end
+
+  # Apply directives to a code object
+
+  def run_pre_processes(comment_text, code_object, start_line_no, type)
+    comment_text, directives = parse_comment(comment_text, start_line_no, type)
+    directives.each do |directive, (param, line_no)|
+      handle_directive('', directive, param, code_object)
+    end
+    if code_object.is_a?(RDoc::AnyMethod) && (call_seq, = directives['call-seq']) && call_seq
+      code_object.call_seq = call_seq.lines.map(&:chomp).reject(&:empty?).join("\n")
+    end
+    format, = directives['markup']
+    [comment_text, format]
+  end
+
+  # Perform post preocesses to a code object
+
+  def run_post_processes(comment, code_object)
+    self.class.post_processors.each do |handler|
+      handler.call comment, code_object
+    end
+  end
+
+  # Parse comment and return [normalized_comment_text, directives_hash]
+
+  def parse_comment(text, line_no, type)
+    RDoc::Comment.parse(text, @input_file_name, line_no, type) do |filename, prefix_indent|
+      include_file(filename, prefix_indent, text.encoding)
+    end
+  end
+
+  ##
+  # Performs the actions described by +directive+ and its parameter +param+.
+  #
+  # +code_object+ is used for directives that operate on a class or module.
+  # +prefix+ is used to ensure the replacement for handled directives is
+  # correct.  +encoding+ is used for the <tt>include</tt> directive.
+  #
+  # For a list of directives in RDoc see RDoc::Markup.
+  #--
+  # When 1.8.7 support is ditched prefix can be defaulted to ''
+
+  def handle_directive(prefix, directive, param, code_object = nil,
+                       encoding = nil)
+    blankline = "#{prefix.strip}\n"
+    directive = directive.downcase
+
+    case directive
+    when 'arg', 'args' then
+      return "#{prefix}:#{directive}: #{param}\n" unless code_object && code_object.kind_of?(RDoc::AnyMethod)
+
+      code_object.params = param
+
+      blankline
+    when 'category' then
+      if RDoc::Context === code_object then
+        section = code_object.add_section param
+        code_object.temporary_section = section
+      elsif RDoc::AnyMethod === code_object then
+        code_object.section_title = param
+      end
+
+      blankline # ignore category if we're not on an RDoc::Context
+    when 'doc' then
+      return blankline unless code_object
+      code_object.document_self = true
+      code_object.force_documentation = true
+
+      blankline
+    when 'enddoc' then
+      return blankline unless code_object
+      code_object.done_documenting = true
+
+      blankline
+    when 'include' then
+      filename = param.split(' ', 2).first
+      include_file filename, prefix, encoding
+    when 'nodoc' then
+      return blankline unless code_object
+      code_object.document_self = nil # notify nodoc
+      code_object.document_children = param !~ /all/i
+
+      blankline
+    when 'notnew', 'not_new', 'not-new' then
+      return blankline unless RDoc::AnyMethod === code_object
+
+      code_object.dont_rename_initialize = true
+
+      blankline
+    when 'startdoc' then
+      return blankline unless code_object
+
+      code_object.start_doc
+      code_object.force_documentation = true
+
+      blankline
+    when 'stopdoc' then
+      return blankline unless code_object
+
+      code_object.stop_doc
+
+      blankline
+    when 'yield', 'yields' then
+      return blankline unless code_object
+      # remove parameter &block
+      code_object.params = code_object.params.sub(/,?\s*&\w+/, '') if code_object.params
+
+      code_object.block_params = param || ''
+
+      blankline
+    else
+      result = yield directive, param if block_given?
+
+      case result
+      when nil then
+        code_object.metadata[directive] = param if code_object
+
+        if RDoc::Markup::PreProcess.registered.include? directive then
+          handler = RDoc::Markup::PreProcess.registered[directive]
+          result = handler.call directive, param if handler
+        else
+          result = "#{prefix}:#{directive}: #{param}\n"
+        end
+      when false then
+        result = "#{prefix}:#{directive}: #{param}\n"
+      end
+
+      result
+    end
+  end
+
+  ##
+  # Handles the <tt>:include: _filename_</tt> directive.
+  #
+  # If the first line of the included file starts with '#', and contains
+  # an encoding information in the form 'coding:' or 'coding=', it is
+  # removed.
+  #
+  # If all lines in the included file start with a '#', this leading '#'
+  # is removed before inclusion. The included content is indented like
+  # the <tt>:include:</tt> directive.
+  #--
+  # so all content will be verbatim because of the likely space after '#'?
+  # TODO shift left the whole file content in that case
+  # TODO comment stop/start #-- and #++ in included file must be processed here
+
+  def include_file(name, indent, encoding)
+    full_name = find_include_file name
+
+    unless full_name then
+      warn "Couldn't find file to include '#{name}' from #{@input_file_name}"
+      return ''
+    end
+
+    content = RDoc::Encoding.read_file full_name, encoding, true
+    content = RDoc::Encoding.remove_magic_comment content
+
+    # strip magic comment
+    content = content.sub(/\A# .*coding[=:].*$/, '').lstrip
+
+    # strip leading '#'s, but only if all lines start with them
+    if content =~ /^[^#]/ then
+      content.gsub(/^/, indent)
+    else
+      content.gsub(/^#?/, indent)
+    end
+  end
+
+  ##
+  # Look for the given file in the directory containing the current file,
+  # and then in each of the directories specified in the RDOC_INCLUDE path
+
+  def find_include_file(name)
+    to_search = [File.dirname(@input_file_name)].concat @include_path
+    to_search.each do |dir|
+      full_name = File.join(dir, name)
+      stat = File.stat(full_name) rescue next
+      return full_name if stat.readable?
+    end
+    nil
+  end
+
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RDoc
+  class Markup
+    # A section of text that is added to the output document as-is
+    class Raw
+      # The component parts of the list
+      #: Array[String]
+      attr_reader :parts
+
+      # Creates a new Raw containing +parts+
+      #: (*String) -> void
+      def initialize(*parts)
+        @parts = parts
+      end
+
+      # Appends +text+
+      #: (String) -> void
+      def <<(text)
+        @parts << text
+      end
+
+      #: (top) -> bool
+      def ==(other) # :nodoc:
+        self.class == other.class && @parts == other.parts
+      end
+
+      # Calls #accept_raw+ on +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_raw(self)
+      end
+
+      # Appends +other+'s parts
+      #: (Raw) -> void
+      def merge(other)
+        @parts.concat(other.parts)
+      end
+
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        self.class.name =~ /.*::(\w{1,4})/i
+
+        q.group(2, "[#{$1.downcase}: ", ']') do
+          q.seplist(@parts) do |part|
+            q.pp(part)
+          end
+        end
+      end
+
+      # Appends +texts+ onto this Paragraph
+      #: (*String) -> void
+      def push(*texts)
+        self.parts.concat(texts)
+      end
+
+      # The raw text
+      #: () -> String
+      def text
+        @parts.join(" ")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+##
+# A horizontal rule with a weight
+
+class RDoc::Markup::Rule < Struct.new :weight
+
+  ##
+  # Calls #accept_rule on +visitor+
+
+  def accept(visitor)
+    visitor.accept_rule self
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group 2, '[rule:', ']' do
+      q.pp weight
+    end
+  end
+
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RDoc
+  class Markup
+    # A section of table
+    class Table < Element
+      # Headers of each column
+      #: Array[String]
+      attr_accessor :header
+
+      # Alignments of each column
+      #: Array[Symbol?]
+      attr_accessor :align
+
+      # Body texts of each column
+      #: Array[String]
+      attr_accessor :body
+
+      #: (Array[String], Array[Symbol?], Array[String]) -> void
+      def initialize(header, align, body)
+        @header, @align, @body = header, align, body
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        self.class == other.class && @header == other.header &&
+          @align == other.align && @body == other.body
+      end
+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_table(@header, @body, @align)
+      end
+
+      # @override
+      #: (untyped) -> String
+      def pretty_print(q)
+        q.group 2, '[Table: ', ']' do
+          q.group 2, '[Head: ', ']' do
+            q.seplist @header.zip(@align) do |text, align|
+              q.pp text
+              if align
+                q.text ":"
+                q.breakable
+                q.text align.to_s
+              end
+            end
+          end
+          q.breakable
+          q.group 2, '[Body: ', ']' do
+            q.seplist @body do |body|
+              q.group 2, '[', ']' do
+                q.seplist body do |text|
+                  q.pp text
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+##
+# Outputs RDoc markup with vibrant ANSI color!
+
+class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
+
+  ##
+  # Creates a new ToAnsi visitor that is ready to output vibrant ANSI color!
+
+  def initialize
+    super
+
+    @headings.clear
+    @headings[1] = ["\e[1;32m", "\e[m"] # bold
+    @headings[2] = ["\e[4;32m", "\e[m"] # underline
+    @headings[3] = ["\e[32m",   "\e[m"] # just green
+  end
+
+  ##
+  # Maps attributes to ANSI sequences
+
+  ANSI_STYLE_CODES_ON = {
+    BOLD: 1,
+    TT: 7,
+    EM: 4,
+    STRIKE: 9
+  }
+
+  ANSI_STYLE_CODES_OFF = {
+    BOLD: 22,
+    TT: 27,
+    EM: 24,
+    STRIKE: 29
+  }
+
+  # Apply the given attributes by emitting ANSI sequences.
+  # Emitting attribute changes are deferred until new text is added and applied in batch.
+  # This method computes the necessary ANSI codes to transition from the
+  # current set of applied attributes to the new set of +attributes+.
+
+  def apply_attributes(attributes)
+    before = @applied_attributes
+    after = attributes.sort
+    return if before == after
+
+    if after.empty?
+      emit_inline("\e[m")
+    elsif !before.empty? && before.size > (before & after).size + 1
+      codes = after.map {|attr| ANSI_STYLE_CODES_ON[attr] }.compact
+      emit_inline("\e[#{[0, *codes].join(';')}m")
+    else
+      off_codes = (before - after).map {|attr| ANSI_STYLE_CODES_OFF[attr] }.compact
+      on_codes = (after - before).map {|attr| ANSI_STYLE_CODES_ON[attr] }.compact
+      emit_inline("\e[#{(off_codes + on_codes).join(';')}m")
+    end
+    @applied_attributes = attributes
+  end
+
+  def add_text(text)
+    attrs = @attributes.keys
+    if @applied_attributes != attrs
+      apply_attributes(attrs)
+    end
+    emit_inline(text)
+  end
+
+  def handle_inline(text)
+    @applied_attributes = []
+    res = super
+    res << "\e[m" unless @applied_attributes.empty?
+    @applied_attributes = []
+    res
+  end
+
+  ##
+  # Overrides indent width to ensure output lines up correctly.
+
+  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" unless res.length == 1
+              2
+            else
+              bullet = @list_index.last.to_s
+              @list_index[-1] = @list_index.last.succ
+              bullet.length + 2
+            end
+
+    @indent -= width
+  end
+
+  ##
+  # Adds coloring to note and label list items
+
+  def accept_list_item_start(list_item)
+    bullet = case @list_type.last
+             when :BULLET then
+               '*'
+             when :NOTE, :LABEL then
+               labels = Array(list_item.label).map do |label|
+                 attributes(label).strip
+               end.join "\n"
+
+               labels << ":\n" unless labels.empty?
+
+               labels
+             else
+               @list_index.last.to_s + '.'
+             end
+
+    case @list_type.last
+    when :NOTE, :LABEL then
+      @indent += 2
+      @prefix = bullet + (' ' * @indent)
+    else
+      @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
+
+      width = bullet.gsub(/\e\[[\d;]*m/, '').length + 1
+
+      @indent += width
+    end
+  end
+
+  def calculate_text_width(text)
+    text.gsub(/\e\[[\d;]*m/, '').size
+  end
+
+  ##
+  # Starts accepting with a reset screen
+
+  def start_accepting
+    super
+
+    @res = ["\e[0m"]
+  end
+
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+##
+# Outputs RDoc markup with hot backspace action!  You will probably need a
+# pager to use this output format.
+#
+# This formatter won't work on 1.8.6 because it lacks String#chars.
+
+class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
+
+  ##
+  # Returns a new ToBs that is ready for hot backspace action!
+
+  def initialize
+    super
+
+    @in_b  = false
+    @in_em = false
+  end
+
+  def handle_inline(text)
+    initial_style = []
+    initial_style << :BOLD if @in_b
+    initial_style << :EM   if @in_em
+    super(text, initial_style)
+  end
+
+  def add_text(text)
+    attrs = @attributes.keys
+    if attrs.include? :BOLD
+      styled = +''
+      text.chars.each do |c|
+        styled << "#{c}\b#{c}"
+      end
+      text = styled
+    elsif attrs.include? :EM
+      styled = +''
+      text.chars.each do |c|
+        styled << "_\b#{c}"
+      end
+      text = styled
+    end
+    emit_inline(text)
+  end
+
+  ##
+  # Makes heading text bold.
+
+  def accept_heading(heading)
+    use_prefix or @res << ' ' * @indent
+    @res << @headings[heading.level][0]
+    @in_b = true
+    @res << attributes(heading.text)
+    @in_b = false
+    @res << @headings[heading.level][1]
+    @res << "\n"
+  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 += 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
+
+  def calculate_text_width(text)
+    text.gsub(/_\x08/, '').gsub(/\x08./, '').size
+  end
+end