class SimpleCov::Result


library generates (Coverage.result).
A simplecov code coverage result, initialized from the Hash Ruby’s built-in coverage

def self.from_hash(hash)

Loads a SimpleCov::Result#to_hash dump 
def self.from_hash(hash)
  command_name, data = hash.first
  result = SimpleCov::Result.new(data["coverage"])
  result.command_name = command_name
  result.created_at = Time.at(data["timestamp"])
  result
end

def adapt_pre_simplecov_0_18_result(result) 

def adapt_pre_simplecov_0_18_result(result)
  result.map do |file_path, line_coverage_data|
    [file_path, {"lines" => line_coverage_data}]
  end.to_h
end

def adapt_result(result)

See https://github.com/colszowka/simplecov/pull/824#issuecomment-576049747
considered we can adapt them).
to have "old" resultsets lying around (but not too old so that they're still
We changed the format of the raw result data in simplecov, as people are likely 
def adapt_result(result)
  if pre_simplecov_0_18_result?(result)
    adapt_pre_simplecov_0_18_result(result)
  else
    result
  end
end

def command_name

Delegated to SimpleCov.command_name if not set manually
The command name that launched this result. 
def command_name
  @command_name ||= SimpleCov.command_name
end

def coverage 

def coverage
  keys = original_result.keys & filenames
  Hash[keys.zip(original_result.values_at(*keys))]
end

def created_at

Defines when this result has been created. Defaults to Time.now 
def created_at
  @created_at ||= Time.now
end

def filenames

Returns all filenames for source files contained in this result 
def filenames
  files.map(&:filename)
end

def filter!

Applies all configured SimpleCov filters on this result's source files 
def filter!
  @files = SimpleCov.filtered(files)
end

def format!

Applies the configured SimpleCov.formatter on this result 
def format!
  SimpleCov.formatter.new.format(self)
end

def groups

Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models' 
def groups
  @groups ||= SimpleCov.grouped(files)
end

def initialize(original_result)

coverage data)
Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of 
def initialize(original_result)
  result = adapt_result(original_result)
  @original_result = result.freeze
  @files = SimpleCov::FileList.new(result.map do |filename, coverage|
    SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage))) if File.file?(filename)
  end.compact.sort_by(&:filename))
  filter!
end

def pre_simplecov_0_18_result?(result)

pre 0.18 coverage data pointed from file directly to an array of line coverage 
def pre_simplecov_0_18_result?(result)
  _key, data = result.first
  data.is_a?(Array)
end

def to_hash

Returns a hash representation of this Result that can be used for marshalling it into JSON 
def to_hash
  {
    command_name => {
      "coverage" => coverage,
      "timestamp" => created_at.to_i
    }
  }
end