cvss-suite 1.0.8 → 1.1.0

data/vendor/cache/ruby/2.2.0/gems/rspec-support-3.4.0/lib/rspec/support/spec/deprecation_helpers.rb

@@ -1,64 +0,0 @@
-module RSpecHelpers
-  def expect_no_deprecation
-    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
-  end
-
-  def expect_deprecation_with_call_site(file, line, snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options[:call_site]).to include([file, line].join(':'))
-      expect(options[:deprecated]).to match(snippet)
-    end
-  end
-
-  def expect_deprecation_without_call_site(snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options[:call_site]).to eq nil
-      expect(options[:deprecated]).to match(snippet)
-    end
-  end
-
-  def expect_warn_deprecation_with_call_site(file, line, snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      message = options[:message]
-      expect(message).to match(snippet)
-      expect(message).to include([file, line].join(':'))
-    end
-  end
-
-  def expect_warn_deprecation(snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      message = options[:message]
-      expect(message).to match(snippet)
-    end
-  end
-
-  def allow_deprecation
-    allow(RSpec.configuration.reporter).to receive(:deprecation)
-  end
-
-  def expect_no_deprecations
-    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
-  end
-
-  def expect_warning_without_call_site(expected=//)
-    expect(::Kernel).to receive(:warn) do |message|
-      expect(message).to match expected
-      expect(message).to_not match(/Called from/)
-    end
-  end
-
-  def expect_warning_with_call_site(file, line, expected=//)
-    expect(::Kernel).to receive(:warn) do |message|
-      expect(message).to match expected
-      expect(message).to match(/Called from #{file}:#{line}/)
-    end
-  end
-
-  def expect_no_warnings
-    expect(::Kernel).not_to receive(:warn)
-  end
-
-  def allow_warning
-    allow(::Kernel).to receive(:warn)
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/rspec-support-3.4.0/lib/rspec/support/spec/formatting_support.rb

@@ -1,9 +0,0 @@
-module RSpec
-  module Support
-    module FormattingSupport
-      def dedent(string)
-        string.gsub(/^\s+\|/, '').chomp
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/rspec-support-3.4.0/lib/rspec/support/spec/in_sub_process.rb

@@ -1,52 +0,0 @@
-module RSpec
-  module Support
-    module InSubProcess
-      if Process.respond_to?(:fork) && !(Ruby.jruby? && RUBY_VERSION == '1.8.7')
-
-        # Useful as a way to isolate a global change to a subprocess.
-
-        # rubocop:disable MethodLength
-        def in_sub_process(prevent_warnings=true)
-          readme, writeme = IO.pipe
-
-          pid = Process.fork do
-            exception = nil
-            warning_preventer = $stderr = RSpec::Support::StdErrSplitter.new($stderr)
-
-            begin
-              yield
-              warning_preventer.verify_no_warnings! if prevent_warnings
-            rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
-              exception = e
-            end
-
-            writeme.write Marshal.dump(exception)
-
-            readme.close
-            writeme.close
-            exit! # prevent at_exit hooks from running (e.g. minitest)
-          end
-
-          writeme.close
-          Process.waitpid(pid)
-
-          exception = Marshal.load(readme.read)
-          readme.close
-
-          raise exception if exception
-        end
-        # rubocop:enable MethodLength
-        alias :in_sub_process_if_possible :in_sub_process
-      else
-        def in_sub_process(*)
-          skip "This spec requires forking to work properly, " \
-               "and your platform does not support forking"
-        end
-
-        def in_sub_process_if_possible(*)
-          yield
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/rspec-support-3.4.0/lib/rspec/support/spec/library_wide_checks.rb

@@ -1,152 +0,0 @@
-require 'rspec/support/spec/shell_out'
-
-module RSpec
-  module Support
-    module WhitespaceChecks
-      # This malformed whitespace detection logic has been borrowed from bundler:
-      # https://github.com/bundler/bundler/blob/v1.8.0/spec/quality_spec.rb
-      def check_for_tab_characters(filename)
-        failing_lines = []
-        File.readlines(filename).each_with_index do |line, number|
-          failing_lines << number + 1 if line =~ /\t/
-        end
-
-        return if failing_lines.empty?
-        "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
-      end
-
-      def check_for_extra_spaces(filename)
-        failing_lines = []
-        File.readlines(filename).each_with_index do |line, number|
-          next if line =~ /^\s+#.*\s+\n$/
-          failing_lines << number + 1 if line =~ /\s+\n$/
-        end
-
-        return if failing_lines.empty?
-        "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
-      end
-    end
-  end
-end
-
-RSpec.shared_examples_for "library wide checks" do |lib, options|
-  consider_a_test_env_file = options.fetch(:consider_a_test_env_file, /MATCHES NOTHING/)
-  allowed_loaded_feature_regexps = options.fetch(:allowed_loaded_feature_regexps, [])
-  preamble_for_lib = options[:preamble_for_lib]
-  preamble_for_spec = "require 'rspec/core'; require 'spec_helper'"
-  skip_spec_files = options.fetch(:skip_spec_files, /MATCHES NOTHING/)
-
-  include RSpec::Support::ShellOut
-  include RSpec::Support::WhitespaceChecks
-
-  define_method :files_to_require_for do |sub_dir|
-    slash         = File::SEPARATOR
-    lib_path_re   = /#{slash + lib}[^#{slash}]*#{slash}lib/
-    load_path     = $LOAD_PATH.grep(lib_path_re).first
-    directory     = load_path.sub(/lib$/, sub_dir)
-    files         = Dir["#{directory}/**/*.rb"]
-    extract_regex = /#{Regexp.escape(directory) + File::SEPARATOR}(.+)\.rb$/
-
-    # We sort to ensure the files are loaded in a consistent order, regardless
-    # of OS. Otherwise, it could load in a different order on Travis than
-    # locally, and potentially trigger a "circular require considered harmful"
-    # warning or similar.
-    files.sort.map { |file| file[extract_regex, 1] }
-  end
-
-  def command_from(code_lines)
-    code_lines.join("\n")
-  end
-
-  def load_all_files(files, preamble, postamble=nil)
-    requires = files.map { |f| "require '#{f}'" }
-    command  = command_from(Array(preamble) + requires + Array(postamble))
-
-    stdout, stderr, status = with_env 'NO_COVERAGE' => '1' do
-      options = %w[ -w ]
-      options << "--disable=gem" if RUBY_VERSION.to_f >= 1.9 && RSpec::Support::Ruby.mri?
-      run_ruby_with_current_load_path(command, *options)
-    end
-
-    # Ignore bundler warning.
-    stderr = stderr.split("\n").reject { |l| l =~ %r{bundler/source/rubygems} }.join("\n")
-    [stdout, stderr, status.exitstatus]
-  end
-
-  define_method :load_all_lib_files do
-    files = all_lib_files - lib_test_env_files
-    preamble  = ['orig_loaded_features = $".dup', preamble_for_lib]
-    postamble = ['puts(($" - orig_loaded_features).join("\n"))']
-
-    @loaded_feature_lines, stderr, exitstatus = load_all_files(files, preamble, postamble)
-    ["", stderr, exitstatus]
-  end
-
-  define_method :load_all_spec_files do
-    files = files_to_require_for("spec") + lib_test_env_files
-    files = files.reject { |f| f =~ skip_spec_files }
-    load_all_files(files, preamble_for_spec)
-  end
-
-  attr_reader :all_lib_files, :lib_test_env_files,
-              :lib_file_results, :spec_file_results
-
-  before(:context) do
-    @all_lib_files           = files_to_require_for("lib")
-    @lib_test_env_files      = all_lib_files.grep(consider_a_test_env_file)
-
-    @lib_file_results, @spec_file_results = [
-      # Load them in parallel so it's faster...
-      Thread.new { load_all_lib_files  },
-      Thread.new { load_all_spec_files }
-    ].map(&:join).map(&:value)
-  end
-
-  def have_successful_no_warnings_output
-    eq ["", "", 0]
-  end
-
-  it "issues no warnings when loaded", :slow do
-    expect(lib_file_results).to have_successful_no_warnings_output
-  end
-
-  it "issues no warnings when the spec files are loaded", :slow do
-    expect(spec_file_results).to have_successful_no_warnings_output
-  end
-
-  it 'only loads a known set of stdlibs so gem authors are forced ' \
-     'to load libs they use to have passing specs', :slow do
-    loaded_features = @loaded_feature_lines.split("\n")
-    if RUBY_VERSION == '1.8.7'
-      # On 1.8.7, $" returns the relative require path if that was used
-      # to require the file. LIB_REGEX will not match the relative version
-      # since it has a `/lib` prefix. Here we deal with this by expanding
-      # relative files relative to the $LOAD_PATH dir (lib).
-      Dir.chdir("lib") { loaded_features.map! { |f| File.expand_path(f) } }
-    end
-
-    loaded_features.reject! { |feature| RSpec::CallerFilter::LIB_REGEX =~ feature }
-    loaded_features.reject! { |feature| allowed_loaded_feature_regexps.any? { |r| r =~ feature } }
-
-    expect(loaded_features).to eq([])
-  end
-
-  RSpec::Matchers.define :be_well_formed do
-    match do |actual|
-      actual.empty?
-    end
-
-    failure_message do |actual|
-      actual.join("\n")
-    end
-  end
-
-  it "has no malformed whitespace", :slow do
-    error_messages = []
-    `git ls-files -z`.split("\x0").each do |filename|
-      error_messages << check_for_tab_characters(filename)
-      error_messages << check_for_extra_spaces(filename)
-    end
-    expect(error_messages.compact).to be_well_formed
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/rspec-support-3.4.0/lib/rspec/support/spec/shell_out.rb

@@ -1,71 +0,0 @@
-require 'open3'
-require 'rake/file_utils'
-require 'shellwords'
-
-module RSpec
-  module Support
-    module ShellOut
-      def with_env(vars)
-        original = ENV.to_hash
-        vars.each { |k, v| ENV[k] = v }
-
-        begin
-          yield
-        ensure
-          ENV.replace(original)
-        end
-      end
-
-      if Open3.respond_to?(:capture3) # 1.9+
-        def shell_out(*command)
-          stdout, stderr, status = Open3.capture3(*command)
-          return stdout, filter(stderr), status
-        end
-      else # 1.8.7
-        # popen3 doesn't provide the exit status so we fake it out.
-        FakeProcessStatus = Struct.new(:exitstatus)
-
-        def shell_out(*command)
-          stdout = stderr = nil
-
-          Open3.popen3(*command) do |_in, out, err|
-            stdout = out.read
-            stderr = err.read
-          end
-
-          status = FakeProcessStatus.new(0)
-          return stdout, filter(stderr), status
-        end
-      end
-
-      def run_ruby_with_current_load_path(ruby_command, *flags)
-        command = [
-          FileUtils::RUBY,
-          "-I#{$LOAD_PATH.map(&:shellescape).join(File::PATH_SEPARATOR)}",
-          "-e", ruby_command, *flags
-        ]
-
-        # Unset these env vars because `ruby -w` will issue warnings whenever
-        # they are set to non-default values.
-        with_env 'RUBY_GC_HEAP_FREE_SLOTS' => nil, 'RUBY_GC_MALLOC_LIMIT' => nil,
-                 'RUBY_FREE_MIN' => nil do
-          shell_out(*command)
-        end
-      end
-
-    private
-
-      if Ruby.jruby?
-        def filter(output)
-          output.each_line.reject do |line|
-            line.include?("lib/ruby/shared/rubygems/defaults/jruby")
-          end.join($/)
-        end
-      else
-        def filter(output)
-          output
-        end
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/rspec-support-3.4.0/lib/rspec/support/spec/stderr_splitter.rb

@@ -1,63 +0,0 @@
-require 'stringio'
-
-module RSpec
-  module Support
-    class StdErrSplitter
-      def initialize(original)
-        @orig_stderr    = original
-        @output_tracker = ::StringIO.new
-      end
-
-      respond_to_name = (::RUBY_VERSION.to_f < 1.9) ? :respond_to? : :respond_to_missing?
-      define_method respond_to_name do |*args|
-        @orig_stderr.respond_to?(*args) || super(*args)
-      end
-
-      def method_missing(name, *args, &block)
-        @output_tracker.__send__(name, *args, &block) if @output_tracker.respond_to?(name)
-        @orig_stderr.__send__(name, *args, &block)
-      end
-
-      def ==(other)
-        @orig_stderr == other
-      end
-
-      def reopen(*args)
-        reset!
-        @orig_stderr.reopen(*args)
-      end
-
-      # To work around JRuby error:
-      # can't convert RSpec::Support::StdErrSplitter into String
-      def to_io
-        @orig_stderr.to_io
-      end
-
-      # To work around JRuby error:
-      # TypeError: $stderr must have write method, RSpec::StdErrSplitter given
-      def write(line)
-        return if line =~ %r{^\S+/gems/\S+:\d+: warning:} # http://rubular.com/r/kqeUIZOfPG
-
-        @orig_stderr.write(line)
-        @output_tracker.write(line)
-      end
-
-      def has_output?
-        !output.empty?
-      end
-
-      def reset!
-        @output_tracker = ::StringIO.new
-      end
-
-      def verify_no_warnings!
-        raise "Warnings were generated: #{output}" if has_output?
-        reset!
-      end
-
-      def output
-        @output_tracker.string
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/rspec-support-3.4.0/lib/rspec/support/spec/string_matcher.rb

@@ -1,46 +0,0 @@
-require 'rspec/matchers'
-# Special matcher for comparing encoded strings so that
-# we don't run any expectation failures through the Differ,
-# which also relies on EncodedString. Instead, confirm the
-# strings have the same bytes.
-RSpec::Matchers.define :be_identical_string do |expected|
-
-  if String.method_defined?(:encoding)
-    match do
-      expected_encoding? &&
-        actual.bytes.to_a == expected.bytes.to_a
-    end
-
-    failure_message do
-      "expected\n#{actual.inspect} (#{actual.encoding.name}) to be identical to\n"\
-        "#{expected.inspect} (#{expected.encoding.name})\n"\
-        "The exact bytes are printed below for more detail:\n"\
-        "#{actual.bytes.to_a}\n"\
-        "#{expected.bytes.to_a}\n"\
-    end
-
-    # Depends on chaining :with_same_encoding for it to
-    # check for string encoding.
-    def expected_encoding?
-      if defined?(@expect_same_encoding) && @expect_same_encoding
-        actual.encoding == expected.encoding
-      else
-        true
-      end
-    end
-  else
-    match do
-      actual.split(//) == expected.split(//)
-    end
-
-    failure_message do
-      "expected\n#{actual.inspect} to be identical to\n#{expected.inspect}\n"
-    end
-  end
-
-  chain :with_same_encoding do
-    @expect_same_encoding ||= true
-  end
-end
-RSpec::Matchers.alias_matcher :a_string_identical_to, :be_identical_string
-RSpec::Matchers.alias_matcher :be_diffed_as, :be_identical_string