deep-cover 0.1.16 → 0.2.0

data/lib/deep_cover/builtin_takeover.rb

@@ -2,3 +2,8 @@
 
 require_relative '../deep_cover'
 require_relative '../deep_cover/core_ext/coverage_replacement'
+
+require 'coverage'
+BuiltinCoverage = Coverage
+Object.send(:remove_const, 'Coverage')
+Coverage = DeepCover::CoverageReplacement.dup

data/lib/deep_cover/cli/deep_cover.rb

@@ -40,11 +40,12 @@ module DeepCover
           o.separator ''
           o.string '-o', '--output', 'output folder', default: './coverage'
           o.string '-c', '--command', 'command to run tests', default: 'bundle exec rake'
+          o.string '--reporter', 'reporter', default: 'html'
           o.bool '--bundle', 'run bundle before the tests', default: true
           o.bool '--process', 'turn off to only redo the reporting', default: true
           o.bool '--open', 'open the output coverage', default: false
           o.separator 'Coverage options'
-          @ignore_uncovered_map = Analyser.optionally_covered.map do |option|
+          @ignore_uncovered_map = Analyser::Node.optionally_covered.map do |option|
             default = Config::DEFAULTS[:ignore_uncovered].include?(option)
             o.bool "--ignore-#{Tools.dasherize(option)}", '', default: default
             [:"ignore_#{option}", option]

data/lib/deep_cover/cli/instrumented_clone_reporter.rb

@@ -106,23 +106,25 @@ module DeepCover
 
       def patch_gemfile
         gemfile = @dest_root.join('Gemfile')
+        deps = Bundler::Definition.build(gemfile, nil, nil).dependencies
+
+        return if deps.find { |e| e.name == 'deep-cover' }
+
         content = File.read(gemfile)
-        unless content =~ /gem 'deep-cover'/
-          puts "Patching Gemfile #{gemfile}"
-          File.write(gemfile, [
-                                '# This file was modified by DeepCover',
-                                content,
-                                "gem 'deep-cover', path: '#{File.expand_path(__dir__ + '/../../../')}'",
-                                '',
-                              ].join("\n"))
-        end
+        puts "Patching Gemfile #{gemfile}"
+        File.write(gemfile, [
+                              '# This file was modified by DeepCover',
+                              content,
+                              "gem 'deep-cover', path: '#{File.expand_path(__dir__ + '/../../../')}'",
+                              '',
+                            ].join("\n"))
       end
 
       def patch_rubocop
         path = @dest_root.join('.rubocop.yml')
         return unless path.exist?
         puts 'Patching .rubocop.yml'
-        config = YAML.safe_load(path.read.gsub(/(?<!\w)lib(?!\w)/, 'lib_original'))
+        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

data/lib/deep_cover/config.rb

@@ -14,38 +14,52 @@ module DeepCover
     end
 
     def to_hash
-      copy(@options)
+      @options.dup
     end
     alias_method :to_h, :to_hash
 
     def ignore_uncovered(*keywords)
-      check_uncovered(keywords)
-      change(:ignore_uncovered, @options[:ignore_uncovered] | keywords)
+      if keywords.empty?
+        @options[:ignore_uncovered]
+      else
+        check_uncovered(keywords)
+        change(:ignore_uncovered, @options[:ignore_uncovered] | keywords)
+      end
     end
 
     def detect_uncovered(*keywords)
-      check_uncovered(keywords)
-      change(:ignore_uncovered, @options[:ignore_uncovered] - keywords)
+      if keywords.empty?
+        Analyser::Node.optionally_covered - @options[:ignore_uncovered]
+      else
+        check_uncovered(keywords)
+        change(:ignore_uncovered, @options[:ignore_uncovered] - keywords)
+      end
     end
 
     def paths(paths = nil)
       if paths
-        change(:paths, Array(paths).dup.freeze)
+        change(:paths, Array(paths).dup)
       else
         @options[:paths]
       end
     end
 
+    def reset
+      DEFAULTS.each do |key, value|
+        change(key, value)
+      end
+    end
+
     private
 
     def check_uncovered(keywords)
-      unknown = keywords - Analyser.optionally_covered
+      unknown = keywords - Analyser::Node.optionally_covered
       raise ArgumentError, "unknown options: #{unknown.join(', ')}" unless unknown.empty?
     end
 
     def change(option, value)
       if @options[option] != value
-        @options[option] = value
+        @options[option] = value.freeze
         @notify.config_changed(option) if @notify.respond_to? :config_changed
       end
       self

data/lib/deep_cover/core_ext/coverage_replacement.rb

@@ -2,27 +2,31 @@
 
 # This is a complete replacement for the builtin Coverage module of Ruby
 
-require 'coverage'
-BuiltinCoverage = Coverage
-Object.send(:remove_const, 'Coverage')
+module DeepCover
+  module CoverageReplacement
+    class << self
+      def running?
+        DeepCover.running?
+      end
 
-module Coverage
-  def self.start
-    @started = true
-    DeepCover.start
-    DeepCover.coverage.reset
-  end
+      def start
+        return if running?
+        DeepCover.start
+        nil
+      end
 
-  def self.result
-    raise 'coverage measurement is not enabled' unless @started
-    @started = false
-    self.peek
-  end
+      def result
+        r = peek_result
+        DeepCover.stop
+        r
+      end
 
-  def self.peek
-    results = DeepCover.coverage.covered_codes.map do |filename, covered_code|
-      [filename, covered_code.line_coverage(allow_partial: false)]
+      def peek_result
+        raise 'coverage measurement is not enabled' unless running?
+        DeepCover.coverage.covered_codes.map do |covered_code|
+          [covered_code.path, covered_code.line_coverage(allow_partial: false)]
+        end.to_h
+      end
     end
-    Hash[results]
   end
 end

data/lib/deep_cover/coverage.rb

@@ -1,208 +1,8 @@
 # frozen_string_literal: true
 
 module DeepCover
-  require 'parser'
-  silence_warnings do
-    require 'parser/current'
-  end
   require_relative 'covered_code'
-  require 'securerandom'
-
-  # A collection of CoveredCode
-  class Coverage
-    include Enumerable
-
-    def initialize(**options)
-      @covered_codes = {}
-      @options = options
-    end
-
-    def covered_codes
-      @covered_codes.dup
-    end
-
-    def reset
-      @covered_codes = {}
-    end
-
-    def line_coverage(filename, **options)
-      covered_code(filename).line_coverage(**options)
-    end
-
-    def covered_code(path, **options)
-      raise 'path must be an absolute path' unless Pathname.new(path).absolute?
-      @covered_codes[path] ||= CoveredCode.new(path: path, **options, **@options)
-    end
-
-    def each
-      return to_enum unless block_given?
-      @covered_codes.each_value { |covered_code| yield covered_code }
-      self
-    end
-
-    def to_istanbul(**options)
-      map do |covered_code|
-        next {} unless covered_code.has_executed?
-        covered_code.to_istanbul(**options)
-      end.inject(:merge)
-    end
-
-    def output_istanbul(dir: '.', name: '.nyc_output', **options)
-      path = Pathname.new(dir).expand_path.join(name)
-      path.mkpath
-      path.each_child(&:delete)
-      path.join('deep_cover.json').write(JSON.pretty_generate(to_istanbul(**options)))
-      path
-    end
-
-    def report_istanbul(output: nil, **options)
-      dir = output_istanbul(**options).dirname
-      unless [nil, '', 'false'].include? output
-        output = File.expand_path(output)
-        html = "--reporter=html --report-dir='#{output}'"
-        if options[:open]
-          html += " && open '#{output}/index.html'"
-        else
-          msg = "\nHTML coverage written to: '#{output}/index.html'"
-        end
-      end
-      `cd #{dir} && nyc report --reporter=text #{html}` + msg.to_s
-    end
-
-    def basic_report
-      missing = map do |covered_code|
-        if covered_code.has_executed?
-          missed = covered_code.line_coverage.each_with_index.map do |line_cov, line_index|
-            line_index + 1 if line_cov == 0
-          end.compact
-        else
-          missed = ['all']
-        end
-        [covered_code.buffer.name, missed] unless missed.empty?
-      end.compact.to_h
-      missing.map do |path, lines|
-        "#{File.basename(path)}: #{lines.join(', ')}"
-      end.join("\n")
-    end
-
-    def report(**options)
-      if Reporter::Istanbul.available?
-        report_istanbul(**options)
-      else
-        warn 'nyc not available. Please install `nyc` using `yarn global add nyc` or `npm i nyc -g`'
-        basic_report
-      end
-    end
-
-    def self.load(dest_path, dirname = 'deep_cover', with_trackers: true)
-      Persistence.new(dest_path, dirname).load(with_trackers: with_trackers)
-    end
-
-    def self.saved?(dest_path, dirname = 'deep_cover')
-      Persistence.new(dest_path, dirname).saved?
-    end
-
-    def save(dest_path, dirname = 'deep_cover')
-      Persistence.new(dest_path, dirname).save(self)
-      self
-    end
-
-    def save_trackers(dest_path, dirname = 'deep_cover')
-      Persistence.new(dest_path, dirname).save_trackers(tracker_global)
-      self
-    end
-
-    def tracker_global
-      @options.fetch(:tracker_global, CoveredCode::DEFAULT_TRACKER_GLOBAL)
-    end
-
-    class Persistence
-      # rubocop:disable Security/MarshalLoad
-      BASENAME = 'coverage.dc'
-      TRACKER_TEMPLATE = 'trackers%{unique}.dct'
-
-      attr_reader :dir_path
-      def initialize(dest_path, dirname)
-        @dir_path = Pathname(dest_path).join(dirname).expand_path
-      end
-
-      def load(with_trackers: true)
-        saved?
-        load_trackers if with_trackers
-        load_coverage
-      end
-
-      def save(coverage)
-        create_if_needed
-        delete_trackers
-        save_coverage(coverage)
-      end
-
-      def save_trackers(global)
-        saved?
-        trackers = eval(global) # rubocop:disable Security/Eval
-        # Some testing involves more than one process, some of which don't run any of our covered code.
-        # Don't save anything if that's the case
-        return if trackers.nil?
-        basename = format(TRACKER_TEMPLATE, unique: SecureRandom.urlsafe_base64)
-        dir_path.join(basename).binwrite(Marshal.dump(
-                                             version: DeepCover::VERSION,
-                                             global: global,
-                                             trackers: trackers,
-        ))
-      end
-
-      def saved?
-        raise "Can't find folder '#{dir_path}'" unless dir_path.exist?
-        self
-      end
-
-      private
-
-      def create_if_needed
-        dir_path.mkpath
-      end
-
-      def save_coverage(coverage)
-        dir_path.join(BASENAME).binwrite(Marshal.dump(
-                                             version: DeepCover::VERSION,
-                                             coverage: coverage,
-        ))
-      end
-
-      def load_coverage
-        Marshal.load(dir_path.join(BASENAME).binread).tap do |version: raise, coverage: raise|
-          raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
-          return coverage
-        end
-      end
-
-      def load_trackers
-        tracker_files.each do |full_path|
-          Marshal.load(full_path.binread).tap do |version: raise, global: raise, trackers: raise|
-            raise "dump version mismatch: #{version}, currently #{DeepCover::VERSION}" unless version == DeepCover::VERSION
-            merge_trackers(eval("#{global} ||= {}"), trackers) # rubocop:disable Security/Eval
-          end
-        end
-      end
-
-      def merge_trackers(hash, to_merge)
-        hash.merge!(to_merge) do |_key, current, to_add|
-          unless current.empty? || current.size == to_add.size
-            warn "Merging trackers of different sizes: #{current.size} vs #{to_add.size}"
-          end
-          to_add.zip(current).map { |a, b| a + b }
-        end
-      end
-
-      def tracker_files
-        basename = format(TRACKER_TEMPLATE, unique: '*')
-        Pathname.glob(dir_path.join(basename))
-      end
-
-      def delete_trackers
-        tracker_files.each(&:delete)
-      end
-    end
-  end
+  Coverage = Class.new
+  require_relative_dir 'coverage'
+  Coverage.include Coverage::Istanbul
 end

data/lib/deep_cover/coverage/analysis.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Coverage::Analysis < Struct.new(:covered_codes, :options)
+    include Memoize
+    memoize :analyser_map, :stat_map
+
+    def analyser_map
+      covered_codes.map do |covered_code|
+        [covered_code, compute_analysers(covered_code)]
+      end.to_h
+    end
+
+    def stat_map
+      analyser_map.transform_values { |a| a.transform_values(&:stats) }
+    end
+
+    private
+
+    def compute_analysers(covered_code)
+      base = Analyser::Node.new(covered_code, **options)
+      {node: base}.merge!(
+          {
+            per_char: Analyser::PerChar,
+            branch: Analyser::Branch,
+          }.transform_values { |klass| klass.new(base, **options) }
+      )
+    end
+  end
+
+  class Coverage
+    def analysis(**options)
+      Analysis.new(covered_codes, options)
+    end
+  end
+end

data/lib/deep_cover/coverage/base.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DeepCover
+  # A collection of CoveredCode
+  class Coverage
+    include Enumerable
+
+    def initialize(**options)
+      @covered_code_index = {}
+      @options = options
+    end
+
+    def covered_codes
+      @covered_code_index.values
+    end
+
+    def reset
+      @covered_code_index = {}
+    end
+
+    def line_coverage(filename, **options)
+      covered_code(filename).line_coverage(**options)
+    end
+
+    def covered_code(path, **options)
+      raise 'path must be an absolute path' unless Pathname.new(path).absolute?
+      @covered_code_index[path] ||= CoveredCode.new(path: path, **options, **@options)
+    end
+
+    def each
+      return to_enum unless block_given?
+      @covered_code_index.each_value { |covered_code| yield covered_code }
+      self
+    end
+
+    def report(**options)
+      case (reporter = options.fetch(:reporter, :html).to_sym)
+      when :html
+        Reporter::HTML.report(self, **options)
+      when :istanbul
+        if Reporter::Istanbul.available?
+          report_istanbul(**options)
+        else
+          warn 'nyc not available. Please install `nyc` using `yarn global add nyc` or `npm i nyc -g`'
+        end
+      when :text
+        basic_report
+      else
+        raise ArgumentError, "Unknown reporter: #{reporter}"
+      end
+    end
+
+    def basic_report
+      missing = map do |covered_code|
+        if covered_code.has_executed?
+          missed = covered_code.line_coverage.each_with_index.map do |line_cov, line_index|
+            line_index + 1 if line_cov == 0
+          end.compact
+        else
+          missed = ['all']
+        end
+        [covered_code.buffer.name, missed] unless missed.empty?
+      end.compact.to_h
+      missing.map do |path, lines|
+        "#{File.basename(path)}: #{lines.join(', ')}"
+      end.join("\n")
+    end
+
+    def self.load(dest_path, dirname = 'deep_cover', with_trackers: true)
+      Persistence.new(dest_path, dirname).load(with_trackers: with_trackers)
+    end
+
+    def self.saved?(dest_path, dirname = 'deep_cover')
+      Persistence.new(dest_path, dirname).saved?
+    end
+
+    def save(dest_path, dirname = 'deep_cover')
+      Persistence.new(dest_path, dirname).save(self)
+      self
+    end
+
+    def save_trackers(dest_path, dirname = 'deep_cover')
+      Persistence.new(dest_path, dirname).save_trackers(tracker_global)
+      self
+    end
+
+    def tracker_global
+      @options.fetch(:tracker_global, CoveredCode::DEFAULT_TRACKER_GLOBAL)
+    end
+  end
+end