deep-cover 0.1.16 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e164c802351be75ed8094fb9fe6d2a93d2928ccc
-  data.tar.gz: 5ec49dbb3275309c8585dc2ae919c75ac36b4cfb
+  metadata.gz: de76a03a06ec4a16d33c5a24a9c510678f83b33a
+  data.tar.gz: db775778d2b7d2c65ce0c299f3ff4f3900796e02
 SHA512:
-  metadata.gz: f38996b4c6804ea7f56e7ae31254ef741607684b48bcecb22bfc37d42a68a8ebc7f2e635e14f2d7ab77b42c6eed959f4eac6419d0e37841bd1d66fc3f9442a88
-  data.tar.gz: 06fa0ffb32772c5c6303acee40999336920f743ee9eef3202bd66006de5e1dc46077666f41dce453e97b563ec9fa46a47e27d36595c1df5028df643a01bb5b08
+  metadata.gz: 246c598d3da7d0fca5d5c4e453dc134f2e36cc59e7529f4148fa159c8e31c3288316e731faec5d08be37167fdd605454f0155b12cea3fdcbd22235f3e9ad9df3
+  data.tar.gz: 96fea731d9cd93158718857999a9da092b9ec619126dc0814b339b8e3c460a224dca594194b35d686b8dbf5c5c4cde03de69bd17a1bcd482e92ab1851bbb4ee7

data/.gitignore

@@ -8,6 +8,8 @@
 /spec/reports/
 /tmp/
 /.idea
+/.sass-cache
 
 # rspec failure tracking
 .rspec_status
+/Gemfile.local

data/.rubocop.yml

@@ -103,14 +103,6 @@ Naming/FileName:
 Style/FrozenStringLiteralComment:
   EnforcedStyle: always
 
-Style/InverseMethods:
-  InverseMethods:
-    :present?: :blank?,
-    :include?: :exclude?
-  Exclude:
-    - bin/*
-    - gemfiles/*
-
 Style/NegatedIf:
   Enabled: false
 
@@ -225,3 +217,6 @@ Style/Lambda:
 
 Style/StructInheritance:
   Enabled: false
+
+Security/YAMLLoad:
+  Enabled: false

data/.travis.yml

@@ -11,9 +11,9 @@ before_install:
   - gem install bundler -v 1.15.4
   - npm install -g nyc
 before_script:
-  - rake dev:install
+  - bundle exec rake dev:install
 script:
   - rake test:all
-# matrix:
-#   allow_failures:
-#   - rvm: jruby-9.1.9.0
+matrix:
+  allow_failures:
+  - rvm: jruby-9.1.9.0

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.2
+
+* HTML reporter
+* Improved analyser
+
+## 0.1
+
+* Initial "proof of concept" release

data/Gemfile

@@ -7,5 +7,7 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in deep_cover.gemspec
 gemspec
 
-gem 'pry-byebug', platforms: :mri
+eval_gemfile 'Gemfile.local' if File.exist?('Gemfile.local')
+
+gem 'parser', git: 'https://github.com/marcandre/parser.git', branch: 'tree_rewriter_release'
 gem 'ruby-prof', platforms: :mri

data/README.md

@@ -34,13 +34,16 @@ def test_foo
 end
 ```
 
-## Installation
+## Examples
 
-    gem install deep-cover
+These examples are direct outputs from our HTML reporter:
+
+* [Rails' `activesupport`](https://deep-cover.github.io/rails-cover/activesupport/)
+* [Rails' `activerecord`](https://deep-cover.github.io/rails-cover/activerecord/)
 
-DeepCover currently uses [`Istanbul`](https://istanbul.js.org/)'s reporter, so you'll need `node` and Istanbul's command line `nyc`:
+## Installation
 
-    yarn global add nyc   # or npm install nyc -g
+    gem install deep-cover
 
 ### Command line interface (for a Rails app or a Gem):
 
@@ -50,6 +53,8 @@ An easy way to check coverage, without any configuration needed:
 
 This assumes your project has a `Gemfile`, and that your default `rake` task is set to execute all tests (otherwise set the `--command` option)
 
+It also uses our builtin HTML reporter. Check the produced `coverage/index.html`.
+
 ### Builtin Coverage (including SimpleCov) users
 
 Add to your Gemfile `gem 'deep-cover'`, then run `bundle`.

data/Rakefile

@@ -26,12 +26,15 @@ namespace :dev do
       commands << 'bundle install --gemfile=spec/full_usage/rails51_project/Gemfile'
     end
     commands << 'bundle install --gemfile=spec/cli_fixtures/simple_rails42_app/Gemfile'
+    commands << 'bundle install --gemfile=spec/cli_fixtures/rails_like_gem/Gemfile'
 
     commands.each do |command|
       puts "Running: #{command}"
-      unless system(command)
-        puts "Failed to run `#{command}`, see above for details. When it is fixed, try running this rake task again."
-        exit(1)
+      Bundler.with_clean_env do
+        unless system(command)
+          puts "Failed to run `#{command}`, see above for details. When it is fixed, try running this rake task again."
+          exit(1)
+        end
       end
       puts "Command succeeded: #{command}"
     end

data/deep_cover.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = 'In depth coverage of your Ruby code.'
   spec.description   = 'expression and branch coverage for Ruby.'
-  spec.homepage      = 'http://github.com'
+  spec.homepage      = 'https://github.com/deep-cover/deep-cover'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -45,7 +45,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'activesupport', '~> 4.0'
   spec.add_development_dependency 'bundler', '~> 1.15'
   spec.add_development_dependency 'psych', '>= 2.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop'
 end

data/lib/deep_cover.rb

@@ -2,12 +2,22 @@
 
 # rubocop:disable Style/MixinUsage (See https://github.com/bbatsov/rubocop/issues/5055)
 module DeepCover
+  # External dependencies (ex parser)
   require 'parser'
   require 'term/ansicolor'
   require 'pry'
+
+  # Bootstrapping
   require_relative 'deep_cover/backports'
   require_relative 'deep_cover/tools'
+
+  # Parser
+  silence_warnings do
+    require 'parser/current'
+  end
   require_relative_dir 'deep_cover/parser_ext'
+
+  # Main
   require_relative_dir 'deep_cover', except: %w[auto_run builtin_takeover]
 
   extend Base

data/lib/deep_cover/analyser.rb

@@ -20,6 +20,5 @@ module DeepCover
 
   require_relative_dir 'analyser'
 
-  Analyser.include Analyser::IgnoreUncovered, Analyser::Base
-  Analyser.extend Analyser::OptionallyCovered
+  Analyser.include Analyser::Base
 end

data/lib/deep_cover/analyser/base.rb

@@ -2,6 +2,8 @@
 
 module DeepCover
   module Analyser::Base
+    include Tools::Covered
+
     attr_reader :source, :options
 
     def initialize(source, **options)
@@ -19,6 +21,10 @@ module DeepCover
       @source.node_runs(node)
     end
 
+    def node_covered?(node)
+      covered?(node_runs(node))
+    end
+
     def node_runs_map
       each_node.map do |node|
         [node, node_runs(node)]
@@ -30,6 +36,32 @@ module DeepCover
       node_runs_map
     end
 
+    def node_stat_type(node)
+      return :not_executable unless node.executable?
+      case node_runs(node)
+      when nil
+        :ignored
+      when 0
+        :not_executed
+      else
+        :executed
+      end
+    end
+
+    def node_stat_contributions(nodes)
+      if respond_to? :node_stat_contribution
+        nodes.sum { |n| node_stat_contribution(n) }
+      else
+        nodes.size
+      end
+    end
+
+    def stats
+      st = each_node.group_by { |n| node_stat_type(n) }
+                    .transform_values { |nodes| node_stat_contributions(nodes) }
+      Analyser::Stats.new(**st)
+    end
+
     # Iterates on nodes in the subset.
     # Yields the node and it's children (within the subset)
     def each_node(from = covered_code.root, &block)

data/lib/deep_cover/analyser/branch.rb

@@ -4,19 +4,34 @@ require_relative 'subset'
 
 module DeepCover
   class Analyser::Branch < Analyser
+    def self.human_name
+      'Branches'
+    end
     include Analyser::Subset
     SUBSET_CLASSES = [Node::Branch].freeze
 
+    def node_runs(node)
+      runs = super
+      if node.is_a?(Node::Branch) && covered?(runs)
+        worst = worst_branch_runs(node)
+        runs = worst unless covered?(worst)
+      end
+      runs
+    end
+
     def results
       each_node.map do |node|
-        branches_runs = node.branches.map { |b| [b, node_runs(b)] }.to_h
+        branches_runs = node.branches.map { |jump| [jump, source.node_runs(jump)] }.to_h
         [node, branches_runs]
       end.to_h
     end
 
-    def is_trivial_if?(node)
-      parent = node.parent
-      parent.is_a?(Node::If) && parent.condition.is_a?(Node::SingletonLiteral)
+    private
+
+    def worst_branch_runs(fork)
+      fork.branches.map { |jump| source.node_runs(jump) }
+          .sort_by { |runs| runs == 0 ? -2 : runs || -1 }
+          .first
     end
   end
 end

data/lib/deep_cover/analyser/node.rb

@@ -2,6 +2,26 @@
 
 module DeepCover
   class Analyser::Node < Analyser
+    include Analyser::Subset
+
+    def self.human_name
+      'Nodes'
+    end
+
+    def initialize(source, ignore_uncovered: [], **options)
+      @cache = {}.compare_by_identity
+      super
+      @allow_filters = Array(ignore_uncovered).map { |kind| method(:"is_#{kind}?") }
+    end
+
+    def node_runs(node)
+      @cache.fetch(node) do
+        runs = super
+        runs = nil if runs == 0 && should_be_ignored?(node)
+        @cache[node] = runs
+      end
+    end
+
     def is_raise?(node)
       node.is_a?(Node::Send) && (node.message == :raise || node.message == :exit)
     end
@@ -15,10 +35,42 @@ module DeepCover
       node.is_a?(Node::EmptyBody) && parent.is_a?(Node::Case) && !parent.has_else?
     end
 
+    def in_subset?(node, _parent)
+      node.executable?
+    end
+
+    def is_trivial_if?(node)
+      # Supports only node being a branch or the fork itself
+      node.parent.is_a?(Node::If) && node.parent.condition.is_a?(Node::SingletonLiteral)
+    end
+
+    def self.optionally_covered
+      @optionally_covered ||= instance_methods(false).map do |method|
+        method =~ /^is_(.*)\?$/
+        Regexp.last_match(1)
+      end.compact.map(&:to_sym).freeze
+    end
+
     protected
 
     def convert(node, **)
       Analyser::CoveredCodeSource.new(node)
     end
+
+    private
+
+    def should_be_ignored?(node)
+      @allow_filters.any? { |f| f[node] } || is_ignored?(node.parent)
+    end
+
+    def is_ignored?(node)
+      if node == nil
+        false
+      elsif node.executable?
+        node_runs(node).nil?
+      else
+        is_ignored?(node.parent)
+      end
+    end
   end
 end

data/lib/deep_cover/analyser/per_char.rb

@@ -2,10 +2,13 @@
 
 module DeepCover
   class Analyser::PerChar < Analyser
+    def self.human_name
+      'Chars'
+    end
+
     # Returns an array of characters for each line of code.
     # Each character is either ' ' (executed), '-' (not executable) or 'x' (not covered)
     def results
-      buffer = covered_code.buffer
       bc = buffer.source_lines.map { |line| '-' * line.size }
       each_node do |node|
         runs = node_runs(node)
@@ -17,5 +20,19 @@ module DeepCover
       bc.zip(buffer.source_lines) { |cov, line| cov[line.size..-1] = '' } # remove extraneous character for end lines, in any
       bc
     end
+
+    def node_stat_contribution(node)
+      node.executed_locs.sum(&:size)
+    end
+
+    def stats
+      s = super
+      actual_total = buffer.source.size
+      s.with not_executable: actual_total - s.total
+    end
+
+    def buffer
+      covered_code.buffer
+    end
   end
 end

data/lib/deep_cover/analyser/stats.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Analyser::StatsBase
+    DECIMALS = 2
+    include Memoize
+    memoize :to_h, :total
+
+    VALUES = %i[executed not_executed not_executable ignored].freeze # All are exclusive
+
+    attr_reader(*VALUES)
+
+    def to_h
+      VALUES.map { |val| [val, public_send(val)] }.to_h
+    end
+
+    def initialize(executed: 0, not_executed: 0, not_executable: 0, ignored: 0)
+      @executed = executed
+      @not_executed = not_executed
+      @not_executable = not_executable
+      @ignored = ignored
+      freeze
+    end
+
+    def +(other)
+      self.class.new(to_h.merge(other.to_h) { |k, a, b| a + b })
+    end
+
+    def total
+      to_h.values.inject(:+)
+    end
+
+    def with(**values)
+      self.class.new(to_h.merge(values))
+    end
+
+    def potentially_executable
+      total - not_executable
+    end
+
+    def percent_covered
+      return 100 if potentially_executable == 0
+      (100 * (1 - not_executed.fdiv(potentially_executable))).round(DECIMALS)
+    end
+  end
+
+  class Analyser::Stats < Analyser::StatsBase
+    memoize :percent
+
+    def percent
+      Analyser::StatsBase.new(to_h.transform_values { |v| (100 * v).fdiv(total).round(DECIMALS) })
+    end
+  end
+end

data/lib/deep_cover/backports.rb

@@ -18,3 +18,4 @@ require 'backports/2.1.0/enumerable/to_h'
 require 'backports/2.4.0/false_class/dup'
 require 'backports/2.4.0/true_class/dup'
 require 'backports/2.4.0/hash/transform_values'
+require 'backports/2.4.0/enumerable/sum'

data/lib/deep_cover/base.rb

@@ -2,6 +2,10 @@
 
 module DeepCover
   module Base
+    def running?
+      @started
+    end
+
     def start
       return if @started
       if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
@@ -30,11 +34,16 @@ module DeepCover
       coverage.covered_code(handle_relative_filename(filename))
     end
 
-    def cover
+    def cover(paths: nil)
+      if paths
+        prev = config.paths
+        config.paths(paths)
+      end
       start
       yield
     ensure
       stop
+      config.paths(prev) if paths
     end
 
     def config_changed(what)
@@ -44,6 +53,13 @@ module DeepCover
       end
     end
 
+    def reset
+      stop if @started
+      @coverage = @custom_requirer = @autoload_tracker = nil
+      config.reset
+      self
+    end
+
     def coverage
       @coverage ||= Coverage.new
     end