RubyGems - cvss-suite - Versions diffs - 1.0.8 → 1.1.0 - Mend

cvss-suite 1.0.8 → 1.1.0

Files changed (821) hide show

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/lib/simplecov/configuration.rb DELETED

@@ -1,296 +0,0 @@
-require "fileutils"
-require "docile"
-require "simplecov/formatter/multi_formatter"
-#
-# Bundles the configuration options used for SimpleCov. All methods
-# defined here are usable from SimpleCov directly. Please check out
-# SimpleCov documentation for further info.
-#
-module SimpleCov
-  module Configuration # rubocop:disable ModuleLength
-    attr_writer :filters, :groups, :formatter
-    #
-    # The root for the project. This defaults to the
-    # current working directory.
-    #
-    # Configure with SimpleCov.root('/my/project/path')
-    #
-    def root(root = nil)
-      return @root if defined?(@root) && root.nil?
-      @root = File.expand_path(root || Dir.getwd)
-    end
-    #
-    # The name of the output and cache directory. Defaults to 'coverage'
-    #
-    # Configure with SimpleCov.coverage_dir('cov')
-    #
-    def coverage_dir(dir = nil)
-      return @coverage_dir if defined?(@coverage_dir) && dir.nil?
-      @coverage_path = nil # invalidate cache
-      @coverage_dir = (dir || "coverage")
-    end
-    #
-    # Returns the full path to the output directory using SimpleCov.root
-    # and SimpleCov.coverage_dir, so you can adjust this by configuring those
-    # values. Will create the directory if it's missing
-    #
-    def coverage_path
-      @coverage_path ||= begin
-        coverage_path = File.expand_path(coverage_dir, root)
-        FileUtils.mkdir_p coverage_path
-        coverage_path
-      end
-    end
-    #
-    # Coverage results will always include files matched by this glob, whether
-    # or not they were explicitly required. Without this, un-required files
-    # will not be present in the final report.
-    #
-    def track_files(glob = nil)
-      return @track_files if defined?(@track_files) && glob.nil?
-      @track_files = glob
-    end
-    #
-    # Returns the list of configured filters. Add filters using SimpleCov.add_filter.
-    #
-    def filters
-      @filters ||= []
-    end
-    # The name of the command (a.k.a. Test Suite) currently running. Used for result
-    # merging and caching. It first tries to make a guess based upon the command line
-    # arguments the current test suite is running on and should automatically detect
-    # unit tests, functional tests, integration tests, rpsec and cucumber and label
-    # them properly. If it fails to recognize the current command, the command name
-    # is set to the shell command that the current suite is running on.
-    #
-    # You can specify it manually with SimpleCov.command_name("test:units") - please
-    # also check out the corresponding section in README.rdoc
-    def command_name(name = nil)
-      @name = name unless name.nil?
-      @name ||= SimpleCov::CommandGuesser.guess
-      @name
-    end
-    #
-    # Gets or sets the configured formatter.
-    #
-    # Configure with: SimpleCov.formatter(SimpleCov::Formatter::SimpleFormatter)
-    #
-    def formatter(formatter = nil)
-      return @formatter if defined?(@formatter) && formatter.nil?
-      @formatter = formatter
-      fail "No formatter configured. Please specify a formatter using SimpleCov.formatter = SimpleCov::Formatter::SimpleFormatter" unless @formatter
-      @formatter
-    end
-    #
-    # Sets the configured formatters.
-    #
-    def formatters=(formatters)
-      @formatter = SimpleCov::Formatter::MultiFormatter.new(formatters)
-    end
-    #
-    # Gets the configured formatters.
-    #
-    def formatters
-      if @formatter.is_a?(SimpleCov::Formatter::MultiFormatter)
-        @formatter.formatters
-      else
-        Array(formatter)
-      end
-    end
-    #
-    # Certain code blocks (i.e. Ruby-implementation specific code) can be excluded from
-    # the coverage metrics by wrapping it inside # :nocov: comment blocks. The nocov token
-    # can be configured to be any other string using this.
-    #
-    # Configure with SimpleCov.nocov_token('skip') or it's alias SimpleCov.skip_token('skip')
-    #
-    def nocov_token(nocov_token = nil)
-      return @nocov_token if defined?(@nocov_token) && nocov_token.nil?
-      @nocov_token = (nocov_token || "nocov")
-    end
-    alias skip_token nocov_token
-    #
-    # Returns the configured groups. Add groups using SimpleCov.add_group
-    #
-    def groups
-      @groups ||= {}
-    end
-    #
-    # Returns the hash of available profiles
-    #
-    def profiles
-      @profiles ||= SimpleCov::Profiles.new
-    end
-    def adapters
-      warn "#{Kernel.caller.first}: [DEPRECATION] #adapters is deprecated. Use #profiles instead."
-      profiles
-    end
-    #
-    # Allows you to configure simplecov in a block instead of prepending SimpleCov to all config methods
-    # you're calling.
-    #
-    # SimpleCov.configure do
-    #   add_filter 'foobar'
-    # end
-    #
-    # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a bunch of configure
-    # options at once.
-    #
-    def configure(&block)
-      return false unless SimpleCov.usable?
-      Docile.dsl_eval(self, &block)
-    end
-    #
-    # Gets or sets the behavior to process coverage results.
-    #
-    # By default, it will call SimpleCov.result.format!
-    #
-    # Configure with:
-    #   SimpleCov.at_exit do
-    #     puts "Coverage done"
-    #     SimpleCov.result.format!
-    #   end
-    #
-    def at_exit(&block)
-      return proc {} unless running || block_given?
-      @at_exit = block if block_given?
-      @at_exit ||= proc { SimpleCov.result.format! }
-    end
-    #
-    # Returns the project name - currently assuming the last dirname in
-    # the SimpleCov.root is this.
-    #
-    def project_name(new_name = nil)
-      return @project_name if defined?(@project_name) && @project_name && new_name.nil?
-      @project_name = new_name if new_name.is_a?(String)
-      @project_name ||= File.basename(root.split("/").last).capitalize.tr("_", " ")
-    end
-    #
-    # Defines whether to use result merging so all your test suites (test:units, test:functionals, cucumber, ...)
-    # are joined and combined into a single coverage report
-    #
-    def use_merging(use = nil)
-      @use_merging = use unless use.nil?
-      @use_merging = true unless defined?(@use_merging) && @use_merging == false
-    end
-    #
-    # Defines them maximum age (in seconds) of a resultset to still be included in merged results.
-    # i.e. If you run cucumber features, then later rake test, if the stored cucumber resultset is
-    # more seconds ago than specified here, it won't be taken into account when merging (and is also
-    # purged from the resultset cache)
-    #
-    # Of course, this only applies when merging is active (e.g. SimpleCov.use_merging is not false!)
-    #
-    # Default is 600 seconds (10 minutes)
-    #
-    # Configure with SimpleCov.merge_timeout(3600) # 1hr
-    #
-    def merge_timeout(seconds = nil)
-      @merge_timeout = seconds if seconds.is_a?(Fixnum)
-      @merge_timeout ||= 600
-    end
-    #
-    # Defines the minimum overall coverage required for the testsuite to pass.
-    # SimpleCov will return non-zero if the current coverage is below this threshold.
-    #
-    # Default is 0% (disabled)
-    #
-    def minimum_coverage(coverage = nil)
-      @minimum_coverage ||= (coverage || 0).to_f.round(2)
-    end
-    #
-    # Defines the maximum coverage drop at once allowed for the testsuite to pass.
-    # SimpleCov will return non-zero if the coverage decreases by more than this threshold.
-    #
-    # Default is 100% (disabled)
-    #
-    def maximum_coverage_drop(coverage_drop = nil)
-      @maximum_coverage_drop ||= (coverage_drop || 100).to_f.round(2)
-    end
-    #
-    # Defines the minimum coverage per file required for the testsuite to pass.
-    # SimpleCov will return non-zero if the current coverage of the least covered file
-    # is below this threshold.
-    #
-    # Default is 0% (disabled)
-    #
-    def minimum_coverage_by_file(coverage = nil)
-      @minimum_coverage_by_file ||= (coverage || 0).to_f.round(2)
-    end
-    #
-    # Refuses any coverage drop. That is, coverage is only allowed to increase.
-    # SimpleCov will return non-zero if the coverage decreases.
-    #
-    def refuse_coverage_drop
-      maximum_coverage_drop 0
-    end
-    #
-    # Add a filter to the processing chain.
-    # There are three ways to define a filter:
-    #
-    # * as a String that will then be matched against all source files' file paths,
-    #   SimpleCov.add_filter 'app/models' # will reject all your models
-    # * as a block which will be passed the source file in question and should either
-    #   return a true or false value, depending on whether the file should be removed
-    #   SimpleCov.add_filter do |src_file|
-    #     File.basename(src_file.filename) == 'environment.rb'
-    #   end # Will exclude environment.rb files from the results
-    # * as an instance of a subclass of SimpleCov::Filter. See the documentation there
-    #   on how to define your own filter classes
-    #
-    def add_filter(filter_argument = nil, &filter_proc)
-      filters << parse_filter(filter_argument, &filter_proc)
-    end
-    #
-    # Define a group for files. Works similar to add_filter, only that the first
-    # argument is the desired group name and files PASSING the filter end up in the group
-    # (while filters exclude when the filter is applicable).
-    #
-    def add_group(group_name, filter_argument = nil, &filter_proc)
-      groups[group_name] = parse_filter(filter_argument, &filter_proc)
-    end
-  private
-    #
-    # The actal filter processor. Not meant for direct use
-    #
-    def parse_filter(filter_argument = nil, &filter_proc)
-      if filter_argument.is_a?(SimpleCov::Filter)
-        filter_argument
-      elsif filter_argument.is_a?(String)
-        SimpleCov::StringFilter.new(filter_argument)
-      elsif filter_proc
-        SimpleCov::BlockFilter.new(filter_proc)
-      elsif filter_argument.is_a?(Array)
-        SimpleCov::ArrayFilter.new(filter_argument)
-      else
-        fail ArgumentError, "Please specify either a string or a block to filter with"
-      end
-    end
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/lib/simplecov/defaults.rb DELETED

@@ -1,122 +0,0 @@
-# Load default formatter gem
-require "simplecov-html"
-require "pathname"
-SimpleCov.profiles.define "root_filter" do
-  # Exclude all files outside of simplecov root
-  root_filter = nil
-  add_filter do |src|
-    root_filter ||= /\A#{Regexp.escape(SimpleCov.root)}/io
-    !(src.filename =~ root_filter)
-  end
-end
-SimpleCov.profiles.define "test_frameworks" do
-  add_filter "/test/"
-  add_filter "/features/"
-  add_filter "/spec/"
-  add_filter "/autotest/"
-end
-SimpleCov.profiles.define "bundler_filter" do
-  add_filter "/vendor/bundle/"
-end
-SimpleCov.profiles.define "rails" do
-  load_profile "test_frameworks"
-  add_filter "/config/"
-  add_filter "/db/"
-  add_group "Controllers", "app/controllers"
-  add_group "Models", "app/models"
-  add_group "Mailers", "app/mailers"
-  add_group "Helpers", "app/helpers"
-  add_group "Jobs", %w(app/jobs app/workers)
-  add_group "Libraries", "lib"
-  track_files "{app,lib}/**/*.rb"
-end
-# Default configuration
-SimpleCov.configure do
-  formatter SimpleCov::Formatter::HTMLFormatter
-  load_profile "bundler_filter"
-  # Exclude files outside of SimpleCov.root
-  load_profile "root_filter"
-end
-# Gotta stash this a-s-a-p, see the CommandGuesser class and i.e. #110 for further info
-SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
-at_exit do
-  # If we are in a different process than called start, don't interfere.
-  next if SimpleCov.pid != Process.pid
-  @exit_status = if $! # was an exception thrown?
-                   # if it was a SystemExit, use the accompanying status
-                   # otherwise set a non-zero status representing termination by
-                   # some other exception (see github issue 41)
-                   $!.is_a?(SystemExit) ? $!.status : SimpleCov::ExitCodes::EXCEPTION
-                 else
-                   # Store the exit status of the test run since it goes away
-                   # after calling the at_exit proc...
-                   SimpleCov::ExitCodes::SUCCESS
-                 end
-  SimpleCov.at_exit.call
-  if SimpleCov.result? # Result has been computed
-    covered_percent = SimpleCov.result.covered_percent.round(2)
-    covered_percentages = SimpleCov.result.covered_percentages.map { |p| p.round(2) }
-    if @exit_status == SimpleCov::ExitCodes::SUCCESS # No other errors
-      if covered_percent < SimpleCov.minimum_coverage # rubocop:disable Metrics/BlockNesting
-        $stderr.printf("Coverage (%.2f%%) is below the expected minimum coverage (%.2f%%).\n", covered_percent, SimpleCov.minimum_coverage)
-        @exit_status = SimpleCov::ExitCodes::MINIMUM_COVERAGE
-      elsif covered_percentages.any? { |p| p < SimpleCov.minimum_coverage_by_file } # rubocop:disable Metrics/BlockNesting
-        $stderr.printf("File (%s) is only (%.2f%%) covered. This is below the expected minimum coverage per file of (%.2f%%).\n", SimpleCov.result.least_covered_file, covered_percentages.min, SimpleCov.minimum_coverage_by_file)
-        @exit_status = SimpleCov::ExitCodes::MINIMUM_COVERAGE
-      elsif (last_run = SimpleCov::LastRun.read) # rubocop:disable Metrics/BlockNesting
-        diff = last_run["result"]["covered_percent"] - covered_percent
-        if diff > SimpleCov.maximum_coverage_drop # rubocop:disable Metrics/BlockNesting
-          $stderr.printf("Coverage has dropped by %.2f%% since the last time (maximum allowed: %.2f%%).\n", diff, SimpleCov.maximum_coverage_drop)
-          @exit_status = SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
-        end
-      end
-    end
-    SimpleCov::LastRun.write(:result => {:covered_percent => covered_percent})
-  end
-  # Force exit with stored status (see github issue #5)
-  # unless it's nil or 0 (see github issue #281)
-  Kernel.exit @exit_status if @exit_status && @exit_status > 0
-end
-# Autoload config from ~/.simplecov if present
-require "etc"
-home_dir = File.expand_path("~") || Etc.getpwuid.dir || (ENV["USER"] && File.expand_path("~#{ENV['USER']}"))
-if home_dir
-  global_config_path = File.join(home_dir, ".simplecov")
-  load global_config_path if File.exist?(global_config_path)
-end
-# Autoload config from .simplecov if present
-# Recurse upwards until we find .simplecov or reach the root directory
-config_path = Pathname.new(SimpleCov.root)
-loop do
-  filename = config_path.join(".simplecov")
-  if filename.exist?
-    begin
-      load filename
-    rescue LoadError, StandardError
-      $stderr.puts "Warning: Error occurred while trying to load #{filename}. " \
-        "Error message: #{$!.message}"
-    end
-    break
-  end
-  config_path, = config_path.split
-  break if config_path.root?
-end

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/lib/simplecov/exit_codes.rb DELETED

@@ -1,8 +0,0 @@
-module SimpleCov
-  module ExitCodes
-    SUCCESS = 0
-    EXCEPTION = 1
-    MINIMUM_COVERAGE = 2
-    MAXIMUM_COVERAGE_DROP = 3
-  end
-end

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/lib/simplecov/file_list.rb DELETED

@@ -1,59 +0,0 @@
-# An array of SimpleCov SourceFile instances with additional collection helper
-# methods for calculating coverage across them etc.
-module SimpleCov
-  class FileList < Array
-    # Returns the count of lines that have coverage
-    def covered_lines
-      return 0.0 if empty?
-      map { |f| f.covered_lines.count }.inject(&:+)
-    end
-    # Returns the count of lines that have been missed
-    def missed_lines
-      return 0.0 if empty?
-      map { |f| f.missed_lines.count }.inject(&:+)
-    end
-    # Returns the count of lines that are not relevant for coverage
-    def never_lines
-      return 0.0 if empty?
-      map { |f| f.never_lines.count }.inject(&:+)
-    end
-    # Returns the count of skipped lines
-    def skipped_lines
-      return 0.0 if empty?
-      map { |f| f.skipped_lines.count }.inject(&:+)
-    end
-    # Computes the coverage based upon lines covered and lines missed for each file
-    # Returns an array with all coverage percentages
-    def covered_percentages
-      map(&:covered_percent)
-    end
-    # Finds the least covered file and returns that file's name
-    def least_covered_file
-      sort_by(&:covered_percent).first.filename
-    end
-    # Returns the overall amount of relevant lines of code across all files in this list
-    def lines_of_code
-      covered_lines + missed_lines
-    end
-    # Computes the coverage based upon lines covered and lines missed
-    # @return [Float]
-    def covered_percent
-      return 100.0 if empty? || lines_of_code.zero?
-      Float(covered_lines * 100.0 / lines_of_code)
-    end
-    # Computes the strength (hits / line) based upon lines covered and lines missed
-    # @return [Float]
-    def covered_strength
-      return 0.0 if empty? || lines_of_code.zero?
-      Float(map { |f| f.covered_strength * f.lines_of_code }.inject(&:+) / lines_of_code)
-    end
-  end
-end