deep-cover 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0bfde5bb75505e45c28d6e28a2cf89464a0c5ad
-  data.tar.gz: effb8e5d1322f994532f65406ad867e5f6b0c30c
+  metadata.gz: cbe670bee3fca431efa3a04244d724b26deb7ede
+  data.tar.gz: a8f57f090a6fb004bb0b328901885b84f00548ca
 SHA512:
-  metadata.gz: 267136d48b010079e4ddd88c35044757aa6eeafb8619e087b52669754e105ef66b7ecc34c6e5f4b3b53f0d94dc66190ea7a6f0f7c20add4a437511560621fd44
-  data.tar.gz: 70bb129eecdc023b306308076b722ccb07d6200fa38e0d305a00eb844d7ebb7bcbc2e7fb7f4c165793350a1880a9d285a077d5a3a3f0220f94b203c88ccbe1f7
+  metadata.gz: d7d097733ac9da1e9e482f9c56ad96533f18da22f90c60ed3c009fcc7f2f8c4db1a099d5fb0051682157cd9a0d322c546e060f6b17438609ab839901b19a9aa2
+  data.tar.gz: 6e0f37c3293bed959adba222707bc77b31c233cf02e62f65ecef70bdfb24b8acc600b9b1ceccaf818b7f094dcb450e35d2ef9ff4bc6dc96b58582a14e0389dfb

data/.rspec

@@ -1,2 +1,3 @@
 --color
+--exclude-pattern "spec/cli_fixtures/**/*.rb"
 --tag ~skip

data/.travis.yml

@@ -7,4 +7,6 @@ rvm:
   - 2.1.10
   - 2.0.0
   - jruby-9.1.9.0
-before_install: gem install bundler -v 1.15.4
+before_install:
+  - gem install bundler -v 1.15.4
+  - npm install -g nyc

data/Rakefile

@@ -1,6 +1,6 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:spec).tap{|task| task.pattern = "spec/*_spec.rb, spec/*/*_spec.rb"}
 
 task :default => :spec

data/bin/selfcov

@@ -9,7 +9,7 @@ end
 require "deep_cover"
 
 if covered_path.nil?
-  covered_path = DeepCover::Tools.dump_covered_code('./lib', '../covered_deep_cover')
+  covered_path = DeepCover::Tools.dump_covered_code_and_save('./lib', dest_path: '../covered_deep_cover')
   puts "Covered code generation done. Output in", covered_path
   exec 'bin/selfcov', covered_path
 else

data/deep_cover.gemspec

@@ -22,6 +22,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   ### Runtime dependencies
+  spec.required_ruby_version = ">= 2.0.0"
+
   spec.add_runtime_dependency 'parser'
   spec.add_runtime_dependency 'backports', '>= 3.10.1'
   spec.add_runtime_dependency 'binding_of_caller'
@@ -29,7 +31,6 @@ Gem::Specification.new do |spec|
   # 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'
 

data/lib/deep_cover/analyser.rb

@@ -19,6 +19,5 @@ module DeepCover
   require_relative_dir 'analyser'
 
   Analyser.include Analyser::IgnoreUncovered, Analyser::Base
-  Node.include Analyser::CoveredCodeSource::NodeExtension
-  CoveredCode.include Analyser::CoveredCodeSource::CoveredCodeExtension
+  Analyser.extend Analyser::OptionallyCovered
 end

data/lib/deep_cover/analyser/base.rb

@@ -3,15 +3,10 @@ module DeepCover
     attr_reader :source, :options
 
     def initialize(source, **options)
-      @source = source.to_analyser
+      @source = to_source(source, **options)
       @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)
@@ -47,5 +42,24 @@ module DeepCover
     def covered_code
       @source.covered_code
     end
+
+    protected
+
+    def convert(covered_code, **options)
+      Analyser::Node.new(covered_code, **options)
+    end
+
+    def to_source(source, **options)
+      case source
+      when Analyser
+        source
+      when CoveredCode
+        convert(source, **options)
+      when Node
+        convert(source.covered_code, **options)
+      else
+        raise ArgumentError, "expected Analyser, Node or CoveredCode, got #{source.class}"
+      end
+    end
   end
 end

data/lib/deep_cover/analyser/covered_code_source.rb

@@ -15,17 +15,5 @@ module DeepCover
     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/node.rb

@@ -1,11 +1,21 @@
 module DeepCover
   class Analyser::Node < Analyser
     def is_raise?(node)
-      node.is_a?(Node::Send) && (node.method_name == :raise || node.method_name == :exit)
+      node.is_a?(Node::Send) && (node.message == :raise || node.message == :exit)
     end
 
     def is_default_argument?(node)
       node.parent.is_a?(Node::Optarg)
     end
+
+    def is_case_implicit_else?(node)
+      parent = node.parent
+      node.is_a?(Node::EmptyBody) && parent.is_a?(Node::Case) && !parent.has_else?
+    end
+
+    protected
+    def convert(node, **)
+      Analyser::CoveredCodeSource.new(node)
+    end
   end
 end

data/lib/deep_cover/analyser/optionally_covered.rb

@@ -0,0 +1,14 @@
+module DeepCover
+  module Analyser::OptionallyCovered
+    def optionally_covered
+      @optionally_covered ||= Analyser
+        .constants.map{|c| Analyser.const_get(c)}
+        .select{|klass| klass < Analyser }
+        .flat_map do |klass|
+          klass.instance_methods(false).map {|m| m.match(/^is_(.*)\?$/); $1 }
+        end
+        .compact
+        .map(&:to_sym)
+    end
+  end
+end

data/lib/deep_cover/auto_run.rb

@@ -3,47 +3,51 @@ require 'pry'
 
 module DeepCover
   module AutoRun
-    extend self
+    class Runner
+      def initialize(covered_path)
+        @covered_path = covered_path
+      end
 
-    def detect
-      @covered_path = File.expand_path('./lib')
-      Coverage.saved? @covered_path
-    end
+      def run!
+        detect
+        load
+        after_tests { save }
+      end
 
-    def load
-      @coverage = Coverage.load(@covered_path)
-    end
+      private
+      def detect
+        Coverage.saved? @covered_path
+      end
 
-    def save
-      @coverage.save_trackers(@covered_path)
-    end
+      def load
+        @coverage = Coverage.load(@covered_path, with_trackers: false)
+      end
 
-    def after_tests
-      use_at_exit = true
-      if defined?(Minitest)
-        puts "Registering with Minitest"
-        use_at_exit = false
-        Minitest.after_run { yield }
+      def save
+        @coverage.save_trackers(@covered_path)
       end
-      if defined?(Rspec)
-        use_at_exit = false
-        puts "Registering with Rspec"
-        RSpec.configure do |config|
-          config.after(:suite) { yield }
+
+      def after_tests
+        use_at_exit = true
+        if defined?(Minitest)
+          use_at_exit = false
+          Minitest.after_run { yield }
+        end
+        if defined?(Rspec)
+          use_at_exit = false
+          RSpec.configure do |config|
+            config.after(:suite) { yield }
+          end
+        end
+        if use_at_exit
+          at_exit { yield }
         end
-      end
-      if use_at_exit
-        puts "Using at_exit"
-        at_exit { yield }
       end
     end
 
-    def run!
-      detect
-      load
-      after_tests { save }
+    def self.run!(covered_path)
+      Runner.new(covered_path).run! unless @already_setup
+      @already_setup = true
     end
-
-    run!
   end
 end

data/lib/deep_cover/backports.rb

@@ -2,6 +2,15 @@
 class Module
   public :prepend # Public in Ruby 2.1+.
 end
+require 'pathname'
+class Pathname
+  def write(*args)
+    File.write(to_path, *args)
+  end unless method_defined? :write
+  def binwrite(*args)
+    File.binwrite(to_path, *args)
+  end unless method_defined? :binwrite
+end
 require 'backports/2.1.0/module/include'
 require 'backports/2.1.0/enumerable/to_h'
 require 'backports/2.4.0/false_class/dup'

data/lib/deep_cover/base.rb

@@ -17,7 +17,7 @@ module DeepCover
     end
 
     def line_coverage(filename)
-      coverage.line_coverage(handle_relative_filename(filename), **@config)
+      coverage.line_coverage(handle_relative_filename(filename), **config)
     end
 
     def covered_code(filename)
@@ -51,5 +51,12 @@ module DeepCover
       filename += '.rb' unless filename =~ /\.rb$/
       filename
     end
+
+    def parser
+      Parser::CurrentRuby.new.tap do |parser|
+        parser.diagnostics.all_errors_are_fatal = true
+        parser.diagnostics.ignore_warnings      = true
+      end
+    end
   end
 end

data/lib/deep_cover/cli/debugger.rb

@@ -21,11 +21,13 @@ module DeepCover
         end
       end
 
-      def initialize(source, filename: '(source)', lineno: 1, pry: false)
+      attr_reader :options
+      def initialize(source, filename: '(source)', lineno: 1, pry: false, **options)
         @source = source
         @filename = filename
         @lineno = lineno
         @pry = pry
+        @options = options
       end
 
       def show
@@ -41,8 +43,8 @@ module DeepCover
         puts "Line Coverage: Builtin | DeepCover | DeepCover Strict:\n"
         begin
           builtin_line_coverage = builtin_coverage(@source, @filename, @lineno)
-          our_line_coverage = our_coverage(@source, @filename, @lineno)
-          our_strict_line_coverage = our_coverage(@source, @filename, @lineno, allow_partial: false)
+          our_line_coverage = our_coverage(@source, @filename, @lineno, **options)
+          our_strict_line_coverage = our_coverage(@source, @filename, @lineno, allow_partial: false, **options)
           lines = format(builtin_line_coverage, our_line_coverage, our_strict_line_coverage, source: @source)
           puts number_lines(lines, lineno: @lineno)
         rescue Exception => e
@@ -72,7 +74,7 @@ module DeepCover
       def show_char_coverage
         puts "\nChar coverage:\n"
 
-        puts format_char_cover(covered_code, show_whitespace: !!ENV['W'])
+        puts format_char_cover(covered_code, show_whitespace: !!ENV['W'], **options)
       end
 
       def pry

data/lib/deep_cover/cli/deep_cover.rb

@@ -13,16 +13,38 @@ module DeepCover
       end
 
       def show_help
-        puts options
+        puts menu
       end
 
-      def options
-        @options ||= Slop.parse do |o|
+      class Parser < Struct.new(:delegate)
+        def method_missing(method, *args, &block)
+          options = args.last
+          if options.is_a?(Hash) && options.has_key?(:default)
+            args[-2] += " [#{options[:default]}]"
+          end
+          delegate.public_send(method, *args, &block)
+        end
+      end
+
+      def parse
+        Slop.parse do |o|
+          yield Parser.new(o)
+        end
+      end
+
+      def menu
+        @menu ||= parse do |o|
           o.banner = "usage: deep-cover [options] [path/to/app/or/gem]"
           o.separator ''
           o.string '-o', '--output', 'output folder', default: './coverage'
           o.string '-c', '--command', 'command to run tests', default: 'rake'
-
+          o.bool '--bundle', 'run bundle before the tests', default: true
+          o.separator 'Coverage options'
+          @ignore_uncovered_map = Analyser.optionally_covered.map do |option|
+            default = Config::DEFAULTS[:ignore_uncovered].include?(option)
+            o.bool "--ignore-#{Tools.dasherize(option)}", "", default: default
+            [:"ignore_#{option}", option]
+          end.to_h
           o.separator ''
           o.separator 'For testing purposes:'
           o.string '-e', '--expression', 'test ruby expression instead of a covering a path'
@@ -35,10 +57,19 @@ module DeepCover
         end
       end
 
+      def convert_options(options)
+        iu = options[:ignore_uncovered] = []
+        @ignore_uncovered_map.each do |cli_option, option|
+          iu << option if options.delete(cli_option)
+        end
+        options
+      end
+
       def go
+        options = convert_options(menu.to_h)
         if options[:expression]
-          Debugger.new(options[:expression], pry: options[:debug]).show
-        elsif (path = options.arguments.first)
+          Debugger.new(options[:expression], pry: options[:debug], **options).show
+        elsif (path = menu.arguments.first)
           InstrumentedCloneReporter.new(path, **options).run
         else
           show_help

data/lib/deep_cover/cli/instrumented_clone_reporter.rb

@@ -5,24 +5,21 @@ module DeepCover
   module CLI
     class InstrumentedCloneReporter
       include Tools
-      attr_reader :dest_path
 
       def initialize(gem_path, command: 'rake', **options)
         @command = command
         @options = options
-        @root_path = File.expand_path(gem_path)
-        if File.exist?(File.join(@root_path, 'Gemfile'))
-          @gem_relative_path = '' # Typical case
-        else
+        @root_path = gem_path = Pathname.new(gem_path).expand_path
+        unless @root_path.join('Gemfile').exist?
           # E.g. rails/activesupport
-          @gem_relative_path = File.basename(@root_path)
-          @root_path = File.dirname(@root_path)
-          raise "Can't find Gemfile" unless File.exist?(File.join(@root_path, 'Gemfile'))
+          @root_path = @root_path.dirname
+          raise "Can't find Gemfile" unless @root_path.join('Gemfile').exist?
         end
-        @dest_root = File.expand_path('~/test_deep_cover')
-        @dest_root = Dir.mktmpdir("deep_cover_test") unless Dir.exist?(@dest_root)
+        @dest_root = Pathname('~/test_deep_cover').expand_path
+        @dest_root = Pathname.new(Dir.mktmpdir("deep_cover_test")) unless @dest_root.exist?
         `rm -rf #{@dest_root}/* #{@dest_root}/.*`
-        @dest_path = File.expand_path(File.join(@dest_root, @gem_relative_path))
+        gem_relative_path = gem_path.relative_path_from(@root_path)
+        @main_path = @dest_root.join(gem_relative_path)
       end
 
       def copy
@@ -32,24 +29,34 @@ module DeepCover
       def patch_ruby_file(ruby_file)
         content = File.read(ruby_file)
         # Insert our code after leading comments:
-        content.sub!(/^((#.*\n+)*)/, '\1require "deep_cover/auto_run";')
+        content.sub!(/^((#.*\n+)*)/, "#{$1}require 'deep_cover/auto_run';DeepCover::AutoRun.run! '#{@dest_root}';")
         File.write(ruby_file, content)
       end
 
+      def each_gem_path
+        return to_enum __method__ unless block_given?
+        if @main_path.join('lib').exist?
+          yield @main_path
+        else # Rails style
+          Pathname.glob(@main_path.join('*/lib')).each{|p| yield p.dirname}
+        end
+      end
+
       def patch_main_ruby_files
-        main = File.join(dest_path, 'lib/*.rb')
-        Dir.glob(main).each do |main|
-          puts "Patching #{main}"
-          patch_ruby_file(main)
+        each_gem_path do |dest_path|
+          main = dest_path.join('lib/*.rb')
+          Dir.glob(main).each do |main|
+            puts "Patching #{main}"
+            patch_ruby_file(main)
+          end
         end
       end
 
       def patch_gemfile
-        gemfile = File.expand_path(File.join(dest_path, 'Gemfile'))
-        gemfile = File.expand_path(File.join(dest_path, '..', 'Gemfile')) unless File.exist?(gemfile)
+        gemfile = @dest_root.join('Gemfile')
         content = File.read(gemfile)
         unless content =~ /gem 'deep-cover'/
-          puts "Patching Gemfile"
+          puts "Patching Gemfile #{gemfile}"
           File.write(gemfile, [
             "# This file was modified by DeepCover",
             content,
@@ -57,18 +64,15 @@ module DeepCover
             '',
           ].join("\n"))
         end
-        Bundler.with_clean_env do
-          `cd #{dest_path} && bundle`
-        end
       end
 
       def patch_rubocop
-        path = File.expand_path(File.join(dest_path, '.rubocop.yml'))
-        return unless File.exists?(path)
+        path = @dest_root.join('.rubocop.yml')
+        return unless path.exist?
         puts "Patching .rubocop.yml"
-        config = YAML.load(File.read(path).gsub(/(?<!\w)lib(?!\w)/, 'lib_original'))
-        ((config['AllCops'] ||= {})['Exclude'] ||= []) << 'lib/**/*'
-        File.write(path, "# This file was modified by DeepCover\n" + YAML.dump(config))
+        config = YAML.load(path.read.gsub(/(?<!\w)lib(?!\w)/, 'lib_original'))
+        ((config['AllCops'] ||= {})['Exclude'] ||= []) << 'lib/**/*' << 'app/**/*'
+        path.write("# This file was modified by DeepCover\n" + YAML.dump(config))
       end
 
       def patch
@@ -78,25 +82,39 @@ module DeepCover
       end
 
       def cover
-        `cp -R #{dest_path}/lib #{dest_path}/lib_original`
-        @covered_path = Tools.dump_covered_code(File.join(dest_path, 'lib_original'), File.join(dest_path, 'lib'))
+        coverage = Coverage.new
+        each_gem_path do |dest_path|
+          `cp -R #{dest_path}/lib #{dest_path}/lib_original`
+          Tools.dump_covered_code(File.join(dest_path, 'lib_original'),
+            coverage: coverage, root_path: @dest_root.to_s,
+            dest_path: File.join(dest_path, 'lib'))
+        end
+        coverage.save(@dest_root.to_s)
       end
 
       def process
         Bundler.with_clean_env do
-          system("cd #{dest_path} && #{@command}", out: $stdout, err: :out)
+          system("cd #{@main_path} && #{@command}")
         end
       end
 
       def report
-        coverage = Coverage.load @covered_path
-        puts coverage.report(dir: @covered_path, **@options)
+        coverage = Coverage.load @dest_root.to_s
+        puts coverage.report(dir: @dest_root.to_s, **@options)
+      end
+
+      def bundle
+        puts "Running `bundle install`"
+        Bundler.with_clean_env do
+          `cd #{@dest_root} && bundle`
+        end
       end
 
       def run
         copy
         cover
         patch
+        bundle if @options.fetch(:bundle, true)
         process
         report
       end