ric 0.12.0 → 0.12.2

data/vendor/bundle/ruby/2.5.0/gems/rdoc-6.1.1/lib/rdoc/context/section.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+##
+# A section of documentation like:
+#
+#   # :section: The title
+#   # The body
+#
+# Sections can be referenced multiple times and will be collapsed into a
+# single section.
+
+class RDoc::Context::Section
+
+  include RDoc::Text
+
+  MARSHAL_VERSION = 0 # :nodoc:
+
+  ##
+  # Section comment
+
+  attr_reader :comment
+
+  ##
+  # Section comments
+
+  attr_reader :comments
+
+  ##
+  # Context this Section lives in
+
+  attr_reader :parent
+
+  ##
+  # Section title
+
+  attr_reader :title
+
+  @@sequence = "SEC00000"
+
+  ##
+  # Creates a new section with +title+ and +comment+
+
+  def initialize parent, title, comment
+    @parent = parent
+    @title = title ? title.strip : title
+
+    @@sequence = @@sequence.succ
+    @sequence = @@sequence.dup
+
+    @comments = []
+
+    add_comment comment
+  end
+
+  ##
+  # Sections are equal when they have the same #title
+
+  def == other
+    self.class === other and @title == other.title
+  end
+
+  alias eql? ==
+
+  ##
+  # Adds +comment+ to this section
+
+  def add_comment comment
+    comment = extract_comment comment
+
+    return if comment.empty?
+
+    case comment
+    when RDoc::Comment then
+      @comments << comment
+    when RDoc::Markup::Document then
+      @comments.concat comment.parts
+    when Array then
+      @comments.concat comment
+    else
+      raise TypeError, "unknown comment type: #{comment.inspect}"
+    end
+  end
+
+  ##
+  # Anchor reference for linking to this section
+
+  def aref
+    title = @title || '[untitled]'
+
+    CGI.escape(title).gsub('%', '-').sub(/^-/, '')
+  end
+
+  ##
+  # Extracts the comment for this section from the original comment block.
+  # If the first line contains :section:, strip it and use the rest.
+  # Otherwise remove lines up to the line containing :section:, and look
+  # for those lines again at the end and remove them. This lets us write
+  #
+  #   # :section: The title
+  #   # The body
+
+  def extract_comment comment
+    case comment
+    when Array then
+      comment.map do |c|
+        extract_comment c
+      end
+    when nil
+      RDoc::Comment.new ''
+    when RDoc::Comment then
+      if comment.text =~ /^#[ \t]*:section:.*\n/ then
+        start = $`
+        rest = $'
+
+        comment.text = if start.empty? then
+                         rest
+                       else
+                         rest.sub(/#{start.chomp}\Z/, '')
+                       end
+      end
+
+      comment
+    when RDoc::Markup::Document then
+      comment
+    else
+      raise TypeError, "unknown comment #{comment.inspect}"
+    end
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %p>" % [self.class, object_id, title]
+  end
+
+  def hash # :nodoc:
+    @title.hash
+  end
+
+  ##
+  # The files comments in this section come from
+
+  def in_files
+    return [] if @comments.empty?
+
+    case @comments
+    when Array then
+      @comments.map do |comment|
+        comment.file
+      end
+    when RDoc::Markup::Document then
+      @comment.parts.map do |document|
+        document.file
+      end
+    else
+      raise RDoc::Error, "BUG: unknown comment class #{@comments.class}"
+    end
+  end
+
+  ##
+  # Serializes this Section.  The title and parsed comment are saved, but not
+  # the section parent which must be restored manually.
+
+  def marshal_dump
+    [
+      MARSHAL_VERSION,
+      @title,
+      parse,
+    ]
+  end
+
+  ##
+  # De-serializes this Section.  The section parent must be restored manually.
+
+  def marshal_load array
+    @parent  = nil
+
+    @title    = array[1]
+    @comments = array[2]
+  end
+
+  ##
+  # Parses +comment_location+ into an RDoc::Markup::Document composed of
+  # multiple RDoc::Markup::Documents with their file set.
+
+  def parse
+    case @comments
+    when String then
+      super
+    when Array then
+      docs = @comments.map do |comment, location|
+        doc = super comment
+        doc.file = location if location
+        doc
+      end
+
+      RDoc::Markup::Document.new(*docs)
+    when RDoc::Comment then
+      doc = super @comments.text, comments.format
+      doc.file = @comments.location
+      doc
+    when RDoc::Markup::Document then
+      return @comments
+    else
+      raise ArgumentError, "unknown comment class #{comments.class}"
+    end
+  end
+
+  ##
+  # The section's title, or 'Top Section' if the title is nil.
+  #
+  # This is used by the table of contents template so the name is silly.
+
+  def plain_html
+    @title || 'Top Section'
+  end
+
+  ##
+  # Removes a comment from this section if it is from the same file as
+  # +comment+
+
+  def remove_comment comment
+    return if @comments.empty?
+
+    case @comments
+    when Array then
+      @comments.delete_if do |my_comment|
+        my_comment.file == comment.file
+      end
+    when RDoc::Markup::Document then
+      @comments.parts.delete_if do |document|
+        document.file == comment.file.name
+      end
+    else
+      raise RDoc::Error, "BUG: unknown comment class #{@comments.class}"
+    end
+  end
+
+  ##
+  # Section sequence number (deprecated)
+
+  def sequence
+    warn "RDoc::Context::Section#sequence is deprecated, use #aref"
+    @sequence
+  end
+
+end
+

data/vendor/bundle/ruby/2.5.0/gems/rdoc-6.1.1/lib/rdoc/cross_reference.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+##
+# RDoc::CrossReference is a reusable way to create cross references for names.
+
+class RDoc::CrossReference
+
+  ##
+  # Regular expression to match class references
+  #
+  # 1. There can be a '\\' in front of text to suppress the cross-reference
+  # 2. There can be a '::' in front of class names to reference from the
+  #    top-level namespace.
+  # 3. The method can be followed by parenthesis (not recommended)
+
+  CLASS_REGEXP_STR = '\\\\?((?:\:{2})?[A-Z]\w*(?:\:\:\w+)*)'
+
+  ##
+  # Regular expression to match method references.
+  #
+  # See CLASS_REGEXP_STR
+
+  METHOD_REGEXP_STR = '([a-z]\w*[!?=]?|%|===|\[\]=?|<<|>>|-|\+|\*)(?:\([\w.+*/=<>-]*\))?'
+
+  ##
+  # Regular expressions matching text that should potentially have
+  # cross-reference links generated are passed to add_regexp_handling. Note
+  # that these expressions are meant to pick up text for which cross-references
+  # have been suppressed, since the suppression characters are removed by the
+  # code that is triggered.
+
+  CROSSREF_REGEXP = /(?:^|\s)
+                     (
+                      (?:
+                       # A::B::C.meth
+                       #{CLASS_REGEXP_STR}(?:[.#]|::)#{METHOD_REGEXP_STR}
+
+                       # Stand-alone method (preceded by a #)
+                       | \\?\##{METHOD_REGEXP_STR}
+
+                       # Stand-alone method (preceded by ::)
+                       | ::#{METHOD_REGEXP_STR}
+
+                       # A::B::C
+                       # The stuff after CLASS_REGEXP_STR is a
+                       # nasty hack.  CLASS_REGEXP_STR unfortunately matches
+                       # words like dog and cat (these are legal "class"
+                       # names in Fortran 95).  When a word is flagged as a
+                       # potential cross-reference, limitations in the markup
+                       # engine suppress other processing, such as typesetting.
+                       # This is particularly noticeable for contractions.
+                       # In order that words like "can't" not
+                       # be flagged as potential cross-references, only
+                       # flag potential class cross-references if the character
+                       # after the cross-reference is a space, sentence
+                       # punctuation, tag start character, or attribute
+                       # marker.
+                       | #{CLASS_REGEXP_STR}(?=[@\s).?!,;<\000]|\z)
+
+                       # Things that look like filenames
+                       # The key thing is that there must be at least
+                       # one special character (period, slash, or
+                       # underscore).
+                       | (?:\.\.\/)*[-\/\w]+[_\/.][-\w\/.]+
+
+                       # Things that have markup suppressed
+                       # Don't process things like '\<' in \<tt>, though.
+                       # TODO: including < is a hack, not very satisfying.
+                       | \\[^\s<]
+                      )
+
+                      # labels for headings
+                      (?:@[\w+%-]+(?:\.[\w|%-]+)?)?
+                     )/x
+
+  ##
+  # Version of CROSSREF_REGEXP used when <tt>--hyperlink-all</tt> is specified.
+
+  ALL_CROSSREF_REGEXP = /
+                     (?:^|\s)
+                     (
+                      (?:
+                       # A::B::C.meth
+                       #{CLASS_REGEXP_STR}(?:[.#]|::)#{METHOD_REGEXP_STR}
+
+                       # Stand-alone method
+                       | \\?#{METHOD_REGEXP_STR}
+
+                       # A::B::C
+                       | #{CLASS_REGEXP_STR}(?=[@\s).?!,;<\000]|\z)
+
+                       # Things that look like filenames
+                       | (?:\.\.\/)*[-\/\w]+[_\/.][-\w\/.]+
+
+                       # Things that have markup suppressed
+                       | \\[^\s<]
+                      )
+
+                      # labels for headings
+                      (?:@[\w+%-]+)?
+                     )/x
+
+  ##
+  # Hash of references that have been looked-up to their replacements
+
+  attr_accessor :seen
+
+  ##
+  # Allows cross-references to be created based on the given +context+
+  # (RDoc::Context).
+
+  def initialize context
+    @context = context
+    @store   = context.store
+
+    @seen = {}
+  end
+
+  ##
+  # Returns a reference to +name+.
+  #
+  # If the reference is found and +name+ is not documented +text+ will be
+  # returned.  If +name+ is escaped +name+ is returned.  If +name+ is not
+  # found +text+ is returned.
+
+  def resolve name, text
+    return @seen[name] if @seen.include? name
+
+    if /#{CLASS_REGEXP_STR}([.#]|::)#{METHOD_REGEXP_STR}/o =~ name then
+      type = $2
+      if '.' == type # will find either #method or ::method
+        method = $3
+      else
+        method = "#{type}#{$3}"
+      end
+      container = @context.find_symbol_module($1)
+    elsif /^([.#]|::)#{METHOD_REGEXP_STR}/o =~ name then
+      type = $1
+      if '.' == type
+        method = $2
+      else
+        method = "#{type}#{$2}"
+      end
+      container = @context
+    else
+      type = nil
+      container = nil
+    end
+
+    if container then
+      unless RDoc::TopLevel === container then
+        if '.' == type then
+          if 'new' == method then # AnyClassName.new will be class method
+            ref = container.find_local_symbol method
+            ref = container.find_ancestor_local_symbol method unless ref
+          else
+            ref = container.find_local_symbol "::#{method}"
+            ref = container.find_ancestor_local_symbol "::#{method}" unless ref
+            ref = container.find_local_symbol "##{method}" unless ref
+            ref = container.find_ancestor_local_symbol "##{method}" unless ref
+          end
+        else
+          ref = container.find_local_symbol method
+          ref = container.find_ancestor_local_symbol method unless ref
+        end
+      end
+    end
+
+    ref = case name
+          when /^\\(#{CLASS_REGEXP_STR})$/o then
+            @context.find_symbol $1
+          else
+            @context.find_symbol name
+          end unless ref
+
+    # Try a page name
+    ref = @store.page name if not ref and name =~ /^\w+$/
+
+    ref = nil if RDoc::Alias === ref # external alias, can't link to it
+
+    out = if name == '\\' then
+            name
+          elsif name =~ /^\\/ then
+            # we remove the \ only in front of what we know:
+            # other backslashes are treated later, only outside of <tt>
+            ref ? $' : name
+          elsif ref then
+            if ref.display? then
+              ref
+            else
+              text
+            end
+          else
+            text
+          end
+
+    @seen[name] = out
+
+    out
+  end
+
+end
+

data/vendor/bundle/ruby/2.5.0/gems/rdoc-6.1.1/lib/rdoc/encoding.rb

@@ -0,0 +1,136 @@
+# coding: US-ASCII
+# frozen_string_literal: true
+
+##
+# This class is a wrapper around File IO and Encoding that helps RDoc load
+# files and convert them to the correct encoding.
+
+module RDoc::Encoding
+
+  HEADER_REGEXP = /^
+    (?:
+      \A\#!.*\n
+      |
+      ^\#\s+frozen[-_]string[-_]literal[=:].+\n
+      |
+      ^\#[^\n]+\b(?:en)?coding[=:]\s*(?<name>[^\s;]+).*\n
+      |
+      <\?xml[^?]*encoding=(?<quote>["'])(?<name>.*?)\k<quote>.*\n
+    )+
+  /xi # :nodoc:
+
+  ##
+  # Reads the contents of +filename+ and handles any encoding directives in
+  # the file.
+  #
+  # The content will be converted to the +encoding+.  If the file cannot be
+  # converted a warning will be printed and nil will be returned.
+  #
+  # If +force_transcode+ is true the document will be transcoded and any
+  # unknown character in the target encoding will be replaced with '?'
+
+  def self.read_file filename, encoding, force_transcode = false
+    content = File.open filename, "rb" do |f| f.read end
+    content.gsub!("\r\n", "\n") if RUBY_PLATFORM =~ /mswin|mingw/
+
+    utf8 = content.sub!(/\A\xef\xbb\xbf/, '')
+
+    enc = RDoc::Encoding.detect_encoding content
+    content = RDoc::Encoding.change_encoding content, enc if enc
+
+    begin
+      encoding ||= Encoding.default_external
+      orig_encoding = content.encoding
+
+      if not orig_encoding.ascii_compatible? then
+        content = content.encode encoding
+      elsif utf8 then
+        content = RDoc::Encoding.change_encoding content, Encoding::UTF_8
+        content = content.encode encoding
+      else
+        # assume the content is in our output encoding
+        content = RDoc::Encoding.change_encoding content, encoding
+      end
+
+      unless content.valid_encoding? then
+        # revert and try to transcode
+        content = RDoc::Encoding.change_encoding content, orig_encoding
+        content = content.encode encoding
+      end
+
+      unless content.valid_encoding? then
+        warn "unable to convert #{filename} to #{encoding}, skipping"
+        content = nil
+      end
+    rescue Encoding::InvalidByteSequenceError,
+           Encoding::UndefinedConversionError => e
+      if force_transcode then
+        content = RDoc::Encoding.change_encoding content, orig_encoding
+        content = content.encode(encoding,
+                                 :invalid => :replace,
+                                 :undef => :replace,
+                                 :replace => '?')
+        return content
+      else
+        warn "unable to convert #{e.message} for #{filename}, skipping"
+        return nil
+      end
+    end
+
+    content
+  rescue ArgumentError => e
+    raise unless e.message =~ /unknown encoding name - (.*)/
+    warn "unknown encoding name \"#{$1}\" for #{filename}, skipping"
+    nil
+  rescue Errno::EISDIR, Errno::ENOENT
+    nil
+  end
+
+  def self.remove_frozen_string_literal string
+    string =~ /\A(?:#!.*\n)?(.*\n)/
+    first_line = $1
+
+    if first_line =~ /\A# +frozen[-_]string[-_]literal[=:].+$/i
+      string = string.sub first_line, ''
+    end
+
+    string
+  end
+
+  ##
+  # Detects the encoding of +string+ based on the magic comment
+
+  def self.detect_encoding string
+    result = HEADER_REGEXP.match string
+    name = result && result[:name]
+
+    name ? Encoding.find(name) : nil
+  end
+
+  ##
+  # Removes magic comments and shebang
+
+  def self.remove_magic_comment string
+    string.sub HEADER_REGEXP do |s|
+      s.gsub(/[^\n]/, '')
+    end
+  end
+
+  ##
+  # Changes encoding based on +encoding+ without converting and returns new
+  # string
+
+  def self.change_encoding text, encoding
+    if text.kind_of? RDoc::Comment
+      text.encode! encoding
+    else
+      # TODO: Remove this condition after Ruby 2.2 EOL
+      if RUBY_VERSION < '2.3.0'
+        text.force_encoding encoding
+      else
+        String.new text, encoding: encoding
+      end
+    end
+  end
+
+end