docspring 3.0.0 → 3.1.0

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/markup/pre_process.rb

@@ -0,0 +1,318 @@
+# 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
+    first_line = 1
+    if RDoc::Comment === text then
+      comment = text
+      text = text.text
+      first_line = comment.line || 1
+    end
+
+    # regexp helper (square brackets for optional)
+    # $1      $2  $3        $4      $5
+    # [prefix][\]:directive:[spaces][param]newline
+    text = text.lines.map.with_index(first_line) do |line, num|
+      next line unless line =~ /\A([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):([\w-]+):([ \t]*)(.+)?(\r?\n|$)/
+      # 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, num, &block
+    end.join
+
+    if comment then
+      comment.text = text
+    else
+      comment = text
+    end
+
+    self.class.post_processors.each do |handler|
+      handler.call comment, code_object
+    end
+
+    text
+  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, line = 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 'main' then
+      @options.main_page = param if @options.respond_to? :main_page
+      warn <<~MSG
+        The :main: directive is deprecated and will be removed in RDoc 7.
+
+        You can use these options to specify the initial page displayed instead:
+        - `--main=#{param}` via the command line
+        - `rdoc.main = "#{param}"` if you use `RDoc::Task`
+        - `main_page: #{param}` in your `.rdoc_options` file
+      MSG
+
+      blankline
+    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 'title' then
+      @options.default_title = param if @options.respond_to? :default_title=
+
+      warn <<~MSG
+        The :title: directive is deprecated and will be removed in RDoc 7.
+
+        You can use these options to specify the title displayed instead:
+        - `--title=#{param}` via the command line
+        - `rdoc.title = "#{param}"` if you use `RDoc::Task`
+        - `title: #{param}` in your `.rdoc_options` file
+      MSG
+
+      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, line 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/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/markup/raw.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+##
+# A section of text that is added to the output document as-is
+
+class RDoc::Markup::Raw
+
+  ##
+  # The component parts of the list
+
+  attr_reader :parts
+
+  ##
+  # Creates a new Raw containing +parts+
+
+  def initialize *parts
+    @parts = []
+    @parts.concat parts
+  end
+
+  ##
+  # Appends +text+
+
+  def << text
+    @parts << text
+  end
+
+  def == other # :nodoc:
+    self.class == other.class and @parts == other.parts
+  end
+
+  ##
+  # Calls #accept_raw+ on +visitor+
+
+  def accept visitor
+    visitor.accept_raw self
+  end
+
+  ##
+  # Appends +other+'s parts
+
+  def merge other
+    @parts.concat other.parts
+  end
+
+  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
+
+  def push *texts
+    self.parts.concat texts
+  end
+
+  ##
+  # The raw text
+
+  def text
+    @parts.join ' '
+  end
+
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/markup/regexp_handling.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+##
+# Hold details of a regexp handling sequence
+
+class RDoc::Markup::RegexpHandling
+
+  ##
+  # Regexp handling type
+
+  attr_reader   :type
+
+  ##
+  # Regexp handling text
+
+  attr_accessor :text
+
+  ##
+  # Creates a new regexp handling sequence of +type+ with +text+
+
+  def initialize(type, text)
+    @type, @text = type, text
+  end
+
+  ##
+  # Regexp handlings are equal when the have the same text and type
+
+  def ==(o)
+    self.text == o.text && self.type == o.type
+  end
+
+  def inspect # :nodoc:
+    "#<RDoc::Markup::RegexpHandling:0x%x @type=%p, @text=%p>" % [
+      object_id, @type, text.dump]
+  end
+
+  def to_s # :nodoc:
+    "RegexpHandling: type=#{type} text=#{text.dump}"
+  end
+
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.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/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/markup/table.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+##
+# A section of table
+
+class RDoc::Markup::Table
+  # headers of each column
+  attr_accessor :header
+
+  # alignments of each column
+  attr_accessor :align
+
+  # body texts of each column
+  attr_accessor :body
+
+  # Creates new instance
+  def initialize header, align, body
+    @header, @align, @body = header, align, body
+  end
+
+  # :stopdoc:
+  def == other
+    self.class == other.class and
+      @header == other.header and
+      @align == other.align and
+      @body == other.body
+  end
+
+  def accept visitor
+    visitor.accept_table @header, @body, @align
+  end
+
+  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

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/markup/to_ansi.rb

@@ -0,0 +1,93 @@
+# 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 markup = nil
+    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
+
+  def init_tags
+    add_tag :BOLD, "\e[1m", "\e[m"
+    add_tag :TT,   "\e[7m", "\e[m"
+    add_tag :EM,   "\e[4m", "\e[m"
+  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
+
+  ##
+  # Starts accepting with a reset screen
+
+  def start_accepting
+    super
+
+    @res = ["\e[0m"]
+  end
+
+end

data/vendor/bundle/ruby/3.3.0/gems/rdoc-6.12.0/lib/rdoc/markup/to_bs.rb

@@ -0,0 +1,102 @@
+# 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 markup = nil
+    super
+
+    @in_b  = false
+    @in_em = false
+  end
+
+  ##
+  # Sets a flag that is picked up by #annotate to do the right thing in
+  # #convert_string
+
+  def init_tags
+    add_tag :BOLD, '+b', '-b'
+    add_tag :EM,   '+_', '-_'
+    add_tag :TT,   '', ''   # we need in_tt information maintained
+  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
+
+  ##
+  # Turns on or off regexp handling for +convert_string+
+
+  def annotate tag
+    case tag
+    when '+b' then @in_b = true
+    when '-b' then @in_b = false
+    when '+_' then @in_em = true
+    when '-_' then @in_em = false
+    end
+    ''
+  end
+
+  ##
+  # Calls convert_string on the result of convert_regexp_handling
+
+  def convert_regexp_handling target
+    convert_string super
+  end
+
+  ##
+  # Adds bold or underline mixed with backspaces
+
+  def convert_string string
+    return string unless @in_b or @in_em
+    chars = if @in_b then
+              string.chars.map do |char| "#{char}\b#{char}" end
+            elsif @in_em then
+              string.chars.map do |char| "_\b#{char}" end
+            end
+
+    chars.join
+  end
+
+end