deep-cover 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66af2fb754f224d5044bc6455e2b0995c6028e3a
-  data.tar.gz: eb4865a25287780cbb75730bc093f76cae690a74
+  metadata.gz: fe152ffb51fdfa686a1448c858bc1ea0d763a7df
+  data.tar.gz: a0e0a3ac5ff89b20747943b8819937593def90d4
 SHA512:
-  metadata.gz: 6067f222058c3606c912d24b7eb991c29460a70fe29a6e1dba82277d54cbefb95ef46996074195732aa69e9ae7d1e7a49ebffe22e7038c68882559b34a257103
-  data.tar.gz: 1de08e4f2dd112e79b6b60196d398b5b79e057b3a54b0c8baca9123bdc50307df65a49eee97235230c96152e78be1dec128c4890b7e4c3444427dc0c7ea480b7
+  metadata.gz: c6bfeb927e5f9e667b4623339cf01336c2071e0a38b6222176a87130f429a29e6ece18702a3516021df7ba8c51a454db179e8abea99e5d807627ded57e992183
+  data.tar.gz: 38744bd15d4a21d3d88c436483f7d3a4cb2e66ddac0590439c788853a6c30444483af6f2b6e247c573029e4b57ef88f13a4a29b9f6a730e4ee8629a06bd9eb2f

data/.travis.yml

@@ -10,3 +10,6 @@ rvm:
 before_install:
   - gem install bundler -v 1.15.4
   - npm install -g nyc
+matrix:
+  allow_failures:
+  - rvm: jruby-9.1.9.0

data/CONTRIBUTING.md

@@ -0,0 +1,59 @@
+# Running the tests
+
+## Dev installation
+
+For the moment, you need `nyc`, so you must have `node` (and ideally `yarn`) installed.
+
+```
+$ git clone https://github.com/deep-cover/deep-cover.git
+$ cd deep-cover
+$ bundle
+$ yarn install -g nyc  # or use npm
+```
+
+## rspec
+
+To run the full test suite:
+```
+$ rspec
+```
+
+There's currently a bunch of output we'd like to get rid of, sorry.
+
+You should get no failures.
+
+## Char coverage specs
+
+Much of the specs is in `spec/char_cover/*.rb`. Each file is a collection of tests, each separated with comments starting with `###` and `####`. Ruby code should be indented with 4 spaces. Each line can be followed by a spec comment, stating for each character if it is executed (space), not executed (x) or not executable (-). Lines that have any non-executed parts must have a spec comment otherwise they won't pass.
+
+To run a particular file, say `spec/char_cover/literals.rb`, use `rspec -e literals`.
+
+Note that `RuntimeError`s without any message (`raise`) are silently rescued for each test case. Other exceptions must be rescued in the spec.
+
+To debug a particular case: `bin/cov literals` (will ask which sub spec to run), or `bin/cov literals 3` (to run the 3rd sub spec).
+
+# Implementation notes
+
+## Top level strategy
+
+DeepCover is based on the awesome `parser` gem.
+
+We use the parsed code to rewrite it such that we can deduce what has been executed or not. We insert trackers looking like `$_some_global[42][555] += 1` where 42 is a number unique to the file and 555 is the id of the tracker.
+
+Our rewriting rules:
+* only insert code, never change existing code
+* keep the existing code on their original line
+* are minimal. They don't call any method, rescue exceptions, etc.
+* use the mimimal number of trackers (except for multiple assignments, we use one extra)
+
+### Flow accounting
+
+The goal is to instrument any Ruby code such that we can know, for each node, how many time it’s been executed (`Node#execution_count`). More precisely, for any node, we need to know how many times control flow has "entered" the node (`Node#flow_entry_count`), how many times it has exited the node normally (`Node#flow_completion_count`), and by deduction how many times control flow has been interrupted (say by a raise, throw, return, next, etc. `Node#flow_interrupt_count`).
+
+We always deduce their execution from normal control flow. E.g. in `var = [1, 2, 3]`, to know if `3` was executed, we check if it's previous sibbling (`2`) was executed. To know that, we check if `1` was executed. `1` has no previous sibbling, so we check the parent `[]`. It itself checks the parent `var =`, which finally asks bring us to our parent (`Node::Root`). Only this parent introduces a small performance hit with a tracker ($_some_global[][] += 1`). So we get the execution count of the literals, the array creation and the variable assignment for free.
+
+To summarize our strategy: a Node is not responsible to know how many times it was entered by control flow, that is the responsibility of the parent node. A Node's responsibility is to know how many times control flow exited it normally. For many nodes like literals, `flow_completion_count == flow_entry_count` so there's nothing special to be done. Others must do some accounting, in particular `Node::Send` must add a `$tracker[][]+=1` after the call to know if flow has been interrupted or not. Credit to @MaxLap for pointing us in that direction early on.
+
+Default code for nodes in [flow_accounting.rb](https://github.com/deep-cover/deep-cover/blob/master/lib/deep_cover/node/mixin/flow_accounting.rb).
+
+*To be continued...*

data/README.md

@@ -102,12 +102,14 @@ After checking out the repo, run `bundle` to install dependencies. Then, run `ra
 
 For detailed analysis:
 
-`deep-cover -e "if(:try_me); puts 'cool'; end"`
+`deep-cover -d -e "if(:try_me); puts 'cool'; end"`
 
 To run one of the specs in `spec`:
 
 `bin/cov boolean`
 
+More details in the [contributing guide](https://github.com/deep-cover/deep-cover/blob/master/CONTRIBUTING.md).
+
 ### Status
 
 Currently in heavy development. *Alpha stage, API subject to change every day*. Best time to get involved though ;-)

data/bin/test_gems

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require "deep_cover"
+
+def gem_list
+  return %w[erubis thor i18n builder tzinfo diff-lcs rack-test tilt multipart-post diff-lcs
+    rubygems-bundler method_source daemons hike multi_json rails-deprecated_sanitizer slop
+    rspec-support thread_safe rspec-core rspec-expectations rspec-mocks rspec mini_portile
+    multi_json rspec-support rspec-expectations rspec-mocks mail nokogiri rack rspec unf
+    json thread_safe rspec-core json rack-protection sdoc docile faraday multi_xml coderay
+    mime-types net-scp multi_json turbolinks formatador coffee-script rack-test]
+  # How I got those:
+  require 'gems'
+  Gems.most_downloaded
+  .map(&:first) # discard nb downloads
+  .map{|h| h['full_name']} # get name-0.1.2
+  .map{|n| n.rpartition('-').first } # => name
+end
+
+def install_gems
+  gem_list.each do |n|
+    system "gem install #{n}"
+  end
+end
+
+# install_gems
+
+def test_gems
+  gem_list.each do |n|
+    puts "Require #{n}"
+    begin
+      DeepCover.cover { require n }
+    rescue LoadError
+      puts "Not sure how to load '#{n}'. Skipping"
+    rescue Exception => ours
+      begin
+        require n
+      rescue Exception => normal
+        puts "Gem #{n} doesn't require normally. Skipping"
+      else
+        puts "DeepCover creates issue with Gem #{n}:\n#{ours}"
+      end
+    end
+  end
+end
+
+test_gems
+# module DeepCover
+
+#   # puts
+#   names = Gems.most_downloaded
+# end

data/deep_cover.gemspec

@@ -42,4 +42,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency 'activesupport', "~> 4.0"
+  spec.add_development_dependency "psych", ">= 2.0"
 end

data/lib/deep_cover/autoload_tracker.rb

@@ -33,14 +33,14 @@ module DeepCover
       begin
         pairs.each do |const, name|
           # Changing the autoload to an already loaded file (this one)
-          const.autoload_without_coverage(name, __FILE__)
+          const.autoload_without_deep_cover(name, __FILE__)
         end
 
         yield
       rescue Exception
         pairs.each do |const, name|
           # Changing the autoload to an already loaded file (this one)
-          const.autoload_without_coverage(name, absolute_path)
+          const.autoload_without_deep_cover(name, absolute_path)
         end
 
         raise

data/lib/deep_cover/base.rb

@@ -6,14 +6,18 @@ module DeepCover
         # No issues with autoload in jruby, so no need to override it!
       else
         require_relative 'core_ext/autoload_overrides'
+        AutoloadOverride.active = true
         autoload_tracker.initialize_autoloaded_paths
       end
       require_relative 'core_ext/require_overrides'
+      RequireOverride.active = true
       @started = true
     end
 
     def stop
-      # TODO
+      AutoloadOverride.active = false if defined? AutoloadOverride
+      RequireOverride.active = false
+      @started = false
     end
 
     def line_coverage(filename)

data/lib/deep_cover/core_ext/autoload_overrides.rb

@@ -12,29 +12,31 @@
 
 require 'binding_of_caller'
 
-class << Kernel
-  alias_method :autoload_without_coverage, :autoload
-  def autoload(name, path)
-    mod = binding.of_caller(1).eval('Module.nesting').first || Object
-    DeepCover.autoload_tracker.add(mod, name, path)
-    mod.autoload_without_coverage(name, path)
-  end
-end
+module DeepCover
+  module KernelAutoloadOverride
+    def autoload(name, path)
+      mod = binding.of_caller(1).eval('Module.nesting').first || Object
+      DeepCover.autoload_tracker.add(mod, name, path)
+      mod.autoload_without_deep_cover(name, path)
+    end
 
-module Kernel
-  alias_method :autoload_without_coverage, :autoload
-  def autoload(name, path)
-    mod = binding.of_caller(1).eval('Module.nesting').first || Object
-    DeepCover.autoload_tracker.add(mod, name, path)
-    mod.autoload_without_coverage(name, path)
+    extend ModuleOverride
+    override ::Kernel, ::Kernel.singleton_class
   end
-end
 
+  module ModuleAutoloadOverride
+    def autoload(name, path)
+      DeepCover.autoload_tracker.add(self, name, path)
+      autoload_without_deep_cover(name, path)
+    end
+
+    extend ModuleOverride
+    override Module
+  end
 
-class Module
-  alias_method :autoload_without_coverage, :autoload
-  def autoload(name, path)
-    DeepCover.autoload_tracker.add(self, name, path)
-    autoload_without_coverage(name, path)
+  module AutoloadOverride
+    def self.active=(flag)
+      KernelAutoloadOverride.active = ModuleAutoloadOverride.active = flag
+    end
   end
 end

data/lib/deep_cover/core_ext/load_overrides.rb

@@ -3,22 +3,20 @@
 # For now, this is not used, and may never be. The tracking and reporting for things can might be
 # loaded multiple times can be complex and is beyond the current scope of the project.
 
-class << Kernel
-  alias_method :load_without_coverage, :load
-  def load(path, wrap = false)
-    return load_without_coverage(path, wrap) if wrap
+module DeepCover
+  module LoadOverride
+    def load(path, wrap = false)
+      return load_without_deep_cover(path, wrap) if wrap
 
-    result = DeepCover.custom_requirer.load(path)
-    if [:not_found, :cover_failed, :not_supported].include?(result)
-      load_without_coverage(path)
-    else
-      result
+      result = DeepCover.custom_requirer.load(path)
+      if [:not_found, :cover_failed, :not_supported].include?(result)
+        load_without_deep_cover(path)
+      else
+        result
+      end
     end
   end
-end
 
-module Kernel
-  def load(path, wrap = false)
-    Kernel.require(path, wrap)
-  end
+  extend ModuleOverride
+  override ::Kernel, ::Kernel.singleton_class
 end

data/lib/deep_cover/core_ext/require_overrides.rb

@@ -4,42 +4,26 @@
 # each can have been already overwritten individually. (Rubygems only
 # overrides Kernel#require)
 
-class << Kernel
-  alias_method :require_without_coverage, :require
-  def require(path)
-    result = DeepCover.custom_requirer.require(path)
-    if [:not_found, :cover_failed, :not_supported].include?(result)
-      require_without_coverage(path)
-    else
-      result
+module DeepCover
+  module RequireOverride
+    def require(path)
+      result = DeepCover.custom_requirer.require(path)
+      if [:not_found, :cover_failed, :not_supported].include?(result)
+        require_without_deep_cover(path)
+      else
+        result
+      end
     end
-  end
-
-  def require_relative(path)
-    base = caller(1..1).first[/[^:]+/]
-    raise LoadError, "cannot infer basepath" unless base
-    base = File.dirname(base)
 
-    require(File.absolute_path(path, base))
-  end
-end
+    def require_relative(path)
+      base = caller(1..1).first[/[^:]+/]
+      raise LoadError, "cannot infer basepath" unless base
+      base = File.dirname(base)
 
-module Kernel
-  alias_method :require_without_coverage, :require
-  def require(path)
-    result = DeepCover.custom_requirer.require(path)
-    if [:not_found, :cover_failed, :not_supported].include?(result)
-      require_without_coverage(path)
-    else
-      result
+      require(File.absolute_path(path, base))
     end
-  end
-
-  def require_relative(path)
-    base = caller(1..1).first[/[^:]+/]
-    raise LoadError, "cannot infer basepath" unless base
-    base = File.dirname(base)
 
-    require(File.absolute_path(path, base))
+    extend ModuleOverride
+    override ::Kernel, ::Kernel.singleton_class
   end
 end

data/lib/deep_cover/covered_code.rb

@@ -10,11 +10,7 @@ module DeepCover
       raise "Must provide either path or source" unless path || source
 
       @buffer = ::Parser::Source::Buffer.new(path)
-      if source
-        @buffer.source = source
-      else
-        @buffer.read
-      end
+      @buffer.source = source ||= File.read(path)
       @lineno = lineno
       @tracker_count = 0
       @tracker_global = tracker_global

data/lib/deep_cover/custom_requirer.rb

@@ -82,10 +82,24 @@ module DeepCover
 
     protected
     def cover_and_execute(path)
-      covered_code = DeepCover.coverage.covered_code(path)
-      return :cover_failed unless covered_code
+      begin
+        covered_code = DeepCover.coverage.covered_code(path)
+      rescue Parser::SyntaxError => e
+        if e.message =~ /contains escape sequences incompatible with UTF-8/
+          warn "Can't cover #{path} because of incompatible encoding (see issue #9)"
+        else
+          warn "The file #{path} can't be instrumented"
+        end
+        return :cover_failed
+      end
       DeepCover.autoload_tracker.wrap_require(path) do
-        covered_code.execute_code
+        begin
+          covered_code.execute_code
+        rescue ::SyntaxError => e
+          warn "DeepCover is getting confused with the file #{path} and it won't be instrumented.\n" +
+               "Please report this error and provide the source code around the following:\n#{e}"
+          return :cover_failed
+        end
       end
       covered_code
     end

data/lib/deep_cover/module_override.rb

@@ -0,0 +1,30 @@
+module DeepCover
+  # Helps redefine methods in overriden_modules.
+  # For each methods in Mod, this defines `<method>_with{out}_deep_cover`.
+  # Set `active` to true or false to alias <method> to one or the other.
+  module ModuleOverride
+    attr_reader :overriden_modules
+
+    def active=(active)
+      each do |mod, method_name|
+        mod.send :alias_method, method_name, :"#{method_name}_#{active ? 'with' : 'without'}_deep_cover"
+      end
+    end
+
+    def override(*modules)
+      @overriden_modules = modules
+      each do |mod, method_name|
+        mod.send :alias_method, :"#{method_name}_without_deep_cover", method_name
+        mod.send :define_method, :"#{method_name}_with_deep_cover", instance_method(method_name)
+      end
+    end
+
+    def each(&block)
+      overriden_modules.each do |mod|
+        instance_methods(false).each do |method_name|
+          yield mod, method_name
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/node/case.rb

@@ -45,7 +45,13 @@ module DeepCover
       has_tracker :body_entry
       has_extra_children matches: { splat: WhenSplatCondition, Parser::AST::Node => WhenCondition }
       has_child body: Node,
-        can_be_empty: -> { base_node.loc.expression.succ },
+        can_be_empty: -> {
+          if (after_then = base_node.loc.begin)
+            after_then.end
+          else
+            base_node.loc.expression.succ
+          end
+        },
         rewrite: ";%{body_entry_tracker};%{local}=nil;%{node}",
         is_statement: true,
         flow_entry_count: :body_entry_tracker_hits

data/lib/deep_cover/version.rb

@@ -1,3 +1,3 @@
 module DeepCover
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deep-cover
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Marc-André Lafortune
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-03 00:00:00.000000000 Z
+date: 2017-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -179,6 +179,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: Write a longer description or delete this line.
 email:
 - github@marc-andre.ca
@@ -192,6 +206,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -201,6 +216,7 @@ files:
 - bin/gemcov
 - bin/selfcov
 - bin/setup
+- bin/test_gems
 - bin/testall
 - deep_cover.gemspec
 - exe/deep-cover
@@ -235,6 +251,7 @@ files:
 - lib/deep_cover/coverage.rb
 - lib/deep_cover/covered_code.rb
 - lib/deep_cover/custom_requirer.rb
+- lib/deep_cover/module_override.rb
 - lib/deep_cover/node.rb
 - lib/deep_cover/node/arguments.rb
 - lib/deep_cover/node/assignments.rb