gcovtools 1.0.0

data/lib/project.rb

@@ -0,0 +1,146 @@
+require_relative './file'
+require_relative './line'
+require_relative './logging'
+
+module GCOVTOOLS
+
+  class Project
+    
+    attr_reader :files, :stats
+    attr_accessor :name
+
+    def initialize name=""
+      @name = name
+      @files = {}
+      @adding = false
+    end
+
+    def <<(file)
+      if @files.has_key?file.name
+        @files[file.name].merge! file
+      else
+        @files[file.name] = file
+      end
+      _update_stats unless @adding
+    end
+
+    def files
+      @files.sort{|a,b| 
+        if ::File.basename(a[0]) < ::File.basename(b[0])
+          -1
+        elsif ::File.basename(a[0]) == ::File.basename(b[0])
+          0
+        else
+          1
+        end }.map{|key,val|val}
+    end
+
+    def add_files &block
+      # suspend stat updates until done adding files
+      fail "add_files requires a block" unless block_given?
+
+      # guard against nested calls
+      was_adding = @adding
+      @adding = true
+      yield
+      @adding = was_adding
+
+      _update_stats unless @adding
+
+    end
+
+    def _update_stats
+      @stats = { 
+        :missed_lines => 0,
+        :exec_lines => 0,
+        :empty_lines => 0,
+        :total_exec => 0,
+        :total_lines => 0,
+        :lines => 0,
+        :coverage => 0.0,
+        :hits_per_line => 0
+      }
+
+      @files.each do |name,file|
+        @stats[:missed_lines] += file.stats[:missed_lines]
+        @stats[:exec_lines] += file.stats[:exec_lines]
+        @stats[:total_exec] += file.stats[:total_exec]
+        @stats[:empty_lines] += file.stats[:empty_lines]
+      end
+        
+      @stats[:lines] = @stats[:exec_lines] + @stats[:missed_lines]
+      @stats[:total_lines] = @stats[:lines] + @stats[:empty_lines]
+
+      if @stats[:lines] > 0
+        @stats[:coverage] = @stats[:exec_lines].to_f / @stats[:lines].to_f
+        @stats[:hits_per_line] = @stats[:total_exec].to_f / @stats[:lines]
+      else
+        @stats[:coverage] = 1
+        @stats[:hits_per_line] = 0
+      end  
+      
+      @stats[:coverage_s] = sprintf("%0.01f%",100.0*@stats[:coverage])
+      @stats[:hits_per_line_s] = sprintf("%0.02f",@stats[:hits_per_line])
+
+    end
+
+    def _add_file path, hash_={}
+      GCOVTOOLS::logger.info "parsing file: #{path}"
+
+      hash = hash_.dup
+      
+      files = GCOVTOOLS::File.load(path)
+
+      # apply _inclusive_ filters first
+      files.select!{ |file| 
+        hash[:include].nil? or hash[:include].empty? or !hash[:include].select{|f| f.match(::Pathname.new(file.meta['Source']).cleanpath.to_s) }.empty? 
+      }
+
+      GCOVTOOLS::logger.info "included #{files.size} files"
+
+      old_size = files.size
+
+      # apply _exclusive_ filters next
+      files.select!{ |file| 
+        hash[:exclude].nil? or hash[:exclude].empty? or hash[:exclude].select{|f| f.match(::Pathname.new(file.meta['Source']).cleanpath.to_s) }.empty? 
+      }
+
+      GCOVTOOLS::logger.info "excluded #{old_size-files.size} files"
+
+      # add all the files that survived the gauntlet
+      files.map{ |file| self << file }
+    end
+
+    def add_dir path, hash_={}
+      GCOVTOOLS::logger.info "searching: #{path}"
+      hash = hash_.dup
+      if hash[:recursive] == true
+        filenames = Dir["#{path}/**/*.gcov"]
+      else
+        filenames = Dir["#{path}/*.gcov"]
+      end
+
+      GCOVTOOLS::logger.info "found: #{filenames}"
+
+      add_files do 
+        filenames.each do |filename|
+          _add_file filename, hash
+        end # each filename
+      end # add_files
+    end # #add_dir
+    
+    def add_file path, hash_={}
+      hash = hash_.dup
+      add_files do
+        _add_file path, hash
+      end # add_files
+    end # #add_file
+
+    def self.load_dir path, hash={}
+      project = GCOVTOOLS::Project.new
+      project.add_dir path, hash
+      project
+    end
+
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module GCOVTOOLS
+  VERSION = '1.0.0'
+end

data/lib/xml_formatter.rb

@@ -0,0 +1,58 @@
+
+require_relative './project'
+require_relative './file'
+require_relative './line'
+
+# require 'gyoku'
+require 'builder'
+
+module GCOVTOOLS
+  
+  class XMLFormatter
+    
+    def initialize project, va={}
+      @project = project
+      @xsl = va[:xsl]
+      
+      # @hash = { :files => { :file => [] } }
+      @xml = Builder::XmlMarkup.new( :indent => 2 )
+      @xml.instruct! :xml, :encoding => "UTF-8"
+
+      if @xsl
+        @xml.instruct! :"xml-stylesheet", :href => @xsl, :type => "text/xsl"
+      end
+      
+      @xml.projects do |xprojects|
+        xprojects.project(:name=>"Test") do |xproject|
+          xproject.files do |xfiles|
+            @project.files.each do |file|
+              xfiles.file(:name => file.name) do |xfile|
+                xfile.lines do |xlines|
+                  file.lines.select{|line| line.number > 0}.each do |line|
+                    xlines.line(:number=>line.number,:count=>line.count) do |xline|
+                      xline.count line.count
+                      xline.text do |xtext|
+                        xtext.cdata! line.text
+                      end # xtext
+                    end # xline
+                  end # line
+                end # xlines
+              end # xfile
+            end # file
+          end # xfiles
+        end # xproject
+      end # xprojects
+    end # initialize
+    
+    def print
+      # puts "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+      # if @xslt
+      #   puts "<?xml-stylesheet href=\"#{@xslt}\" type=\"text/xsl\"?>"
+      # end
+      # puts Gyoku.xml( @hash )
+      puts @xml.target!
+    end # XMLFormatter#print
+
+  end # XMLFormatter
+
+end # GCOVTOOLS

data/spec/gcovtools/concat/test_cat.cpp.gcov

@@ -0,0 +1,35 @@
+        -:    0:Source:test.cpp
+        -:    0:Graph:test.gcno
+        -:    0:Data:test.gcda
+        -:    0:Runs:1
+        -:    0:Programs:1
+        -:    1:#include "test.h"
+        -:    2:
+        -:    3:int main( int argc, const char* argv[] )
+        -:    4:{
+        1:    5:    reached(2);
+        1:    6:    reached2(2);
+        1:    7:    reached3(2);
+        1:    8:    return 0;
+        -:    9:}
+        -:    0:Source:test1.cpp
+        -:    0:Graph:test1.gcno
+        -:    0:Data:test1.gcda
+        -:    0:Runs:2
+        -:    0:Programs:1
+        -:    1:
+        -:    2:int reached( int i )
+        -:    3:{
+        2:    4:    int j = i;
+        -:    5:
+        2:    6:    if( j == 2 )
+        2:    7:        return j;
+        -:    8:    
+    #####:    9:    return 3;
+        2:   10:}
+        -:   11:
+        -:   12:int unreached( int x )
+        -:   13:{
+    #####:   14:    int y = x;
+    #####:   15:    return y+3;
+        -:   16:}

data/spec/gcovtools/data/data2/test3.cpp.gcov

@@ -0,0 +1,22 @@
+        -:    0:Source:test3.cpp
+        -:    0:Graph:test3.gcno
+        -:    0:Data:test3.gcda
+        -:    0:Runs:4
+        -:    0:Programs:1
+        -:    1:
+        -:    2:int unreached3( int x )
+        -:    3:{
+    #####:    4:    int y = x;
+    #####:    5:    return y+3;
+        -:    6:}
+        -:    7:
+        -:    8:int reached3( int i )
+        -:    9:{
+        4:   10:    int j = i;
+        -:   11:
+        4:   12:    if( j == 2 )
+        4:   13:        return j;
+        -:   14:    
+    #####:   15:    return 3;
+        4:   16:}
+        -:   17:

data/spec/gcovtools/data/test.cpp.gcov

@@ -0,0 +1,14 @@
+        -:    0:Source:test.cpp
+        -:    0:Graph:test.gcno
+        -:    0:Data:test.gcda
+        -:    0:Runs:1
+        -:    0:Programs:1
+        -:    1:#include "test.h"
+        -:    2:
+        -:    3:int main( int argc, const char* argv[] )
+        -:    4:{
+        1:    5:    reached(2);
+        1:    6:    reached2(2);
+        1:    7:    reached3(2);
+        1:    8:    return 0;
+        -:    9:}

data/spec/gcovtools/data/test1.cpp.gcov

@@ -0,0 +1,21 @@
+        -:    0:Source:test1.cpp
+        -:    0:Graph:test1.gcno
+        -:    0:Data:test1.gcda
+        -:    0:Runs:2
+        -:    0:Programs:1
+        -:    1:
+        -:    2:int reached( int i )
+        -:    3:{
+        2:    4:    int j = i;
+        -:    5:
+        2:    6:    if( j == 2 )
+        2:    7:        return j;
+        -:    8:    
+    #####:    9:    return 3;
+        2:   10:}
+        -:   11:
+        -:   12:int unreached( int x )
+        -:   13:{
+    #####:   14:    int y = x;
+    #####:   15:    return y+3;
+        -:   16:}

data/spec/gcovtools/data/test2.cpp.gcov

@@ -0,0 +1,22 @@
+        -:    0:Source:test2.cpp
+        -:    0:Graph:test2.gcno
+        -:    0:Data:test2.gcda
+        -:    0:Runs:3
+        -:    0:Programs:1
+        -:    1:
+        -:    2:int unreached2( int x )
+        -:    3:{
+    #####:    4:    int y = x;
+    #####:    5:    return y+3;
+        -:    6:}
+        -:    7:
+        -:    8:int reached2( int i )
+        -:    9:{
+        3:   10:    int j = i;
+        -:   11:
+        3:   12:    if( j == 2 )
+        3:   13:        return j;
+        -:   14:    
+    #####:   15:    return 3;
+        3:   16:}
+        -:   17:

data/spec/gcovtools/file_spec.rb

@@ -0,0 +1,140 @@
+require_relative '../spec_helper'
+
+describe GCOVTOOLS::File do
+
+  it "requires a filename" do
+    expect{ file = GCOVTOOLS::File.new }.to raise_error
+  end
+  
+  describe "#name" do
+    it "returns the filename it was given" do
+      file = GCOVTOOLS::File.new "myfile.cpp"
+      expect(file.name).to eq("myfile.cpp")
+    end
+  end
+
+  describe "#<<" do
+    it "doesn't allow adding lines outside of the add_lines block" do
+      file = GCOVTOOLS::File.new "myfile.cpp"
+      expect{ 
+        file << GCOVTOOLS::Line.new(1,4,"line 1")
+      }.to raise_error
+    end
+  end
+
+  describe "#add_lines" do
+    it "computes stats after adding lines" do
+      file = GCOVTOOLS::File.new "myfile.cpp"
+      file.add_lines do
+        file << GCOVTOOLS::Line.new(1,4,"line 1")
+        file << GCOVTOOLS::Line.new(2,23,"line 2")
+        file << GCOVTOOLS::Line.new(3,:none,"line 3")
+        file << GCOVTOOLS::Line.new(4,:missed,"line 4")
+        file << GCOVTOOLS::Line.new(5,:missed,"line 5")
+      end
+      expect(file.stats[:lines]).to eq(4)
+      expect(file.stats[:total_lines]).to eq(5)
+      expect(file.stats[:total_exec]).to eq(27)
+      expect(file.stats[:empty_lines]).to eq(1)
+      expect(file.stats[:exec_lines]).to eq(2)
+      expect(file.stats[:missed_lines]).to eq(2)
+      expect(file.stats[:coverage]).to eq(0.5)
+      expect(file.stats[:hits_per_line]).to eq(27.0/4)
+    end
+
+    it "handles files with 0 executable lines" do
+      file = GCOVTOOLS::File.new "myfile.cpp"
+      file.add_lines do
+        file << GCOVTOOLS::Line.new(1,:none,"line 1")
+        file << GCOVTOOLS::Line.new(2,:none,"line 2")
+        file << GCOVTOOLS::Line.new(3,:none,"line 3")
+        file << GCOVTOOLS::Line.new(4,:none,"line 4")
+      end
+      expect(file.stats[:lines]).to eq(0)
+      expect(file.stats[:coverage]).to eq(1)
+      expect(file.stats[:hits_per_line]).to eq(0)
+    end
+  end
+
+  describe "#lines" do
+    it "returns no lines by default" do
+      file = GCOVTOOLS::File.new "myfile.cpp"
+      expect(file.lines.count).to eq(0)
+    end
+    
+    it "should return the lines it was given, sorted by number" do
+      file = GCOVTOOLS::File.new "myfile.cpp"
+      file.add_lines do
+        file << GCOVTOOLS::Line.new(2,23,"line 2")
+        file << GCOVTOOLS::Line.new(1,4,"line 1")
+      end
+      expect(file.lines.count).to eq(2)
+      expect(file.lines[0].number).to eq(1)
+      expect(file.lines[1].number).to eq(2)
+    end
+    
+  end
+
+  describe ".load" do
+    it "can load a gcov file" do
+      file = GCOVTOOLS::File.load(File.join(File.dirname(__FILE__),"data/test.cpp.gcov"))[0]
+      expect(file.lines.count).to eq(9)
+      expect(file.meta["Graph"]).to eq("test.gcno")
+      expect(file.meta["Runs"].to_i).to eq(1)
+    end
+
+    it "should split concatenated gcov files into multiple objects" do
+      files = GCOVTOOLS::File.load(File.join(File.dirname(__FILE__),"concat/test_cat.cpp.gcov"))
+      
+      expect(files.count).to eq(2)
+      expect(files[0].meta["Source"]).to eq("test.cpp")
+      expect(files[1].meta["Source"]).to eq("test1.cpp")
+
+      expect(files[0].lines.count).to eq(9)
+      expect(files[0].meta["Graph"]).to eq("test.gcno")
+      expect(files[0].meta["Runs"].to_i).to eq(1)
+    end
+  end
+
+  describe ".demangle" do
+    it "should demangle file names with nonexisting components" do
+      demangled = GCOVTOOLS::File.demangle( "testfile.cpp.###Applications#Xcode.app#Nonexisting#Path#Contents#Developer#Toolchains#XcodeDefault.xctoolchain#usr#bin#^#include#c++#v1#streambuf.gcov" )
+      expect( demangled ).to eq("/Applications/Xcode.app/Nonexisting/Path/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/streambuf")
+    end
+  end
+
+  describe "#merge" do
+
+    it "should merge the counts of each line and recompute stats" do
+      file = GCOVTOOLS::File.new "myfile.cpp"
+      file.add_lines do
+        file << GCOVTOOLS::Line.new(1,4,"line 1")
+        file << GCOVTOOLS::Line.new(2,23,"line 2")
+        file << GCOVTOOLS::Line.new(3,:none,"line 3")
+        file << GCOVTOOLS::Line.new(4,:missed,"line 4")
+        file << GCOVTOOLS::Line.new(5,:missed,"line 5")
+      end
+
+      file2 = GCOVTOOLS::File.new "myfile.cpp"
+      file2.add_lines do
+        file2 << GCOVTOOLS::Line.new(1,1,"line 1")
+        file2 << GCOVTOOLS::Line.new(2,:missed,"line 2")
+        file2 << GCOVTOOLS::Line.new(3,:none,"line 3")
+        file2 << GCOVTOOLS::Line.new(4,4,"line 4")
+        file2 << GCOVTOOLS::Line.new(5,:missed,"line 5")
+      end
+
+      file3 = file.merge file2
+
+      expect(file3.stats[:lines]).to eq(4)
+      expect(file3.stats[:total_lines]).to eq(5)
+      expect(file3.stats[:total_exec]).to eq(32)
+      expect(file3.stats[:empty_lines]).to eq(1)
+      expect(file3.stats[:exec_lines]).to eq(3)
+      expect(file3.stats[:missed_lines]).to eq(1)
+      expect(file3.stats[:coverage]).to eq(0.75)
+      expect(file3.stats[:hits_per_line]).to eq(32.0/4)
+
+    end # it
+  end # describe
+end

data/spec/gcovtools/line_spec.rb

@@ -0,0 +1,93 @@
+require_relative '../spec_helper'
+
+describe GCOVTOOLS::Line do
+  describe "#number" do
+    it "returns the number it was given" do
+      line = GCOVTOOLS::Line.new 2, 4, "abcdef"
+      expect(line.number).to eq(2)
+    end
+  end
+
+  describe "#count" do
+    it "returns the count it was given" do
+      line = GCOVTOOLS::Line.new 2, 4, "abcdef"
+      expect(line.count).to eq(4)
+    end
+  end
+
+  describe "#text" do
+    it "returns the text it was given" do
+      line = GCOVTOOLS::Line.new 2, 4, "abcdef"
+      expect(line.text).to eq("abcdef")
+    end
+  end
+
+  describe ".parse" do
+    it "parses gcov format line with count" do
+      line = GCOVTOOLS::Line.parse "        2:   55:  std::string StringUtil::ltrim( const std::string &s ) "
+      expect(line.number).to eq(55)
+      expect(line.count).to eq(2)
+      expect(line.text).to eq("  std::string StringUtil::ltrim( const std::string &s ) ")
+    end
+
+    it "parses empty gcov format line" do
+      line = GCOVTOOLS::Line.parse "        -:   35:   * don't worry about excessive copying."
+      expect(line.number).to eq(35)
+      expect(line.count).to eq(:none)
+      expect(line.text).to eq("   * don't worry about excessive copying.")
+    end
+
+    it "parses missed gcov format line" do
+      line = GCOVTOOLS::Line.parse "    #####:   89:  }  "
+      expect(line.number).to eq(89)
+      expect(line.count).to eq(:missed)
+      expect(line.text).to eq("  }  ")
+    end
+
+  end
+
+  describe "#state" do
+    it "should return :exec if it has positive count" do
+      line = GCOVTOOLS::Line.new 3,5,"line x"
+      expect(line.state).to eq(:exec)
+    end
+
+    it "should return :missed if it was missed" do
+      line = GCOVTOOLS::Line.new 3,:missed,"line x"
+      expect(line.state).to eq(:missed)
+    end
+
+    it "should return :none if it is not relevant" do
+      line = GCOVTOOLS::Line.new 3,:none,"line x"
+      expect(line.state).to eq(:none)
+    end
+  end
+
+  describe "#merge" do
+    it "should add hit counts" do
+      line = GCOVTOOLS::Line.new 3,4, "abcdef"
+      line2 = GCOVTOOLS::Line.new 3,1, "abcdef"
+      line3 = line.merge line2
+      expect(line3.count).to eq(5)
+
+      line = GCOVTOOLS::Line.new 3,:missed, "abcdef"
+      line2 = GCOVTOOLS::Line.new 3,1, "abcdef"
+      line3 = line.merge line2
+      expect(line3.count).to eq(1)
+
+      line = GCOVTOOLS::Line.new 3,1, "abcdef"
+      line2 = GCOVTOOLS::Line.new 3,:missed, "abcdef"
+      line3 = line.merge line2
+      expect(line3.count).to eq(1)
+    end
+
+    it "should give missed (0) presedence over none" do
+      line = GCOVTOOLS::Line.new 3,:missed, "abcdef"
+      line2 = GCOVTOOLS::Line.new 3,:none, "abcdef"
+      line3 = line.merge line2
+      expect(line3.count).to eq(:missed)
+    end
+
+  end # describe #merge
+
+end