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 branches

Return all the branches inside current source file 
def branches
  @branches ||= BranchBuilder.new(self).call
end

def branches_coverage_percent

DEPRECATED: use `covered_percent(:branch)`. 
def branches_coverage_percent
  SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#branches_coverage_percent` is deprecated. " \
                              "Use `covered_percent(:branch)`.")
  covered_percent(:branch)
end

def branches_for_line(line_number) 

def branches_for_line(line_number)
  branches_report.fetch(line_number, [])
end

def branches_report

Return hash with key of line number and branch coverage count as value 
def branches_report
  @branches_report ||=
    branches.reject(&:skipped?).group_by(&:report_line).transform_values { |bs| bs.map(&:report) }
end

def coverage_statistics(criterion = nil)

(`:line` / `:branch` / `:method`) to get that one CoverageStatistics.
returns the `{line:, branch:, method:}` Hash; pass a criterion symbol
The per-criterion coverage statistics for this file. With no argument
`SimpleCov.coverage_criterion_enabled?`.
(FileList, formatters) decide which keys to surface based on
enabled during the run — those collapse to 0/0/0. Consumers
value is a CoverageStatistics, even for criteria that weren't
Returns a hash keyed by every supported coverage criterion. Each 
def coverage_statistics(criterion = nil)
  stats = (@coverage_statistics ||= Statistics.new(self).call)
  criterion ? stats[criterion] : stats
end

def covered_branches

report.
isn't declared in code but is given by default by the coverage
some conditions like `case` may have an additional `else` that
Select the covered branches. We use a tree schema here because 
def covered_branches
  @covered_branches ||= branches.select(&:covered?)
end

def covered_lines

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

def covered_methods 

def covered_methods
  @covered_methods ||= methods.select(&:covered?)
end

def covered_percent(criterion = :line)

default). Returns nil if the criterion was not measured.
The coverage for this file in percent, for the given criterion (line by 
def covered_percent(criterion = :line)
  coverage_statistics(criterion)&.percent
end

def covered_strength(criterion = :line) 

def covered_strength(criterion = :line)
  coverage_statistics(criterion)&.strength
end

def initialize(filename, coverage_data, loaded: true) 

def initialize(filename, coverage_data, loaded: true)
  @filename = filename
  @coverage_data = coverage_data
  @loaded = loaded
end

def line(number)

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

def line_with_missed_branch?(line_number)

Check if any branches missing on given line number 
def line_with_missed_branch?(line_number)
  branches_for_line(line_number).any? { |_type, count| count.zero? }
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 ||= LineBuilder.new(self).call
end

def lines_of_code

Returns the number of relevant lines (covered + missed) 
def lines_of_code
  coverage_statistics[:line]&.total || 0
end

def methods

Return all methods detected in this source file 
def methods
  @methods ||= MethodBuilder.new(self).call
end

def methods_coverage_percent

DEPRECATED: use `covered_percent(:method)`. 
def methods_coverage_percent
  SimpleCov::Deprecation.warn("`SimpleCov::SourceFile#methods_coverage_percent` is deprecated. " \
                              "Use `covered_percent(:method)`.")
  covered_percent(:method)
end

def missed_branches

Select the missed branches with coverage equal to zero 
def missed_branches
  @missed_branches ||= branches.select(&:missed?)
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 missed_methods 

def missed_methods
  @missed_methods ||= methods.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_branches? 

def no_branches?
  total_branches.empty?
end

def no_lines? 

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

def not_loaded?

Whether this file was added via track_files but never loaded/required. 
def not_loaded?
  !@loaded
end

def project_filename

The path to this source file relative to the projects directory 
def project_filename
  @filename.delete_prefix(SimpleCov.root).sub(%r{\A[/\\]}, "")
end

def relevant_lines 

def relevant_lines
  lines.size - never_lines.size - skipped_lines.size
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

Intentionally read lazily to suppress reading unused source code.
The source code for this file. Aliased as :source. 
def src
  @src ||= SourceLoader.call(filename)
end

def total_branches

Return the relevant branches to source file 
def total_branches
  @total_branches ||= covered_branches + missed_branches
end