deep-cover 0.1.1

data/deep_cover.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "deep_cover/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "deep-cover"
+  spec.version       = DeepCover::VERSION
+  spec.authors       = ["Marc-André Lafortune", "Maxime Lapointe"]
+  spec.email         = ["github@marc-andre.ca", "hunter_spawn@hotmail.com"]
+
+  spec.summary       = %q{Write a short summary, because Rubygems requires one.}
+  spec.description   = %q{Write a longer description or delete this line.}
+  spec.homepage      = "http://github.com"
+  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"]
+
+  ### Runtime dependencies
+  spec.add_runtime_dependency 'parser'
+  spec.add_runtime_dependency 'backports', '>= 3.10.1'
+  spec.add_runtime_dependency 'binding_of_caller'
+
+  # CLI
+  spec.add_runtime_dependency "term-ansicolor"
+  spec.add_runtime_dependency "highline"
+  spec.add_runtime_dependency "ruby-progressbar", '<1.9.0'
+  spec.add_runtime_dependency 'with_progress'
+  spec.add_runtime_dependency 'slop', '~> 4.0'
+
+  # While in 0.x
+  spec.add_runtime_dependency 'pry'
+
+  ### Dev dependencies
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'activesupport', "~> 4.0"
+end

data/exe/deep-cover

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'deep_cover/cli/deep_cover'
+
+DeepCover::CLI::DeepCover.go

data/future_read_me.md

@@ -0,0 +1,108 @@
+[![Build Status](https://travis-ci.org/deep-cover/deep-cover.svg?branch=master)](https://travis-ci.org/deep-cover/deep-cover)
+
+# DeepCover
+
+Deep Cover aims to be an improved replacement for the built-in Coverage library.
+
+It will report a more accurate picture of your code usage. In particular a line is considered covered if and only if it is entirely executed:
+
+    foo if false  # => This is considered covered by builtin coverage, even though `foo` might not even exist
+
+Optionally, branch coverage will detect if some branches are never taken. In the following example, `test_foo` only provides values for `x` that respond to `:to_s`, thus the implicit `else` is never tested (i.e. a value of `x` that does not respond to `:to_s`)
+
+  def foo(x)
+    x = x.to_s if x.respond_to? :to_s
+    # ...
+  end
+
+  def test_foo
+    assert_equal something, foo(42)
+    assert_equal something_else, foo(:hello)
+  end
+
+## Installation
+
+Add to your Gemfile:
+
+    gem 'deep-cover'
+
+Then run:
+
+    bundle
+
+### Builtin Coverage (including SimpleCov) users
+
+Before you require `coverage` or `simplecov`, do a `require 'deep-cover/takeover'`.
+
+For example, the `test/test_helper.rb` file for `simplecov` users will look like
+
+```
+require 'deep-cover/takeover'
+require 'simplecov'
+SimpleCov.start
+# rest of `test_helper.rb`
+```
+
+### Quick and dirty for Rails app or Gem:
+
+Assuming your default `rake` task is set to execute all tests, you can try:
+
+`deep-cover /path/to/rails/app/or/gem`
+
+## Usage
+
+### Configuration
+
+`configure` is used to specify how specific `DeepCover` should be and which files it should analyse. The following code reflects the default settings:
+
+```
+DeepCover.configure do
+  cover_paths %w[app lib]
+  require_all_expression_in_line
+  require_all_branches(false)
+  accept_uncovered_raise(false)
+  accept_uncovered_default_arguments(false)
+end
+```
+
+### Low level usage
+
+```
+# Setup
+require 'deep-cover'
+DeepCover.configure { require_all_branches }
+# Cover
+DeepCover.cover do
+  require 'my_file_to_cover'
+  require 'my_other_file_to_cover'
+end
+require 'this_file_wont_be_covered'
+tests.run()
+DeepCover.report
+```
+
+## Development
+
+After checking out the repo, run `bundle` to install dependencies. Then, run `rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+For detailed analysis:
+
+`deep-cover -e "some.ruby(:code).here"`
+
+To run one of the specs in `spec`:
+
+`deep-cover -t boolean`
+
+## Contributing
+
+Please ask questions on StackOverflow.com. Maintainers monitor the tag `deep-cover.rb`.
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/deep-cover/deep-cover. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the DeepCover project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/deep-cover/deep-cover/blob/master/CODE_OF_CONDUCT.md).

data/lib/deep-cover.rb

@@ -0,0 +1 @@
+require_relative 'deep_cover'

data/lib/deep_cover.rb

@@ -0,0 +1,11 @@
+module DeepCover
+  require 'parser'
+  require_relative 'deep_cover/backports'
+  require_relative 'deep_cover/tools'
+  require_relative_dir 'deep_cover/parser_ext'
+  require_relative_dir 'deep_cover', except: %w[auto_run builtin_takeover]
+
+  extend Base
+  extend Config::Setter
+end
+DeepCover::GLOBAL_BINDING = binding

data/lib/deep_cover/analyser.rb

@@ -0,0 +1,24 @@
+require_relative 'node'
+require_relative 'covered_code'
+
+module DeepCover
+  # An analyser works on a subset of the original Node AST.
+  # The Root node is always considered part of the subset.
+  # One can iterate this subset with `each_node`, or ask
+  # the analyser for information about a node's children
+  # (i.e. with respect to this subset), or runs for any node
+  # in this subset.
+
+  # An analyser can summarize information with `results`.
+  # While CoveredCodeSource is based on a CoveredCode, all
+  # other analysers are based on another source analyser.
+
+  class Analyser
+  end
+
+  require_relative_dir 'analyser'
+
+  Analyser.include Analyser::IgnoreUncovered, Analyser::Base
+  Node.include Analyser::CoveredCodeSource::NodeExtension
+  CoveredCode.include Analyser::CoveredCodeSource::CoveredCodeExtension
+end

data/lib/deep_cover/analyser/base.rb

@@ -0,0 +1,51 @@
+module DeepCover
+  module Analyser::Base
+    attr_reader :source, :options
+
+    def initialize(source, **options)
+      @source = source.to_analyser
+      @options = options
+    end
+
+    # Basic coercion mechanism
+    def to_analyser
+      self
+    end
+
+    # Looking exclusively at our subset of nodes, returns the node's direct descendants
+    def node_children(node)
+      @source.node_children(node)
+    end
+
+    # Returns the number of runs of the node (assumed to be in our subset)
+    def node_runs(node)
+      @source.node_runs(node)
+    end
+
+    def node_runs_map
+      each_node.map do |node, sub_statements|
+        [node, node_runs(node)]
+      end.to_h
+    end
+
+    # Analyser-specific output
+    def results
+      node_runs_map
+    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)
+      return to_enum(:each_node) unless block_given?
+      children = node_children(from)
+      yield from, children unless from.is_a?(Node::Root)
+      children.each do |child|
+        each_node(child, &block)
+      end
+    end
+
+    def covered_code
+      @source.covered_code
+    end
+  end
+end

data/lib/deep_cover/analyser/branch.rb

@@ -0,0 +1,20 @@
+require_relative 'subset'
+
+module DeepCover
+  class Analyser::Branch < Analyser
+    include Analyser::Subset
+    SUBSET_CLASSES = [Node::Branch]
+
+    def results
+      each_node.map do |node, _children|
+        branches_runs = node.branches.map{|b| [b, node_runs(b)]}.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)
+    end
+  end
+end

data/lib/deep_cover/analyser/covered_code_source.rb

@@ -0,0 +1,31 @@
+module DeepCover
+  class Analyser::CoveredCodeSource < Analyser
+    attr_reader :covered_code
+
+    def initialize(covered_code)
+      @covered_code = covered_code
+    end
+
+    # Looking exclusively at our subset of nodes, returns the node's direct descendants
+    def node_children(node)
+      node.children_nodes
+    end
+
+    # Returns the number of runs of the node (assumed to be in our subset)
+    def node_runs(node)
+      node.execution_count if node.executable?
+    end
+
+    module NodeExtension
+      def to_analyser
+        Analyser::CoveredCodeSource.new(covered_code)
+      end
+    end
+
+    module CoveredCodeExtension
+      def to_analyser
+        Analyser::CoveredCodeSource.new(self)
+      end
+    end
+  end
+end

data/lib/deep_cover/analyser/function.rb

@@ -0,0 +1,12 @@
+require_relative 'subset'
+
+module DeepCover
+  class Analyser::Function < Analyser
+    include Analyser::Subset
+    SUBSET_CLASSES = [Node::Block, Node::Defs, Node::Def]
+
+    def node_runs(node)
+      super(node.body)
+    end
+  end
+end

data/lib/deep_cover/analyser/ignore_uncovered.rb

@@ -0,0 +1,19 @@
+module DeepCover
+  module Analyser::IgnoreUncovered
+    def initialize(source, ignore_uncovered: [], **options)
+      super
+      @allow_filters = Array(ignore_uncovered)
+        .map{|kind| :"is_#{kind}?"}
+        .select{|name| respond_to?(name) }
+        .map{|name| method(name)}   # So was tempted to write `.map(&method(:method))`!
+    end
+
+    def node_runs(node)
+      runs = super
+      if runs == 0 && @allow_filters.any?{ |f| f[node] }
+        runs = nil
+      end
+      runs
+    end
+  end
+end

data/lib/deep_cover/analyser/node.rb

@@ -0,0 +1,11 @@
+module DeepCover
+  class Analyser::Node < Analyser
+    def is_raise?(node)
+      node.is_a?(Node::Send) && (node.method_name == :raise || node.method_name == :exit)
+    end
+
+    def is_default_argument?(node)
+      node.parent.is_a?(Node::Optarg)
+    end
+  end
+end

data/lib/deep_cover/analyser/per_char.rb

@@ -0,0 +1,20 @@
+module DeepCover
+  class Analyser::PerChar < Analyser
+    # 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, _children|
+        runs = node_runs(node)
+        if runs != nil
+          node.proper_range.each do |pos|
+            bc[buffer.line_for_position(pos)-1][buffer.column_for_position(pos)] = runs > 0 ? ' ' : 'x'
+          end
+        end
+      end
+      bc.zip(buffer.source_lines){|cov, line| cov[line.size..-1] = ''} # remove extraneous character for end lines, in any
+      bc
+    end
+  end
+end

data/lib/deep_cover/analyser/per_line.rb

@@ -0,0 +1,23 @@
+module DeepCover
+  class Analyser::PerLine < Analyser
+    # Returns an array of runs, one per line.
+    def results
+      disallow_partial = !options.fetch(:allow_partial, true)
+      line_hits = Array.new(covered_code.nb_lines)
+      each_node do |node, _children|
+        if (runs = node_runs(node))
+          node.executed_locs.each do |loc|
+            lineno = loc.line - 1
+            if disallow_partial
+              line_hits[lineno] = 0 if runs == 0
+              next if line_hits[lineno] == 0
+            end
+            line_hits[lineno] = [line_hits[lineno] || 0, runs].max
+          end
+        end
+      end
+
+      line_hits
+    end
+  end
+end

data/lib/deep_cover/analyser/statement.rb

@@ -0,0 +1,31 @@
+require_relative 'subset'
+
+module DeepCover
+  class Analyser::Statement < Analyser
+    include Analyser::Subset
+    # Returns a map of Range => runs
+    def results
+      each_node.map do |node, _sub_statements|
+        [node.expression, node_runs(node)]
+      end.to_h
+    end
+
+    private
+
+    def in_subset?(node, parent)
+      is_statement = node.is_statement
+      if node.expression.nil?
+        false
+      elsif is_statement != :if_incompatible
+        is_statement
+      else
+        !compatible_runs?(node_runs(parent), node_runs(node))
+      end
+    end
+
+    def compatible_runs?(expression_runs, sub_expression_runs)
+      sub_expression_runs.nil? ||
+        (sub_expression_runs == 0) == (expression_runs == 0)
+    end
+  end
+end

data/lib/deep_cover/analyser/subset.rb

@@ -0,0 +1,24 @@
+module DeepCover
+  # A module to create a subset from a criteria called `in_subset?`
+  # Including classes can refine it, or specify SUBSET_CLASSES
+  module Analyser::Subset
+    def node_children(node)
+      find_children(node)
+    end
+
+    private
+    def find_children(from, parent = from)
+      @source.node_children(from).flat_map do |node|
+        if in_subset?(node, parent)
+          [node]
+        else
+          find_children(node, parent)
+        end
+      end
+    end
+
+    def in_subset?(node, _parent)
+      self.class::SUBSET_CLASSES.any?{|klass| node.is_a?(klass)}
+    end
+  end
+end