cvss-suite 1.0.0

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

@@ -0,0 +1,190 @@
+module SimpleCov
+  #
+  # Representation of a source file including it's coverage data, source code,
+  # source lines and featuring helpers to interpret that data.
+  #
+  class SourceFile
+    # Representation of a single line in a source file including
+    # this specific line's source code, line_number and code coverage,
+    # with the coverage being either nil (coverage not applicable, e.g. comment
+    # line), 0 (line not covered) or >1 (the amount of times the line was
+    # executed)
+    class Line
+      # The source code for this line. Aliased as :source
+      attr_reader :src
+      # The line number in the source file. Aliased as :line, :number
+      attr_reader :line_number
+      # The coverage data for this line: either nil (never), 0 (missed) or >=1 (times covered)
+      attr_reader :coverage
+      # Whether this line was skipped
+      attr_reader :skipped
+
+      # Lets grab some fancy aliases, shall we?
+      alias source src
+      alias line line_number
+      alias number line_number
+
+      def initialize(src, line_number, coverage)
+        fail ArgumentError, "Only String accepted for source" unless src.is_a?(String)
+        fail ArgumentError, "Only Fixnum accepted for line_number" unless line_number.is_a?(Fixnum)
+        fail ArgumentError, "Only Fixnum and nil accepted for coverage" unless coverage.is_a?(Fixnum) || coverage.nil?
+        @src         = src
+        @line_number = line_number
+        @coverage    = coverage
+        @skipped     = false
+      end
+
+      # Returns true if this is a line that should have been covered, but was not
+      def missed?
+        !never? && !skipped? && coverage.zero?
+      end
+
+      # Returns true if this is a line that has been covered
+      def covered?
+        !never? && !skipped? && coverage > 0
+      end
+
+      # Returns true if this line is not relevant for coverage
+      def never?
+        !skipped? && coverage.nil?
+      end
+
+      # Flags this line as skipped
+      def skipped!
+        @skipped = true
+      end
+
+      # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
+      # # :nocov: comment lines.
+      def skipped?
+        !!skipped
+      end
+
+      # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use
+      # as a css class in report generation
+      def status
+        return "skipped" if skipped?
+        return "never" if never?
+        return "missed" if missed?
+        return "covered" if covered?
+      end
+    end
+
+    # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
+    attr_reader :filename
+    # The array of coverage data received from the Coverage.result
+    attr_reader :coverage
+    # The source code for this file. Aliased as :source
+    attr_reader :src
+    alias source src
+
+    def initialize(filename, coverage)
+      @filename = filename
+      @coverage = coverage
+      File.open(filename, "rb") { |f| @src = f.readlines }
+    end
+
+    # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
+    # and thus including coverage data. Aliased as :source_lines
+    def lines
+      return @lines if defined? @lines
+
+      # Warning to identify condition from Issue #56
+      if coverage.size > src.size
+        $stderr.puts "Warning: coverage data provided by Coverage [#{coverage.size}] exceeds number of lines in #{filename} [#{src.size}]"
+      end
+
+      # Initialize lines
+      @lines = []
+      src.each_with_index do |src, i|
+        @lines << SimpleCov::SourceFile::Line.new(src, i + 1, coverage[i])
+      end
+      process_skipped_lines!
+      @lines
+    end
+    alias source_lines lines
+
+    # Access SimpleCov::SourceFile::Line source lines by line number
+    def line(number)
+      lines[number - 1]
+    end
+
+    # The coverage for this file in percent. 0 if the file has no relevant lines
+    def covered_percent
+      return 100.0 if lines.length.zero? || lines.length == never_lines.count
+      relevant_lines = lines.count - never_lines.count - skipped_lines.count
+      if relevant_lines.zero?
+        0.0
+      else
+        Float(covered_lines.count * 100.0 / relevant_lines.to_f)
+      end
+    end
+
+    def covered_strength
+      return 0.0 if lines.length.zero? || lines.length == never_lines.count
+
+      lines_strength = 0
+      lines.each do |c|
+        lines_strength += c.coverage if c.coverage
+      end
+
+      effective_lines_count = Float(lines.count - never_lines.count - skipped_lines.count)
+
+      if effective_lines_count.zero?
+        0.0
+      else
+        strength = lines_strength / effective_lines_count
+        round_float(strength, 1)
+      end
+    end
+
+    # Returns all covered lines as SimpleCov::SourceFile::Line
+    def covered_lines
+      @covered_lines ||= lines.select(&:covered?)
+    end
+
+    # Returns all lines that should have been, but were not covered
+    # as instances of SimpleCov::SourceFile::Line
+    def missed_lines
+      @missed_lines ||= lines.select(&:missed?)
+    end
+
+    # Returns all lines that are not relevant for coverage as
+    # SimpleCov::SourceFile::Line instances
+    def never_lines
+      @never_lines ||= lines.select(&:never?)
+    end
+
+    # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
+    def skipped_lines
+      @skipped_lines ||= lines.select(&:skipped?)
+    end
+
+    # Returns the number of relevant lines (covered + missed)
+    def lines_of_code
+      covered_lines.count + missed_lines.count
+    end
+
+    # Will go through all source files and mark lines that are wrapped within # :nocov: comment blocks
+    # as skipped.
+    def process_skipped_lines!
+      skipping = false
+      lines.each do |line|
+        if line.src =~ /^([\s]*)#([\s]*)(\:#{SimpleCov.nocov_token}\:)/
+          skipping = !skipping
+        elsif skipping
+          line.skipped!
+        end
+      end
+    end
+
+  private
+
+    # ruby 1.9 could use Float#round(places) instead
+    # @return [Float]
+    def round_float(float, places)
+      factor = Float(10 * places)
+      Float((float * factor).round / factor)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module SimpleCov
+  version = "0.11.2"
+
+  def version.to_a
+    split(".").map(&:to_i)
+  end
+
+  def version.major
+    to_a[0]
+  end
+
+  def version.minor
+    to_a[1]
+  end
+
+  def version.patch
+    to_a[2]
+  end
+
+  def version.pre
+    to_a[3]
+  end
+
+  VERSION = version.freeze
+end

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/simplecov.gemspec

@@ -0,0 +1,27 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "simplecov/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "simplecov"
+  gem.version     = SimpleCov::VERSION
+  gem.platform    = Gem::Platform::RUBY
+  gem.authors     = ["Christoph Olszowka"]
+  gem.email       = ["christoph at olszowka de"]
+  gem.homepage    = "http://github.com/colszowka/simplecov"
+  gem.description = %(Code coverage for Ruby 1.9+ with a powerful configuration library and automatic merging of coverage across test suites)
+  gem.summary     = gem.description
+  gem.license     = "MIT"
+
+  gem.required_ruby_version = ">= 1.8.7"
+
+  gem.add_dependency "json", "~> 1.8"
+  gem.add_dependency "simplecov-html", "~> 0.10.0"
+  gem.add_dependency "docile", "~> 1.1.0"
+
+  gem.add_development_dependency "bundler", "~> 1.9"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+end

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/1_8_fallbacks_spec.rb

@@ -0,0 +1,29 @@
+require "helper"
+
+# Tests that verify that on 1.8 versions of ruby, simplecov simply
+# does not launch and does not cause errors on the way
+#
+# TODO: This should be expanded upon all methods that could potentially
+# be called in a test/spec-helper simplecov config block
+#
+describe "Ruby 1.8 fallback" do
+  it "return false when calling SimpleCov.start" do
+    expect(SimpleCov.start).to be false
+  end
+
+  it "return false when calling SimpleCov.start with a block" do
+    expect(SimpleCov.start { fail "Shouldn't reach this!" }).to be false
+  end
+
+  it "return false when calling SimpleCov.configure with a block" do
+    expect(SimpleCov.configure { fail "Shouldn't reach this!" }).to be false
+  end
+
+  it "allow to define a profile" do
+    expect do
+      SimpleCov.profiles.define "testprofile" do
+        add_filter "/config/"
+      end
+    end.not_to raise_error
+  end
+end if RUBY_VERSION.start_with? "1.8"

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/command_guesser_spec.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+describe SimpleCov::CommandGuesser do
+  subject { SimpleCov::CommandGuesser }
+  it 'correctly guesses "Unit Tests" for unit tests' do
+    subject.original_run_command = "/some/path/test/units/foo_bar_test.rb"
+    expect(subject.guess).to eq("Unit Tests")
+    subject.original_run_command = "test/units/foo.rb"
+    expect(subject.guess).to eq("Unit Tests")
+    subject.original_run_command = "test/foo.rb"
+    expect(subject.guess).to eq("Unit Tests")
+    subject.original_run_command = "test/{models,helpers,unit}/**/*_test.rb"
+    expect(subject.guess).to eq("Unit Tests")
+  end
+
+  it 'correctly guesses "Functional Tests" for functional tests' do
+    subject.original_run_command = "/some/path/test/functional/foo_bar_controller_test.rb"
+    expect(subject.guess).to eq("Functional Tests")
+    subject.original_run_command = "test/{controllers,mailers,functional}/**/*_test.rb"
+    expect(subject.guess).to eq("Functional Tests")
+  end
+
+  it 'correctly guesses "Integration Tests" for integration tests' do
+    subject.original_run_command = "/some/path/test/integration/foo_bar_controller_test.rb"
+    expect(subject.guess).to eq("Integration Tests")
+    subject.original_run_command = "test/integration/**/*_test.rb"
+    expect(subject.guess).to eq("Integration Tests")
+  end
+
+  it 'correctly guesses "Cucumber Features" for cucumber features' do
+    subject.original_run_command = "features"
+    expect(subject.guess).to eq("Cucumber Features")
+    subject.original_run_command = "cucumber"
+    expect(subject.guess).to eq("Cucumber Features")
+  end
+
+  it 'correctly guesses "RSpec" for RSpec' do
+    subject.original_run_command = "/some/path/spec/foo.rb"
+    expect(subject.guess).to eq("RSpec")
+  end
+
+  it "defaults to RSpec because RSpec constant is defined" do
+    subject.original_run_command = "some_arbitrary_command with arguments"
+    expect(subject.guess).to eq("RSpec")
+  end
+end if SimpleCov.usable?

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/deleted_source_spec.rb

@@ -0,0 +1,12 @@
+require "helper"
+
+# Test to verify correct handling of deleted files
+# See https://github.com/colszowka/simplecov/issues/9
+describe "A source file which is subsequently deleted" do
+  it "does not cause an error" do
+    Dir.chdir(File.join(File.dirname(__FILE__), "fixtures")) do
+      `ruby deleted_source_sample.rb`
+      expect($?.exitstatus).to be_zero
+    end
+  end
+end

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/faked_project/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "simplecov", :path => "../../../"
+gem "rake"
+gem "rspec", ">= 2.6.0"
+gem "cucumber"

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/faked_project/Rakefile

@@ -0,0 +1,8 @@
+require "bundler"
+
+require "rake/testtask"
+Rake::TestTask.new(:test) do |test|
+  test.libs << "lib" << "test"
+  test.test_files = FileList["test/**/*_test.rb"].sort
+  test.verbose = true
+end

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/faked_project/cucumber.yml

@@ -0,0 +1,13 @@
+<%
+rerun = File.file?('rerun.txt') ? IO.read('rerun.txt') : ""
+rerun_opts = rerun.to_s.strip.empty? ? "--format #{ENV['CUCUMBER_FORMAT'] || 'progress'} features" : "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} #{rerun}"
+std_opts = "--format #{ENV['CUCUMBER_FORMAT'] || 'progress'} --strict --tags ~@wip"
+interp_opts = if defined?(RUBY_ENGINE)
+  " --tags ~@exclude-#{RUBY_ENGINE}"
+else
+  ''
+end
+%>
+default: <%= std_opts %><%= interp_opts %> features
+wip: --tags @wip:30 --wip features<%= interp_opts %>
+rerun: <%= rerun_opts %> --format rerun --out rerun.txt --strict --tags ~@wip<%= interp_opts %>

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/faked_project/features/step_definitions/my_steps.rb

@@ -0,0 +1,22 @@
+Given /^I want to keep stuff simple$/ do
+  expect(1).to eq(1)
+end
+
+When /^I write my cukes for the fake project$/ do
+  expect(1).to eq(1)
+end
+
+Then /^I make all neccessary tests in a single step$/ do
+  expect(FakedProject.foo).to eq("bar")
+
+  expect(FrameworkSpecific.cucumber).to eq("Only tested in Cucumber")
+
+  expect(FakedProject.a_class_method).to eq("this is a mixed-in class method")
+
+  expect(FakedProject.new.an_instance_method).to eq("this is a mixed-in instance method")
+  expect(FakedProject.new.dynamic).to eq("A dynamically defined instance method")
+
+  something = SomeClass.new("foo")
+  expect(something.reverse).to eq("oof")
+  expect(something.compare_with("foo")).to be true
+end

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/faked_project/features/support/env.rb

@@ -0,0 +1,12 @@
+require "bundler/setup"
+
+# We're injecting simplecov_config via aruba in cucumber here
+# depending on what the test case is...
+begin
+  require File.join(File.dirname(__FILE__), "simplecov_config")
+rescue LoadError
+  $stderr.puts "No SimpleCov config file found!"
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "/../../lib"))
+require "faked_project"

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/faked_project/features/test_stuff.feature

@@ -0,0 +1,6 @@
+Feature: Foo
+
+  Scenario: Test stuff
+    Given I want to keep stuff simple
+    When I write my cukes for the fake project
+    Then I make all neccessary tests in a single step

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/faked_project/lib/faked_project.rb

@@ -0,0 +1,11 @@
+class FakedProject
+  def self.foo
+    "bar"
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), "faked_project/*.rb")].reject { |f| /untested/.match(f) }.each do |file|
+  require file # Require all source files in project dynamically so we can inject some stuff depending on test situation
+end
+
+FakedProject.send :include, MetaMagic

data/vendor/cache/ruby/2.2.0/gems/simplecov-0.11.2/spec/faked_project/lib/faked_project/framework_specific.rb

@@ -0,0 +1,18 @@
+# A pile of methods that only get tested in their frameworks
+# and thus make this file only 100% covered when all framework test
+# results are merged
+module FrameworkSpecific
+  class << self
+    def cucumber
+      "Only tested in Cucumber"
+    end
+
+    def rspec
+      "Only tested in RSpec"
+    end
+
+    def test_unit
+      "Only tested in Test/Unit"
+    end
+  end
+end