@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-5

package/lib/ruby/3.4.11/rdoc/markup/to_html_snippet.rb

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-##
-# Outputs RDoc markup as paragraphs with inline markup only.
-
-class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
-
-  ##
-  # After this many characters the input will be cut off.
-
-  attr_reader :character_limit
-
-  ##
-  # The number of characters seen so far.
-
-  attr_reader :characters # :nodoc:
-
-  ##
-  # The attribute bitmask
-
-  attr_reader :mask
-
-  ##
-  # After this many paragraphs the input will be cut off.
-
-  attr_reader :paragraph_limit
-
-  ##
-  # Count of paragraphs found
-
-  attr_reader :paragraphs
-
-  ##
-  # Creates a new ToHtmlSnippet formatter that will cut off the input on the
-  # next word boundary after the given number of +characters+ or +paragraphs+
-  # of text have been encountered.
-
-  def initialize(options, characters = 100, paragraphs = 3, markup = nil)
-    super options, markup
-
-    @character_limit = characters
-    @paragraph_limit = paragraphs
-
-    @characters = 0
-    @mask       = 0
-    @paragraphs = 0
-
-    @markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
-  end
-
-  ##
-  # Adds +heading+ to the output as a paragraph
-
-  def accept_heading(heading)
-    @res << "<p>#{to_html heading.text}\n"
-
-    add_paragraph
-  end
-
-  ##
-  # Raw sections are untrusted and ignored
-
-  alias accept_raw ignore
-
-  ##
-  # Rules are ignored
-
-  alias accept_rule ignore
-
-  ##
-  # Adds +paragraph+ to the output
-
-  def accept_paragraph(paragraph)
-    para = @in_list_entry.last || "<p>"
-
-    text = paragraph.text @hard_break
-
-    @res << "#{para}#{to_html text}\n"
-
-    add_paragraph
-  end
-
-  ##
-  # Finishes consumption of +list_item+
-
-  def accept_list_item_end(list_item)
-  end
-
-  ##
-  # Prepares the visitor for consuming +list_item+
-
-  def accept_list_item_start(list_item)
-    @res << list_item_start(list_item, @list.last)
-  end
-
-  ##
-  # Prepares the visitor for consuming +list+
-
-  def accept_list_start(list)
-    @list << list.type
-    @res << html_list_name(list.type, true)
-    @in_list_entry.push ''
-  end
-
-  ##
-  # Adds +verbatim+ to the output
-
-  def accept_verbatim(verbatim)
-    throw :done if @characters >= @character_limit
-    input = verbatim.text.rstrip
-
-    text = truncate input
-    text << ' ...' unless text == input
-
-    super RDoc::Markup::Verbatim.new text
-
-    add_paragraph
-  end
-
-  ##
-  # Prepares the visitor for HTML snippet generation
-
-  def start_accepting
-    super
-
-    @characters = 0
-  end
-
-  ##
-  # Removes escaping from the cross-references in +target+
-
-  def handle_regexp_CROSSREF(target)
-    target.text.sub(/\A\\/, '')
-  end
-
-  ##
-  # +target+ is a <code><br></code>
-
-  def handle_regexp_HARD_BREAK(target)
-    @characters -= 4
-    '<br>'
-  end
-
-  ##
-  # Lists are paragraphs, but notes and labels have a separator
-
-  def list_item_start(list_item, list_type)
-    throw :done if @characters >= @character_limit
-
-    case list_type
-    when :BULLET, :LALPHA, :NUMBER, :UALPHA then
-      "<p>"
-    when :LABEL, :NOTE then
-      labels = Array(list_item.label).map do |label|
-        to_html label
-      end.join ', '
-
-      labels << " &mdash; " unless labels.empty?
-
-      start = "<p>#{labels}"
-      @characters += 1 # try to include the label
-      start
-    else
-      raise RDoc::Error, "Invalid list type: #{list_type.inspect}"
-    end
-  end
-
-  ##
-  # Returns just the text of +link+, +url+ is only used to determine the link
-  # type.
-
-  def gen_url(url, text)
-    if url =~ /^rdoc-label:([^:]*)(?::(.*))?/ then
-      type = "link"
-    elsif url =~ /([A-Za-z]+):(.*)/ then
-      type = $1
-    else
-      type = "http"
-    end
-
-    if (type == "http" or type == "https" or type == "link") and
-       url =~ /\.(gif|png|jpg|jpeg|bmp)$/ then
-      ''
-    else
-      text.sub(%r%^#{type}:/*%, '')
-    end
-  end
-
-  ##
-  # In snippets, there are no lists
-
-  def html_list_name(list_type, open_tag)
-    ''
-  end
-
-  ##
-  # Throws +:done+ when paragraph_limit paragraphs have been encountered
-
-  def add_paragraph
-    @paragraphs += 1
-
-    throw :done if @paragraphs >= @paragraph_limit
-  end
-
-  ##
-  # Marks up +content+
-
-  def convert(content)
-    catch :done do
-      return super
-    end
-
-    end_accepting
-  end
-
-  ##
-  # Converts flow items +flow+
-
-  def convert_flow(flow)
-    throw :done if @characters >= @character_limit
-
-    res = []
-    @mask = 0
-
-    flow.each do |item|
-      case item
-      when RDoc::Markup::AttrChanger then
-        off_tags res, item
-        on_tags  res, item
-      when String then
-        text = convert_string item
-        res << truncate(text)
-      when RDoc::Markup::RegexpHandling then
-        text = convert_regexp_handling item
-        res << truncate(text)
-      else
-        raise "Unknown flow element: #{item.inspect}"
-      end
-
-      if @characters >= @character_limit then
-        off_tags res, RDoc::Markup::AttrChanger.new(0, @mask)
-        break
-      end
-    end
-
-    res << ' ...' if @characters >= @character_limit
-
-    res.join
-  end
-
-  ##
-  # Maintains a bitmask to allow HTML elements to be closed properly.  See
-  # RDoc::Markup::Formatter.
-
-  def on_tags(res, item)
-    @mask ^= item.turn_on
-
-    super
-  end
-
-  ##
-  # Maintains a bitmask to allow HTML elements to be closed properly.  See
-  # RDoc::Markup::Formatter.
-
-  def off_tags(res, item)
-    @mask ^= item.turn_off
-
-    super
-  end
-
-  ##
-  # Truncates +text+ at the end of the first word after the character_limit.
-
-  def truncate(text)
-    length = text.length
-    characters = @characters
-    @characters += length
-
-    return text if @characters < @character_limit
-
-    remaining = @character_limit - characters
-
-    text =~ /\A(.{#{remaining},}?)(\s|$)/m # TODO word-break instead of \s?
-
-    $1
-  end
-
-end

package/lib/ruby/3.4.11/rdoc/markup/to_joined_paragraph.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-##
-# Joins the parts of an RDoc::Markup::Paragraph into a single String.
-#
-# This allows for easier maintenance and testing of Markdown support.
-#
-# This formatter only works on Paragraph instances.  Attempting to process
-# other markup syntax items will not work.
-
-class RDoc::Markup::ToJoinedParagraph < RDoc::Markup::Formatter
-
-  def initialize # :nodoc:
-    super nil
-  end
-
-  def start_accepting # :nodoc:
-  end
-
-  def end_accepting # :nodoc:
-  end
-
-  ##
-  # Converts the parts of +paragraph+ to a single entry.
-
-  def accept_paragraph(paragraph)
-    parts = paragraph.parts.chunk do |part|
-      String === part
-    end.flat_map do |string, chunk|
-      string ? chunk.join.rstrip : chunk
-    end
-
-    paragraph.parts.replace parts
-  end
-
-  alias accept_block_quote     ignore
-  alias accept_heading         ignore
-  alias accept_list_end        ignore
-  alias accept_list_item_end   ignore
-  alias accept_list_item_start ignore
-  alias accept_list_start      ignore
-  alias accept_raw             ignore
-  alias accept_rule            ignore
-  alias accept_verbatim        ignore
-  alias accept_table           ignore
-
-end

package/lib/ruby/3.4.11/rdoc/markup/to_label.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-require 'cgi/escape'
-
-##
-# Creates HTML-safe labels suitable for use in id attributes.  Tidylinks are
-# converted to their link part and cross-reference links have the suppression
-# marks removed (\\SomeClass is converted to SomeClass).
-
-class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
-
-  attr_reader :res # :nodoc:
-
-  ##
-  # Creates a new formatter that will output HTML-safe labels
-
-  def initialize(markup = nil)
-    super nil, markup
-
-    @markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
-    @markup.add_regexp_handling(/(((\{.*?\})|\b\S+?)\[\S+?\])/, :TIDYLINK)
-
-    add_tag :BOLD, '', ''
-    add_tag :TT,   '', ''
-    add_tag :EM,   '', ''
-
-    @res = []
-  end
-
-  ##
-  # Converts +text+ to an HTML-safe label
-
-  def convert(text)
-    label = convert_flow @am.flow text
-
-    CGI.escape(label).gsub('%', '-').sub(/^-/, '')
-  end
-
-  ##
-  # Converts the CROSSREF +target+ to plain text, removing the suppression
-  # marker, if any
-
-  def handle_regexp_CROSSREF(target)
-    text = target.text
-
-    text.sub(/^\\/, '')
-  end
-
-  ##
-  # Converts the TIDYLINK +target+ to just the text part
-
-  def handle_regexp_TIDYLINK(target)
-    text = target.text
-
-    return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
-
-    $1
-  end
-
-  alias accept_blank_line         ignore
-  alias accept_block_quote        ignore
-  alias accept_heading            ignore
-  alias accept_list_end           ignore
-  alias accept_list_item_end      ignore
-  alias accept_list_item_start    ignore
-  alias accept_list_start         ignore
-  alias accept_paragraph          ignore
-  alias accept_raw                ignore
-  alias accept_rule               ignore
-  alias accept_verbatim           ignore
-  alias end_accepting             ignore
-  alias handle_regexp_HARD_BREAK  ignore
-  alias start_accepting           ignore
-
-end

package/lib/ruby/3.4.11/rdoc/markup/to_markdown.rb

@@ -1,191 +0,0 @@
-# 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(markup = nil)
-    super
-
-    @headings[1] = ['# ',      '']
-    @headings[2] = ['## ',     '']
-    @headings[3] = ['### ',    '']
-    @headings[4] = ['#### ',   '']
-    @headings[5] = ['##### ',  '']
-    @headings[6] = ['###### ', '']
-
-    add_regexp_handling_RDOCLINK
-    add_regexp_handling_TIDYLINK
-
-    @hard_break = "  \n"
-  end
-
-  ##
-  # Maps attributes to HTML sequences
-
-  def init_tags
-    add_tag :BOLD, '**', '**'
-    add_tag :EM,   '*',  '*'
-    add_tag :TT,   '`',  '`'
-  end
-
-  ##
-  # Adds a newline to the output
-
-  def handle_regexp_HARD_BREAK(target)
-    "  \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
-
-  ##
-  # 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 markup tidylink into a Markdown.style link.
-
-  def handle_regexp_TIDYLINK(target)
-    text = target.text
-
-    return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
-
-    label = $1
-    url   = $2
-
-    if url =~ /^rdoc-label:foot/ then
-      handle_rdoc_link url
-    else
-      gen_url url, label
-    end
-  end
-
-  ##
-  # Converts the rdoc-...: links into a Markdown.style links.
-
-  def handle_regexp_RDOCLINK(target)
-    handle_rdoc_link target.text
-  end
-
-end