ric 0.14.2 → 0.15.0

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.6/lib/rake/thread_pool.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-require "rake/promise"
-
-module Rake
-
-  class ThreadPool # :nodoc: all
-
-    # Creates a ThreadPool object.  The +thread_count+ parameter is the size
-    # of the pool.
-    def initialize(thread_count)
-      require "set"
-      @max_active_threads = [thread_count, 0].max
-      @threads = Set.new
-      @threads_mon = Monitor.new
-      @queue = Queue.new
-      @join_cond = @threads_mon.new_cond
-
-      @history_start_time = nil
-      @history = []
-      @history_mon = Monitor.new
-      @total_threads_in_play = 0
-    end
-
-    # Creates a future executed by the +ThreadPool+.
-    #
-    # The args are passed to the block when executing (similarly to
-    # Thread#new) The return value is an object representing
-    # a future which has been created and added to the queue in the
-    # pool. Sending #value to the object will sleep the
-    # current thread until the future is finished and will return the
-    # result (or raise an exception thrown from the future)
-    def future(*args, &block)
-      promise = Promise.new(args, &block)
-      promise.recorder = lambda { |*stats| stat(*stats) }
-
-      @queue.enq promise
-      stat :queued, item_id: promise.object_id
-      start_thread
-      promise
-    end
-
-    # Waits until the queue of futures is empty and all threads have exited.
-    def join
-      @threads_mon.synchronize do
-        begin
-          stat :joining
-          @join_cond.wait unless @threads.empty?
-          stat :joined
-        rescue Exception => e
-          stat :joined
-          $stderr.puts e
-          $stderr.print "Queue contains #{@queue.size} items. " +
-            "Thread pool contains #{@threads.count} threads\n"
-          $stderr.print "Current Thread #{Thread.current} status = " +
-            "#{Thread.current.status}\n"
-          $stderr.puts e.backtrace.join("\n")
-          @threads.each do |t|
-            $stderr.print "Thread #{t} status = #{t.status}\n"
-            $stderr.puts t.backtrace.join("\n")
-          end
-          raise e
-        end
-      end
-    end
-
-    # Enable the gathering of history events.
-    def gather_history          #:nodoc:
-      @history_start_time = Time.now if @history_start_time.nil?
-    end
-
-    # Return a array of history events for the thread pool.
-    #
-    # History gathering must be enabled to be able to see the events
-    # (see #gather_history). Best to call this when the job is
-    # complete (i.e. after ThreadPool#join is called).
-    def history                 # :nodoc:
-      @history_mon.synchronize { @history.dup }.
-        sort_by { |i| i[:time] }.
-        each { |i| i[:time] -= @history_start_time }
-    end
-
-    # Return a hash of always collected statistics for the thread pool.
-    def statistics              #  :nodoc:
-      {
-        total_threads_in_play: @total_threads_in_play,
-        max_active_threads: @max_active_threads,
-      }
-    end
-
-    private
-
-    # processes one item on the queue. Returns true if there was an
-    # item to process, false if there was no item
-    def process_queue_item      #:nodoc:
-      return false if @queue.empty?
-
-      # Even though we just asked if the queue was empty, it
-      # still could have had an item which by this statement
-      # is now gone. For this reason we pass true to Queue#deq
-      # because we will sleep indefinitely if it is empty.
-      promise = @queue.deq(true)
-      stat :dequeued, item_id: promise.object_id
-      promise.work
-      return true
-
-    rescue ThreadError # this means the queue is empty
-      false
-    end
-
-    def safe_thread_count
-      @threads_mon.synchronize do
-        @threads.count
-      end
-    end
-
-    def start_thread # :nodoc:
-      @threads_mon.synchronize do
-        next unless @threads.count < @max_active_threads
-
-        t = Thread.new do
-          begin
-            while safe_thread_count <= @max_active_threads
-              break unless process_queue_item
-            end
-          ensure
-            @threads_mon.synchronize do
-              @threads.delete Thread.current
-              stat :ended, thread_count: @threads.count
-              @join_cond.broadcast if @threads.empty?
-            end
-          end
-        end
-
-        @threads << t
-        stat(
-          :spawned,
-          new_thread: t.object_id,
-          thread_count: @threads.count)
-        @total_threads_in_play = @threads.count if
-          @threads.count > @total_threads_in_play
-      end
-    end
-
-    def stat(event, data=nil) # :nodoc:
-      return if @history_start_time.nil?
-      info = {
-        event: event,
-        data: data,
-        time: Time.now,
-        thread: Thread.current.object_id,
-      }
-      @history_mon.synchronize { @history << info }
-    end
-
-    # for testing only
-
-    def __queue__ # :nodoc:
-      @queue
-    end
-  end
-
-end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.6/lib/rake/trace_output.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-module Rake
-  module TraceOutput # :nodoc: all
-
-    # Write trace output to output stream +out+.
-    #
-    # The write is done as a single IO call (to print) to lessen the
-    # chance that the trace output is interrupted by other tasks also
-    # producing output.
-    def trace_on(out, *strings)
-      sep = $\ || "\n"
-      if strings.empty?
-        output = sep
-      else
-        output = strings.map { |s|
-          next if s.nil?
-          s.end_with?(sep) ? s : s + sep
-        }.join
-      end
-      out.print(output)
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.6/lib/rake/version.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-module Rake
-  VERSION = "13.0.6"
-
-  module Version # :nodoc: all
-    MAJOR, MINOR, BUILD, *OTHER = Rake::VERSION.split "."
-
-    NUMBERS = [MAJOR, MINOR, BUILD, *OTHER]
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.6/lib/rake/win32.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require "rbconfig"
-
-module Rake
-  # Win 32 interface methods for Rake. Windows specific functionality
-  # will be placed here to collect that knowledge in one spot.
-  module Win32 # :nodoc: all
-
-    # Error indicating a problem in locating the home directory on a
-    # Win32 system.
-    class Win32HomeError < RuntimeError
-    end
-
-    class << self
-      # True if running on a windows system.
-      def windows?
-        RbConfig::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw|[Ww]indows)!
-      end
-
-      # The standard directory containing system wide rake files on
-      # Win 32 systems. Try the following environment variables (in
-      # order):
-      #
-      # * HOME
-      # * HOMEDRIVE + HOMEPATH
-      # * APPDATA
-      # * USERPROFILE
-      #
-      # If the above are not defined, the return nil.
-      def win32_system_dir #:nodoc:
-        win32_shared_path = ENV["HOME"]
-        if win32_shared_path.nil? && ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
-          win32_shared_path = ENV["HOMEDRIVE"] + ENV["HOMEPATH"]
-        end
-
-        win32_shared_path ||= ENV["APPDATA"]
-        win32_shared_path ||= ENV["USERPROFILE"]
-        raise Win32HomeError,
-          "Unable to determine home path environment variable." if
-            win32_shared_path.nil? or win32_shared_path.empty?
-        normalize(File.join(win32_shared_path, "Rake"))
-      end
-
-      # Normalize a win32 path so that the slashes are all forward slashes.
-      def normalize(path)
-        path.gsub(/\\/, "/")
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.6/lib/rake.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-#--
-# Copyright 2003-2010 by Jim Weirich (jim.weirich@gmail.com)
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#++
-
-module Rake; end
-
-require "rake/version"
-
-require "rbconfig"
-require "fileutils"
-require "singleton"
-require "monitor"
-require "optparse"
-require "ostruct"
-
-require "rake/ext/string"
-
-require "rake/win32"
-
-require "rake/linked_list"
-require "rake/cpu_counter"
-require "rake/scope"
-require "rake/task_argument_error"
-require "rake/rule_recursion_overflow_error"
-require "rake/rake_module"
-require "rake/trace_output"
-require "rake/pseudo_status"
-require "rake/task_arguments"
-require "rake/invocation_chain"
-require "rake/task"
-require "rake/file_task"
-require "rake/file_creation_task"
-require "rake/multi_task"
-require "rake/dsl_definition"
-require "rake/file_utils_ext"
-require "rake/file_list"
-require "rake/default_loader"
-require "rake/early_time"
-require "rake/late_time"
-require "rake/name_space"
-require "rake/task_manager"
-require "rake/application"
-require "rake/backtrace"
-
-$trace = false
-
-# :stopdoc:
-#
-# Some top level Constants.
-
-FileList = Rake::FileList
-RakeFileUtils = Rake::FileUtilsExt

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.6/rake.gemspec

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-require_relative 'lib/rake/version'
-
-Gem::Specification.new do |s|
-  s.name = "rake".freeze
-  s.version = Rake::VERSION
-  s.authors = ["Hiroshi SHIBATA".freeze, "Eric Hodel".freeze, "Jim Weirich".freeze]
-  s.email = ["hsbt@ruby-lang.org".freeze, "drbrain@segment7.net".freeze, "".freeze]
-
-  s.summary = "Rake is a Make-like program implemented in Ruby".freeze
-  s.description = <<-DESCRIPTION
-Rake is a Make-like program implemented in Ruby. Tasks and dependencies are
-specified in standard Ruby syntax.
-Rake has the following features:
-  * Rakefiles (rake's version of Makefiles) are completely defined in standard Ruby syntax.
-    No XML files to edit. No quirky Makefile syntax to worry about (is that a tab or a space?)
-  * Users can specify tasks with prerequisites.
-  * Rake supports rule patterns to synthesize implicit tasks.
-  * Flexible FileLists that act like arrays but know about manipulating file names and paths.
-  * Supports parallel execution of tasks.
-  DESCRIPTION
-  s.homepage = "https://github.com/ruby/rake".freeze
-  s.licenses = ["MIT".freeze]
-
-  s.metadata = {
-    "bug_tracker_uri"   => "https://github.com/ruby/rake/issues",
-    "changelog_uri"     => "https://github.com/ruby/rake/blob/v#{s.version}/History.rdoc",
-    "documentation_uri" => "https://ruby.github.io/rake",
-    "source_code_uri"   => "https://github.com/ruby/rake/tree/v#{s.version}",
-  }
-
-  s.files = [
-    "History.rdoc",
-    "MIT-LICENSE",
-    "README.rdoc",
-    "doc/command_line_usage.rdoc",
-    "doc/example/Rakefile1",
-    "doc/example/Rakefile2",
-    "doc/example/a.c",
-    "doc/example/b.c",
-    "doc/example/main.c",
-    "doc/glossary.rdoc",
-    "doc/jamis.rb",
-    "doc/proto_rake.rdoc",
-    "doc/rake.1",
-    "doc/rakefile.rdoc",
-    "doc/rational.rdoc",
-    "exe/rake",
-    "lib/rake.rb",
-    "lib/rake/application.rb",
-    "lib/rake/backtrace.rb",
-    "lib/rake/clean.rb",
-    "lib/rake/cloneable.rb",
-    "lib/rake/cpu_counter.rb",
-    "lib/rake/default_loader.rb",
-    "lib/rake/dsl_definition.rb",
-    "lib/rake/early_time.rb",
-    "lib/rake/ext/core.rb",
-    "lib/rake/ext/string.rb",
-    "lib/rake/file_creation_task.rb",
-    "lib/rake/file_list.rb",
-    "lib/rake/file_task.rb",
-    "lib/rake/file_utils.rb",
-    "lib/rake/file_utils_ext.rb",
-    "lib/rake/invocation_chain.rb",
-    "lib/rake/invocation_exception_mixin.rb",
-    "lib/rake/late_time.rb",
-    "lib/rake/linked_list.rb",
-    "lib/rake/loaders/makefile.rb",
-    "lib/rake/multi_task.rb",
-    "lib/rake/name_space.rb",
-    "lib/rake/packagetask.rb",
-    "lib/rake/phony.rb",
-    "lib/rake/private_reader.rb",
-    "lib/rake/promise.rb",
-    "lib/rake/pseudo_status.rb",
-    "lib/rake/rake_module.rb",
-    "lib/rake/rake_test_loader.rb",
-    "lib/rake/rule_recursion_overflow_error.rb",
-    "lib/rake/scope.rb",
-    "lib/rake/task.rb",
-    "lib/rake/task_argument_error.rb",
-    "lib/rake/task_arguments.rb",
-    "lib/rake/task_manager.rb",
-    "lib/rake/tasklib.rb",
-    "lib/rake/testtask.rb",
-    "lib/rake/thread_history_display.rb",
-    "lib/rake/thread_pool.rb",
-    "lib/rake/trace_output.rb",
-    "lib/rake/version.rb",
-    "lib/rake/win32.rb",
-    "rake.gemspec"
-  ]
-  s.bindir = "exe"
-  s.executables = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  s.require_paths = ["lib".freeze]
-
-  s.required_ruby_version = Gem::Requirement.new(">= 2.2".freeze)
-  s.rdoc_options = ["--main".freeze, "README.rdoc".freeze]
-end

data/vendor/bundle/ruby/2.7.0/gems/rdoc-6.4.0/CONTRIBUTING.rdoc

@@ -1,220 +0,0 @@
-= Developer Introduction
-
-So you want to write a generator, fix a bug, or otherwise work with RDoc.  This
-document provides an overview of how RDoc works from parsing options to
-generating output.  Most of the documentation can be found in the specific
-classes for each feature.
-
-== Bugs
-
-If you think you found a bug, file a ticket on the {issues
-tracker}[https://github.com/ruby/rdoc/issues] on github.
-
-If your bug involves an error RDoc produced please include a sample file that
-illustrates the problem or link to the repository or gem that is associated
-with the bug.
-
-Please include steps to reproduce the issue.  Here are some examples of good
-issues:
-
-* https://github.com/ruby/rdoc/issues/55
-* https://github.com/ruby/rdoc/issues/61
-
-== Developer Quick Start
-
-RDoc uses bundler for development.  To get ready to work on RDoc run:
-
-  $ gem install bundler
-  [...]
-  $ bundle install
-  [...]
-  $ rake
-  [...]
-
-This will install all the necessary dependencies for development with rake,
-generate documentation and run the tests for the first time.
-
-If the tests don't pass on the first run check the {Travis CI page for
-RDoc}[https://travis-ci.org/ruby/rdoc] to see if there are any known failures
-(there shouldn't be).
-
-You can now use `rake` and `autotest` to run the tests.
-
-Note: the `rake` command must be used first before running any tests, because
-its used to generate various parsers implemented in RDoc. Also `rake clean` is
-helpful to delete these generated files.
-
-== Glossary
-
-Here are definitions for some common terms in the RDoc documentation.  The
-list also briefly describes how the components of RDoc interact.
-
-parser::
-  Parses files and creates a documentation tree from the contents.
-
-documentation tree::
-  The documentation tree represents files, classes, modules, methods,
-  constants, includes, comments and other ruby syntax features as a tree.
-  RDoc walks this tree with a generator to create documentation.
-
-generator::
-  Walks the documentation tree and generates output.
-
-  RDoc ships with two generators, the Darkfish generator creates HTML and the
-  RI generator creates an RI data store.
-
-markup parser::
-  Parses comments from a file into a generic markup tree.
-
-  The markup parsers allow RDoc to handle RDoc, TomDoc, rd and Markdown format
-  documentation with common formatters.
-
-markup tree::
-  Each parsed comment has a markup tree that represents common markup items
-  such as headings, paragraphs, lists or verbatim text sections for example
-  code or output.
-
-  A generator uses a formatters to walks the tree to create output.  Some
-  generators use multiple formatters on a markup tree to produce the output.
-
-formatter::
-  Converts a parsed markup tree into some form other form of markup.
-
-  Formatters can either produce a one-to-one conversion, such as ToHtml, or
-  extract part of the parsed result, such as ToHtmlSnippet which outputs the
-  first 100 characters as HTML.
-
-== Plugins
-
-When 'rdoc/rdoc' is loaded RDoc looks for 'rdoc/discover' files in your
-installed gems.  This can be used to load parsers, alternate generators, or
-additional preprocessor directives.  An rdoc plugin layout should look
-something like this:
-
-  lib/rdoc/discover.rb
-  lib/my/rdoc/plugin.rb
-  # etc.
-
-In your rdoc/discover.rb file you will want to wrap the loading of your plugin
-in an RDoc version check like this:
-
-  begin
-    gem 'rdoc', '~> 3'
-    require 'my/rdoc/plugin'
-  rescue Gem::LoadError
-  end
-
-=== Plugin Types
-
-In RDoc you can change the following behaviors:
-
-* Add a parser for a new file format
-* Add a new output generator
-* Add a new markup directive
-* Add a new type of documentation markup
-* Add a new type of formatter
-
-All of these are described below
-
-== Option Parsing
-
-Option parsing is handled by RDoc::Options.  When you're writing a generator
-you can provide the user with extra options by providing a class method
-+setup_options+.  The option parser will call this after your generator is
-loaded.  See RDoc::Generator for details.
-
-== File Parsing
-
-After options are parsed, RDoc parses files from the files and directories in
-ARGV.  RDoc compares the filename against what each parser claims it can parse
-via RDoc::Parser#parse_files_matching.  For example, RDoc::Parser::C can parse
-C files, C headers, C++ files, C++ headers and yacc grammars.
-
-Once a matching parser class is found it is instantiated and +scan+ is called.
-The parser needs to extract documentation from the file and add it to the RDoc
-document tree.  Usually this involves starting at the root and adding a class
-or a module (RDoc::TopLevel#add_class and RDoc::TopLevel#add_module) and
-proceeding to add classes, modules and methods to each nested item.
-
-When the parsers are finished the document tree is cleaned up to remove
-dangling references to aliases and includes that were not found (and may exist
-in a separate library) through RDoc::ClassModule#complete.
-
-To write your own parser for a new file format see RDoc::Parser.
-
-=== Documentation Tree
-
-The parsers build a documentation tree that is composed of RDoc::CodeObject and
-its subclasses.  There are various methods to walk the tree to extract
-information, see RDoc::Context and its subclasses.
-
-Within a class or module, attributes, methods and constants are divided into
-sections.  The section represents a functional grouping of parts of the class.
-TomDoc uses the sections "Public", "Internal" and "Deprecated".  The sections
-can be enumerated using RDoc::Context#each_section.
-
-== Output Generation
-
-An RDoc generator turns the documentation tree into some other kind of output.
-RDoc comes with an HTML generator (RDoc::Generator::Darkfish) and an RI
-database generator (RDoc::Generator::RI).  The output a generator creates does
-not have to be human-readable.
-
-To create your own generator see RDoc::Generator.
-
-=== Comments
-
-In RDoc 3.10 and newer the comment on an RDoc::CodeObject is now an
-RDoc::Comment object instead of a String.  This is to support various
-documentation markup formats like rdoc, TomDoc and rd.  The comments are
-normalized to remove comment markers and remove indentation then parsed lazily
-via RDoc::Comment#document to create a generic markup tree that can be
-processed by a formatter.
-
-To add your own markup format see RDoc::Markup@Other+directives
-
-==== Formatters
-
-To transform a comment into some form of output an RDoc::Markup::Formatter
-subclass is used like RDoc::Markup::ToHtml.  A formatter is a visitor that
-walks a parsed comment tree (an RDoc::Markup::Document) of any format.  To help
-write a formatter RDoc::Markup::FormatterTestCase exists for generic parsers,
-and RDoc::Markup::TextFormatterTestCase which contains extra test cases for
-text-type output (like +ri+ output).
-
-RDoc ships with formatters that will turn a comment into HTML, rdoc-markup-like
-text, ANSI or terminal backspace highlighted text, HTML, cross-referenced HTML,
-an HTML snippet free of most markup, an HTML label for use in id attributes, a
-table-of-contents page, and text with only code blocks.
-
-The output of the formatter does not need to be text or text-like.
-RDoc::Markup::ToLabel creates an HTML-safe label for use in an HTML id
-attribute.  A formatter could count the number of words and the average word
-length for a comment, for example.
-
-==== Directives
-
-For comments in markup you can add new directives (:nodoc: is a directive).
-Directives may replace text or store it off for later use.
-
-See RDoc::Markup::PreProcess::register for details.
-
-=== JSONIndex
-
-RDoc contains a special generator, RDoc::Generator::JSONIndex, which creates a
-JSON-based search index and includes a search engine for use with HTML output.
-This generator can be used to add searching to any HTML output and is designed
-to be called from inside an HTML generator.
-
-== Markup
-
-Additional documentation markup formats can be added to RDoc.  A markup
-parsing class must respond to \::parse and accept a String argument containing
-the markup format.  An RDoc::Document containing documentation items
-(RDoc::Markup::Heading, RDoc::Markup::Paragraph, RDoc::Markup::Verbatim, etc.)
-must be returned.
-
-To register the parser with rdoc, add the markup type's name and class to the
-RDoc::Text::MARKUP_FORMAT hash like:
-
-  RDoc::Text::MARKUP_FORMAT['rdoc'] = RDoc::Markup

data/vendor/bundle/ruby/2.7.0/gems/rdoc-6.4.0/CVE-2013-0256.rdoc

@@ -1,49 +0,0 @@
-= RDoc 2.3.0 through 3.12 XSS Exploit
-
-RDoc documentation generated by rdoc 2.3.0 through rdoc 3.12 and prereleases up
-to rdoc 4.0.0.preview2.1 are vulnerable to an XSS exploit.  This exploit may
-lead to cookie disclosure to third parties.
-
-The exploit exists in darkfish.js which is copied from the RDoc install
-location to the generated documentation.
-
-RDoc is a static documentation generation tool.  Patching the library itself
-is insufficient to correct this exploit.  Those hosting rdoc documentation will
-need to apply the following patch.  If applied while ignoring whitespace, this
-patch will correct all affected versions:
-
-  diff --git darkfish.js darkfish.js
-  index 4be722f..f26fd45 100644
-  --- darkfish.js
-  +++ darkfish.js
-  @@ -109,13 +109,15 @@ function hookSearch() {
-   function highlightTarget( anchor ) {
-     console.debug( "Highlighting target '%s'.", anchor );
-   
-  -  $("a[name=" + anchor + "]").each( function() {
-  -    if ( !$(this).parent().parent().hasClass('target-section') ) {
-  -      console.debug( "Wrapping the target-section" );
-  -      $('div.method-detail').unwrap( 'div.target-section' );
-  -      $(this).parent().wrap( '<div class="target-section"></div>' );
-  -    } else {
-  -      console.debug( "Already wrapped." );
-  +  $("a[name]").each( function() {
-  +    if ( $(this).attr("name") == anchor ) {
-  +      if ( !$(this).parent().parent().hasClass('target-section') ) {
-  +        console.debug( "Wrapping the target-section" );
-  +        $('div.method-detail').unwrap( 'div.target-section' );
-  +        $(this).parent().wrap( '<div class="target-section"></div>' );
-  +      } else {
-  +        console.debug( "Already wrapped." );
-  +      }
-       }
-     });
-   };
-
-RDoc 3.9.5, 3.12.1 and RDoc 4.0.0.rc.2 and newer are not vulnerable to this
-exploit.
-
-This exploit was discovered by Evgeny Ermakov <corwmh@gmail.com>.
-
-This vulnerability has been assigned the CVE identifier CVE-2013-0256.
-