class SimpleCov::SourceFile


source lines and featuring helpers to interpret that data.
Representation of a source file including it’s coverage data, source code,

def build_lines 

def build_lines
  coverage_exceeding_source_warn if coverage.size > src.size
  lines = src.map.with_index(1) do |src, i|
    SimpleCov::SourceFile::Line.new(src, i, coverage[i - 1])
  end
  process_skipped_lines(lines)
end

def coverage_exceeding_source_warn

Warning to identify condition from Issue #56 
def coverage_exceeding_source_warn
  $stderr.puts "Warning: coverage data provided by Coverage [#{coverage.size}] exceeds number of lines in #{filename} [#{src.size}]"
end

def covered_lines

Returns all covered lines as SimpleCov::SourceFile::Line 
def covered_lines
  @covered_lines ||= lines.select(&:covered?)
end

def covered_percent

The coverage for this file in percent. 0 if the file has no relevant lines 
def covered_percent
  return 100.0 if no_lines?
  return 0.0 if relevant_lines.zero?
  Float(covered_lines.size * 100.0 / relevant_lines.to_f)
end

def covered_strength 

def covered_strength
  return 0.0 if relevant_lines.zero?
  round_float(lines_strength / relevant_lines.to_f, 1)
end

def initialize(filename, coverage) 

def initialize(filename, coverage)
  @filename = filename
  @coverage = coverage
end

def line(number)

Access SimpleCov::SourceFile::Line source lines by line number 
def line(number)
  lines[number - 1]
end

def lines

and thus including coverage data. Aliased as :source_lines
Returns all source lines for this file as instances of SimpleCov::SourceFile::Line, 
def lines
  @lines ||= build_lines
end

def lines_of_code

Returns the number of relevant lines (covered + missed) 
def lines_of_code
  covered_lines.size + missed_lines.size
end

def lines_strength 

def lines_strength
  lines.map(&:coverage).compact.reduce(:+)
end

def missed_lines

as instances of SimpleCov::SourceFile::Line
Returns all lines that should have been, but were not covered 
def missed_lines
  @missed_lines ||= lines.select(&:missed?)
end

def never_lines

SimpleCov::SourceFile::Line instances
Returns all lines that are not relevant for coverage as 
def never_lines
  @never_lines ||= lines.select(&:never?)
end

def no_lines? 

def no_lines?
  lines.length.zero? || (lines.length == never_lines.size)
end

def process_skipped_lines(lines)

as skipped.
Will go through all source files and mark lines that are wrapped within # :nocov: comment blocks 
def process_skipped_lines(lines)
  skipping = false
  lines.each do |line|
    if SimpleCov::LinesClassifier.no_cov_line?(line.src)
      skipping = !skipping
      line.skipped!
    elsif skipping
      line.skipped!
    end
  end
end

def project_filename

The path to this source file relative to the projects directory 
def project_filename
  @filename.sub(/^#{SimpleCov.root}/, "")
end

def relevant_lines 

def relevant_lines
  lines.size - never_lines.size - skipped_lines.size
end

def round_float(float, places)

Returns:
  • (Float) - 
def round_float(float, places)
  factor = Float(10 * places)
  Float((float * factor).round / factor)
end

def skipped_lines

Returns all lines that were skipped as SimpleCov::SourceFile::Line instances 
def skipped_lines
  @skipped_lines ||= lines.select(&:skipped?)
end

def src

The source code for this file. Aliased as :source 
def src
  # We intentionally read source code lazily to
  # suppress reading unused source code.
  @src ||= File.open(filename, "rb", &:readlines)
end