coverage-helpers 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8f770dd30dc496298673d765e63f2d8409396bae8abaf5dba9578a9f759a305
+  data.tar.gz: 782fb6b6d21f0fbfd9919c89929b15e369cccc7936d77f43cfb339519ebee8f9
+SHA512:
+  metadata.gz: 899b809986fe68cacfc819a86ac87fd3df1270cb8454ac4985d1156f8e7e3c6a8d9f40e415905dc5f7d558f1a42a892fc3ab76b444682a15f820230ce31d121d
+  data.tar.gz: 42c51e1457028b8fcf90de08117098d24157956918c7c335f2bc7e9ae62b1b1f8c81680dd1c8610e26761fa3dd192894844668ea4a7daeb8323963c05c42e155

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+coverage-helpers-1.0.0.gem

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    coverage-helpers (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  coverage-helpers!
+  minitest (~> 5.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Yusuke Endoh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# Coverage::Helpers
+
+This gem provides some helper methods to manipulate the coverage results measured by `Coverage.result` of the `coverage.so` library.
+
+## APIs
+
+Currently, the following methods are available:
+
+* `Coverage::Helpers.merge(*covs)`: Sum up all coverage results.
+* `Coverage::Helpers.diff(cov1, cov2)`: Extract the coverage results that is covered by `cov1` but not covered by `cov2`.
+* `Coverage::Helpers.sanitize(cov)`: Make the covearge result able to `Marshal#dump`.  (See the Notes section.)
+* `Coverage::Helpers.save(filename, cov)`: Save the coverage result to a file.
+* `Coverage::Helpers.load(filename)`:  Load the coverage result from a file.
+* `Coverage::Helpers.to_lcov_info(cov)`: Translate the result into LCOV info format.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'coverage-helpers'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install coverage-helpers
+
+## Usage
+
+Here is an example:
+
+```
+$ cd example
+$ ruby measure.rb -o cov1.dat -l cov1.info -- file.rb 1
+$ genhtml --branch-coverage cov1.info -o cov1-lcov
+$ open cov1-lcov/index.html
+```
+
+Note that `genhtml` is an executable of LCOV that visualizes LCOV info data by HTML view.
+
+You can merge the coverage results of multiple runs:
+
+```
+$ ruby measure.rb -o cov1.dat -l cov1.info -- file.rb 1
+$ ruby measure.rb -o cov2.dat -l cov2.info -a cov1.dat -- file.rb 2
+$ genhtml --branch-coverage cov2.info -o cov2-lcov
+$ open cov2-lcov/index.html
+```
+
+You can also check the newly covered code:
+
+```
+$ ruby measure.rb -o cov1.dat -l cov1.info -- file.rb 1
+$ ruby measure.rb -o cov2.dat -l cov2.info -b cov1.dat -- file.rb 2
+$ genhtml --branch-coverage cov2.info -o cov2-lcov
+$ open cov2-lcov/index.html
+```
+
+See `example/measure.rb` in detail.
+
+## Notes
+
+There are two formats of `Coverage.result`.  One is an old format, which Ruby 2.4 or before returns.  It can contain only line coverage.  The other is a new format, which Ruby 2.5 or later generates.  It can contain line, branch, and method covearge.  All methods of this gem support both format.
+
+Method coverage data contains a class defined a measured method.  The class may be a singleton class, which `Marshal.dump` cannot handle.  This is why this gem provides `sanitize`.  The method replaces all singleton classes with its string representation by using `to_s`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mame/coverage-helpers.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "coverage/helpers"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/coverage-helpers.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "coverage/helpers"
+
+Gem::Specification.new do |spec|
+  spec.name          = "coverage-helpers"
+  spec.version       = Coverage::Helpers::VERSION
+  spec.authors       = ["Yusuke Endoh"]
+  spec.email         = ["mame@ruby-lang.org"]
+
+  spec.summary       = %q{Helper methods for the Coverage library.}
+  spec.description   = %q{You can merge and diff coverage results, and convert them to LCOV info format.}
+  spec.homepage      = "https://github.com/mame/coverage-helpers"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/example/.gitignore

@@ -0,0 +1,3 @@
+*.dat
+*.info
+*-lcov/

data/example/file.rb

@@ -0,0 +1,22 @@
+def foo(n)
+  if n == 0
+    :zero
+  else
+    :non_zero
+  end
+end
+
+def bar
+  :bar
+end
+
+def baz
+  raise
+end
+
+case ARGV[0]
+when "1"
+  foo(0)
+when "2"
+  bar
+end

data/example/measure.rb

@@ -0,0 +1,42 @@
+require "coverage"
+require "coverage/helpers"
+require "optparse"
+
+# setup
+output_marshal = "cov.dat"
+output_lcov_info = "cov.info"
+add = nil
+base = nil
+o = OptionParser.new
+o.on("-o DAT", "output coverage data (in Marshal format)") {|v| output_marshal = v }
+o.on("-l LCOVINFO", "output coverage data (in LCOV info format)") {|v| output_lcov_info = v }
+o.on("-a DAT", "measure total covearge with this coverage") {|v| add = v }
+o.on("-b DAT", "measure diff from this coverage") {|v| base = v }
+o.parse!
+
+# measure
+Coverage.start(:all)
+load ARGV.shift
+cov = Coverage.result
+
+# merge
+if add
+  add = Coverage::Helpers.load(add)
+  cov = Coverage::Helpers.sanitize(cov)
+  cov = Coverage::Helpers.merge(cov, add)
+end
+
+# diff
+if base
+  base = Coverage::Helpers.load(base)
+  cov = Coverage::Helpers.sanitize(cov)
+  cov = Coverage::Helpers.diff(cov, base)
+end
+
+# save the result in Marshal format
+Coverage::Helpers.save(output_marshal, cov)
+
+# save the result in LCOV info format
+open(output_lcov_info, "w") do |f|
+  Coverage::Helpers.to_lcov_info(cov, out: f)
+end

data/lib/coverage/helpers.rb

@@ -0,0 +1,275 @@
+require "coverage"
+
+module Coverage
+  module Helpers
+    VERSION = "1.0.0"
+
+    # helper methods
+    using(Module.new { refine(Kernel) do
+      def old2new!(cov)
+        cov.each do |path, runs|
+          cov[path] = { :lines => runs }
+        end
+      end
+
+      def merge_lines(dst, src)
+        dst.concat([nil] * [src.size - dst.size, 0].max)
+        src.each_with_index do |run, i|
+          next unless run
+          dst[i] ||= 0
+          dst[i] += run
+        end
+      end
+
+      def merge_branches(dst, src)
+        src.each do |base, targets|
+          dst[base] ||= {}
+          targets.each do |target, run|
+            dst[base][target] ||= 0
+            dst[base][target] += run
+          end
+        end
+      end
+
+      def merge_methods(dst, src)
+        src.each do |mthd, run|
+          dst[mthd] ||= 0
+          dst[mthd] += run
+        end
+      end
+
+      def diff_lines(min, sub)
+        min += [nil] * [sub.size - min.size, 0].max
+        sub.each_with_index do |run, i|
+          next unless run
+          min[i] = [min[i] - run, 0].max if min[i]
+        end
+        min
+      end
+
+      def diff_branches(min, sub)
+        nruns = {}
+        min.each do |base, targets|
+          nruns[base] ||= {}
+          targets.each do |target, run|
+            run2 = sub.dig(base, target) || 0
+            nruns[base][target] = [run - run2, 0].max
+          end
+        end
+        nruns
+      end
+
+      def diff_methods(min, sub)
+        nruns = {}
+        min.each do |mthd, run|
+          run2 = sub[mthd] || 0
+          nruns[mthd] = [run - run2, 0].max
+        end
+        nruns
+      end
+    end })
+
+    module_function
+
+    # Sum up all coverage results.
+    def self.merge(*covs)
+      ncov = {}
+      old_format = true
+
+      covs.each do |cov|
+        cov.each do |path, runs|
+          if runs.is_a?(Array) && old_format
+            # merge two old-format (ruby 2.4 or before) coverage results
+            merge_lines(ncov[path] ||= [], runs)
+            next
+          end
+
+          # promotes from old format to new one
+          if runs.is_a?(Array)
+            runs = { :lines => runs }
+          end
+          if old_format
+            old_format = false
+            old2new!(ncov)
+          end
+
+          # merge two new-format (ruby 2.5 or later) coverage results
+          ncov[path] ||= {}
+          [
+            [:lines, :merge_lines, []],
+            [:branches, :merge_branches, {}],
+            [:methods, :merge_methods, {}],
+          ].each do |type, merge_func, default|
+            if runs[type]
+              send(merge_func, ncov[path][type] ||= default, runs[type])
+            end
+          end
+        end
+      end
+
+      ncov
+    end
+
+    # Extract the coverage results that is covered by `cov1` but not covered by `cov2`.
+    def diff(cov1, cov2)
+      ncov = {}
+      old_format = true
+
+      cov1.each do |path1, runs1|
+        if cov2[path1]
+          runs2 = cov2[path1]
+
+          if runs1.is_a?(Array) && runs2.is_a?(Array) && old_format
+            # diff two old-format (ruby 2.4 or before) coverage results
+            ncov[path1] = diff_lines(runs1, runs2)
+            next
+          end
+
+          # promotes from old format to new one
+          if runs1.is_a?(Array)
+            runs1 = { :lines => runs1 }
+          end
+          if runs2.is_a?(Array)
+            runs2 = { :lines => runs2 }
+          end
+          if old_format
+            old_format = false
+            old2new!(ncov)
+          end
+
+          # diff two new-format (ruby 2.5 or later) coverage results
+          ncov[path1] = {}
+          [
+            [:lines, :diff_lines],
+            [:branches, :diff_branches],
+            [:methods, :diff_methods],
+          ].each do |type, diff_func|
+            if runs1[type]
+              if runs2[type]
+                ncov[path1][type] = send(diff_func, runs1[type], runs2[type])
+              else
+                ncov[path1][type] = runs1[type]
+              end
+            end
+          end
+        else
+          if runs1.is_a?(Array) && old_format
+            ncov[path1] = runs1
+            next
+          end
+
+          # promotes from old format to new one
+          if runs1.is_a?(Array)
+            runs1 = { :lines => runs1 }
+          end
+          if old_format
+            old_format = false
+            old2new!(ncov)
+          end
+          ncov[path1] = runs1
+        end
+      end
+
+      ncov
+    end
+
+    # Make the covearge result able to marshal.
+    def sanitize(cov)
+      ncov = {}
+      cov.each do |path, runs|
+        if runs.is_a?(Array)
+          ncov[path] = runs
+          next
+        end
+
+        ncov[path] = {}
+        ncov[path][:lines] = runs[:lines] if runs[:lines]
+        ncov[path][:branches] = runs[:branches] if runs[:branches]
+
+        if runs[:methods]
+          ncov[path][:methods] = methods = {}
+          runs[:methods].each do |mthd, run|
+            klass =
+              begin
+                Marshal.dump(mthd[0])
+                mthd[0]
+              rescue
+                mthd[0].to_s
+              end
+            methods[[klass] + mthd.drop(1)] = run
+          end
+        end
+      end
+      ncov
+    end
+
+    # Save the coverage result to a file.
+    def save(path, cov)
+      File.binwrite(path, Marshal.dump(sanitize(cov)))
+    end
+
+    # Load the coverage result from a file.
+    def load(path)
+      Marshal.load(File.binread(path))
+    end
+
+    # Translate the result into LCOV info format.
+    def to_lcov_info(cov, out: "", test_name: nil)
+      out << "TN:#{ test_name }\n"
+      cov.each do |path, runs|
+        out << "SF:#{ path }\n"
+
+        # function coverage
+        if runs.is_a?(Hash) && runs[:methods]
+          total = covered = 0
+          runs[:methods].each do |(klass, name, lineno), run|
+            out << "FN:#{ lineno },#{ klass }##{ name }\n"
+            total += 1
+            covered += 1 if run > 0
+          end
+          out << "FNF:#{ total }\n"
+          out << "FNF:#{ covered }\n"
+          runs[:methods].each do |(klass, name, _), run|
+            out << "FNDA:#{ run },#{ klass }##{ name }\n"
+          end
+        end
+
+        # line coverage
+        if runs.is_a?(Array) || (runs.is_a?(Hash) && runs[:lines])
+          total = covered = 0
+          lines = runs.is_a?(Array) ? runs : runs[:lines]
+          lines.each_with_index do |run, lineno|
+            next unless run
+            out << "DA:#{ lineno + 1 },#{ run }\n"
+            total += 1
+            covered += 1 if run > 0
+          end
+          out << "LF:#{ total }\n"
+          out << "LH:#{ covered }\n"
+        end
+
+        # branch coverage
+        if runs.is_a?(Hash) && runs[:branches]
+          total = covered = 0
+          id = 0
+          runs[:branches].each do |(_base_type, _, base_lineno), targets|
+            i = 0
+            targets.each do |(_target_type, _target_lineno), run|
+              out << "BRDA:#{ base_lineno },#{ id },#{ i },#{ run }\n"
+              total += 1
+              covered += 1 if run > 0
+              i += 1
+            end
+            id += 1
+          end
+          out << "BRF:#{ total }\n"
+          out << "BRH:#{ covered }\n"
+        end
+
+        out << "end_of_record\n"
+      end
+
+      out
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: coverage-helpers
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yusuke Endoh
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: You can merge and diff coverage results, and convert them to LCOV info
+  format.
+email:
+- mame@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- coverage-helpers.gemspec
+- example/.gitignore
+- example/file.rb
+- example/measure.rb
+- lib/coverage/helpers.rb
+homepage: https://github.com/mame/coverage-helpers
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Helper methods for the Coverage library.
+test_files: []