class Covered::Persist

Constants

DEFAULT_PATH

Public Class Methods

new(output, path = DEFAULT_PATH) click to toggle source
Calls superclass method
# File lib/covered/persist.rb, line 31
def initialize(output, path = DEFAULT_PATH)
        super(output)
        
        @path = path
        
        @touched = Set.new
end

Public Instance Methods

apply(record) click to toggle source
# File lib/covered/persist.rb, line 39
def apply(record)
        # The file must still exist:
        return unless path = expand_path(record[:path])
        return unless File.exist? path
        
        # If the file has been modified since... we can't use the coverage.
        return unless mtime = record[:mtime]
        return if File.mtime(path).to_f > record[:mtime]
        
        record[:coverage].each_with_index do |count, index|
                @output.mark(path, index, count) if count
        end
end
disable() click to toggle source
Calls superclass method
# File lib/covered/persist.rb, line 100
def disable
        super
        
        # @touched.each do |path|
        #    if @output.accept?(path)
        #            puts "Updated #{path} coverage."
        #    end
        # end
        
        save!
end
enable() click to toggle source
Calls superclass method
# File lib/covered/persist.rb, line 94
def enable
        super
        
        load!
end
load!(path = @path) click to toggle source
# File lib/covered/persist.rb, line 62
def load!(path = @path)
        return unless File.exist?(@path)
        
        # Load existing coverage information and mark all files:
        File.open(@path, "r") do |file|
                file.flock(File::LOCK_SH)
                
                make_unpacker(file).each(&self.method(:apply))
        end
end
make_packer(io) click to toggle source

def each

super do |coverage|
        if @touched.include?(coverage.path)
                yield coverage
        end
end

end

# File lib/covered/persist.rb, line 120
def make_packer(io)
        packer = MessagePack::Packer.new(io)
        packer.register_type(0x00, Symbol, :to_msgpack_ext)
        packer.register_type(0x01, Time) {|object| object.to_s}
        
        return packer
end
make_unpacker(io) click to toggle source
# File lib/covered/persist.rb, line 128
def make_unpacker(io)
        unpacker = MessagePack::Unpacker.new(io)
        unpacker.register_type(0x00, Symbol, :from_msgpack_ext)
        unpacker.register_type(0x01, Time, :parse)
        
        return unpacker
end
mark(file, line, count) click to toggle source
Calls superclass method
# File lib/covered/persist.rb, line 88
def mark(file, line, count)
        @touched << file

        super
end
save!(path = @path) click to toggle source
# File lib/covered/persist.rb, line 73
def save!(path = @path)
        # Dump all coverage:
        File.open(@path, "w") do |file|
                file.flock(File::LOCK_EX)
                
                packer = make_packer(file)
                
                self.each do |coverage|
                        packer.write(serialize(coverage))
                end
                
                packer.flush
        end
end
serialize(coverage) click to toggle source
# File lib/covered/persist.rb, line 53
def serialize(coverage)
        {
                # We want to use relative paths so that moving the repo won't break everything:
                path: relative_path(coverage.path),
                coverage: coverage.counts,
                mtime: File.mtime(coverage.path).to_f,
        }
end