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(
    symbolize_names_of_coverage_results(data["coverage"])
  )
  result.command_name = command_name
  result.created_at = Time.at(data["timestamp"])
  result
end

def self.symbolize_names_of_coverage_results(coverage_data)

Returns:

(Hash) -

def self.symbolize_names_of_coverage_results(coverage_data)
  coverage_data.each_with_object({}) do |(file_name, file_coverage_result), coverage_results|
    coverage_results[file_name] = file_coverage_result.each_with_object({}) do |(k, v), cov_elem|
      cov_elem[k.to_sym] = v
    end
  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)
  @original_result = original_result.freeze
  @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
    SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage), :symbolize_names => true)) if File.file?(filename.to_s)
  end.compact.sort_by(&:filename))
  filter!
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

Modules

Classes