coverband 4.2.0 → 4.2.4

data/lib/coverband/integrations/{middleware.rb → background_middleware.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Coverband
-  class Middleware
+  class BackgroundMiddleware
     def initialize(app)
       @app = app
     end
@@ -10,11 +10,7 @@ module Coverband
       @app.call(env)
     ensure
       AtExit.register
-      if Coverband.configuration.background_reporting_enabled
-        Background.start
-      else
-        Collectors::Coverage.instance.report_coverage
-      end
+      Background.start if Coverband.configuration.background_reporting_enabled
     end
   end
 end

data/lib/coverband/integrations/bundler.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module BundlerEagerLoad
+  def require(*groups)
+    Coverband.eager_loading_coverage { super }
+  end
+end
+Bundler.singleton_class.prepend BundlerEagerLoad

data/lib/coverband/integrations/report_middleware.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Coverband
+  class ReportMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    ensure
+      Collectors::Coverage.instance.report_coverage
+    end
+  end
+end

data/lib/coverband/integrations/resque.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
-Resque.after_fork do |job|
+Resque.after_fork do |_job|
   Coverband.start
   Coverband.runtime_coverage!
-  # no reason to miss coverage on a first resque job
-  Coverband::Collectors::Delta.set_default_results
 end
 
 Resque.before_first_fork do
   Coverband.eager_loading_coverage!
   Coverband.configuration.background_reporting_enabled = false
   Coverband::Background.stop
-  Coverband::Collectors::Coverage.instance.report_coverage(true)
+  Coverband.report_coverage
 end
 
 module Coverband
@@ -19,7 +17,7 @@ module Coverband
     def perform
       super
     ensure
-      Coverband.report_coverage(true)
+      Coverband.report_coverage
     end
   end
 end

data/lib/coverband/reporters/base.rb

@@ -8,37 +8,61 @@ module Coverband
     ###
     class Base
       class << self
-        include Coverband::Utils::FilePathHelper
+        DATA_KEY = 'data'
+
         def report(store, _options = {})
           all_roots = Coverband.configuration.all_root_paths
           scov_style_report = get_current_scov_data_imp(store, all_roots)
 
-          if Coverband.configuration.verbose
-            msg = "report:\n #{scov_style_report.inspect}"
-            # Coverband.configuration.logger.debug msg
-          end
+          # These are extremelhy verbose but useful during coverband development, not generally for users
+          # Only avaiable by uncommenting this mode is never released
+          # if Coverband.configuration.verbose
+          #   # msg = "report:\n #{scov_style_report.inspect}"
+          #   # Coverband.configuration.logger.debug msg
+          # end
           scov_style_report
         end
 
+        ###
+        # Add back files that exist in the project but have no Coverage
+        # This makes it easy to find and delete files with no references
+        ###
+        def fix_reports(reports)
+          # list all files, even if not tracked by Coverband (0% coverage)
+          tracked_glob = Coverband.configuration.tracked_search_paths
+          filtered_report_files = {}
+
+          reports.each_pair do |report_name, report_data|
+            filtered_report_files[report_name] = {}
+            report_files = Coverband::Utils::Result.add_not_loaded_files(report_data, tracked_glob)
+
+            # apply coverband filters
+            report_files.each_pair do |file, data|
+              next if Coverband.configuration.ignore.any? { |i| file.match(i) }
+
+              filtered_report_files[report_name][file] = data
+            end
+          end
+          filtered_report_files
+        end
+
         protected
 
         def fix_file_names(report_hash, roots)
-          if Coverband.configuration.verbose
-            Coverband.configuration.logger.info "fixing root: #{roots.join(', ')}"
-          end
+          Coverband.configuration.logger.debug "fixing root: #{roots.join(', ')}" if Coverband.configuration.verbose
 
           # normalize names across servers
           report_hash.each_with_object({}) do |(name, report), fixed_report|
             fixed_report[name] = {}
             report.each_pair do |key, vals|
-              filename = relative_path_to_full(key, roots)
-              fixed_report[name][filename] = if fixed_report[name].key?(filename) && fixed_report[name][filename]['data'] && vals['data']
-                                         merged_data = merge_arrays(fixed_report[name][filename]['data'], vals['data'])
-                                         vals['data'] = merged_data
-                                         vals
-                                       else
-                                         vals
-                                       end
+              filename = Coverband::Utils::AbsoluteFileConverter.convert(key)
+              fixed_report[name][filename] = if fixed_report[name].key?(filename) && fixed_report[name][filename][DATA_KEY] && vals[DATA_KEY]
+                                               merged_data = merge_arrays(fixed_report[name][filename][DATA_KEY], vals[DATA_KEY])
+                                               vals[DATA_KEY] = merged_data
+                                               vals
+                                             else
+                                               vals
+                                             end
             end
           end
         end

data/lib/coverband/reporters/console_report.rb

@@ -10,6 +10,7 @@ module Coverband
         scov_style_report = super(store, options)
 
         scov_style_report.each_pair do |file, usage|
+          # TODO: In Coverband 5 deprecate none hash format
           if usage.is_a?(Hash)
             Coverband.configuration.logger.info "#{file}: #{usage['data']}"
           else

data/lib/coverband/reporters/html_report.rb

@@ -3,13 +3,13 @@
 module Coverband
   module Reporters
     class HTMLReport < Base
-      attr_accessor :filtered_report_files, :open_report, :html, :notice,
+      attr_accessor :filtered_report_files, :open_report, :static, :notice,
                     :base_path, :filename
 
       def initialize(store, options = {})
         coverband_reports = Coverband::Reporters::Base.report(store, options)
         self.open_report = options.fetch(:open_report) { true }
-        self.html = options.fetch(:html) { false }
+        self.static = options.fetch(:static) { true }
         # TODO: refactor notice out to top level of web only
         self.notice = options.fetch(:notice) { nil }
         self.base_path = options.fetch(:base_path) { nil }
@@ -25,40 +25,44 @@ module Coverband
       end
 
       def report
-        if html
-          Coverband::Utils::HTMLFormatter.new(filtered_report_files,
-                                              base_path: base_path,
-                                              notice: notice).format_html!
+        if static?
+          report_static_site
         else
-          Coverband::Utils::HTMLFormatter.new(filtered_report_files).format!
-          if open_report
-            `open #{Coverband.configuration.root}/coverage/index.html`
-          else
-            Coverband.configuration.logger.info 'report is ready and viewable: open coverage/index.html'
-          end
-
-          Coverband::Utils::S3Report.instance.persist! if Coverband.configuration.s3_bucket
+          report_dynamic_html
         end
       end
 
+      def report_data
+        report_dynamic_data
+      end
+
       private
 
-      def self.fix_reports(reports)
-        # list all files, even if not tracked by Coverband (0% coverage)
-        tracked_glob = "#{Coverband.configuration.current_root}/{app,lib,config}/**/*.{rb}"
-        filtered_report_files = {}
+      def static?
+        static
+      end
+
+      def report_static_site
+        Coverband::Utils::HTMLFormatter.new(filtered_report_files).format_static_html!
+        if open_report
+          `open #{Coverband.configuration.root}/coverage/index.html`
+        else
+          Coverband.configuration.logger.info 'report is ready and viewable: open coverage/index.html'
+        end
 
-        reports.each_pair do |report_name, report_data|
-          filtered_report_files[report_name] = {}
-          report_files = Coverband::Utils::Result.add_not_loaded_files(report_data, tracked_glob)
+        Coverband::Utils::S3Report.instance.persist! if Coverband.configuration.s3_bucket
+      end
 
-          # apply coverband filters
-          report_files.each_pair do |file, data|
-            next if Coverband.configuration.ignore.any? { |i| file.match(i) }
+      def report_dynamic_html
+        Coverband::Utils::HTMLFormatter.new(filtered_report_files,
+                                            base_path: base_path,
+                                            notice: notice).format_dynamic_html!
+      end
 
-            filtered_report_files[report_name][file] = data
-          end
-        end
+      def report_dynamic_data
+        Coverband::Utils::HTMLFormatter.new(filtered_report_files,
+                                            base_path: base_path,
+                                            notice: notice).format_dynamic_data!
       end
     end
   end

data/lib/coverband/reporters/web.rb

@@ -3,6 +3,7 @@
 begin
   require 'rack'
 rescue LoadError
+  puts 'error loading Coverband web reporter as Rack is not available'
 end
 
 module Coverband
@@ -17,19 +18,30 @@ module Coverband
                                    urls: [/.*\.css/, /.*\.js/, /.*\.gif/, /.*\.png/])
       end
 
+      def check_auth
+        return true unless Coverband.configuration.password
+
+        auth_header = request.get_header('HTTP_AUTHORIZATION')
+        return unless auth_header
+
+        Coverband.configuration.password == Base64.decode64(auth_header.split[1]).split(':')[1]
+      end
+
       def call(env)
         @request = Rack::Request.new(env)
 
+        return [401, { 'www-authenticate' => 'Basic realm=""' }, ['']] unless check_auth
+
         if request.post?
           case request.path_info
+          when %r{\/clear_view_tracking_file}
+            clear_view_tracking_file
+          when %r{\/clear_view_tracking}
+            clear_view_tracking
           when %r{\/clear_file}
             clear_file
           when %r{\/clear}
             clear
-          when %r{\/collect_coverage}
-            collect_coverage
-          when %r{\/reload_files}
-            reload_files
           else
             [404, { 'Content-Type' => 'text/html' }, ['404 error!']]
           end
@@ -39,6 +51,12 @@ module Coverband
             @static.call(env)
           when %r{\/settings}
             [200, { 'Content-Type' => 'text/html' }, [settings]]
+          when %r{\/view_tracker_data}
+            [200, { 'Content-Type' => 'text/json' }, [view_tracker_data]]
+          when %r{\/view_tracker}
+            [200, { 'Content-Type' => 'text/html' }, [view_tracker]]
+          when %r{\/enriched_debug_data}
+            [200, { 'Content-Type' => 'text/json' }, [enriched_debug_data]]
           when %r{\/debug_data}
             [200, { 'Content-Type' => 'text/json' }, [debug_data]]
           when %r{\/load_file_details}
@@ -55,7 +73,7 @@ module Coverband
         notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params['notice'])}<br/>"
         notice = request.params['notice'] ? notice : ''
         Coverband::Reporters::HTMLReport.new(Coverband.configuration.store,
-                                             html: true,
+                                             static: false,
                                              base_path: base_path,
                                              notice: notice,
                                              open_report: false).report
@@ -65,10 +83,30 @@ module Coverband
         Coverband::Utils::HTMLFormatter.new(nil, base_path: base_path).format_settings!
       end
 
+      def view_tracker
+        notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params['notice'])}<br/>"
+        notice = request.params['notice'] ? notice : ''
+        Coverband::Utils::HTMLFormatter.new(nil,
+                                            notice: notice,
+                                            base_path: base_path).format_view_tracker!
+      end
+
+      def view_tracker_data
+        Coverband::Collectors::ViewTracker.new(store: Coverband.configuration.store).as_json
+      end
+
       def debug_data
         Coverband.configuration.store.get_coverage_report.to_json
       end
 
+      def enriched_debug_data
+        Coverband::Reporters::HTMLReport.new(Coverband.configuration.store,
+                                             static: false,
+                                             base_path: base_path,
+                                             notice: '',
+                                             open_report: false).report_data
+      end
+
       def load_file_details
         filename = request.params['filename']
         Coverband::Reporters::HTMLReport.new(Coverband.configuration.store,
@@ -77,12 +115,6 @@ module Coverband
                                              open_report: false).file_details
       end
 
-      def collect_coverage
-        Coverband.report_coverage(true)
-        notice = 'coverband coverage collected'
-        [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
-      end
-
       def clear
         if Coverband.configuration.web_enable_clear
           Coverband.configuration.store.clear!
@@ -104,14 +136,27 @@ module Coverband
         [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
       end
 
-      def reload_files
-        Coverband.configuration&.safe_reload_files&.each do |safe_file|
-          load safe_file
+      def clear_view_tracking
+        if Coverband.configuration.web_enable_clear
+          tracker = Coverband::Collectors::ViewTracker.new(store: Coverband.configuration.store)
+          tracker.reset_recordings
+          notice = 'view tracking reset'
+        else
+          notice = 'web_enable_clear isnt enabled in your configuration'
         end
-        # force reload
-        Coverband.configure
-        notice = 'coverband files reloaded'
-        [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
+        [301, { 'Location' => "#{base_path}/view_tracker?notice=#{notice}" }, []]
+      end
+
+      def clear_view_tracking_file
+        if Coverband.configuration.web_enable_clear
+          tracker = Coverband::Collectors::ViewTracker.new(store: Coverband.configuration.store)
+          filename = request.params['filename']
+          tracker.clear_file!(filename)
+          notice = "coverage for file #{filename} cleared"
+        else
+          notice = 'web_enable_clear isnt enabled in your configuration'
+        end
+        [301, { 'Location' => "#{base_path}/view_tracker?notice=#{notice}" }, []]
       end
 
       private

data/lib/coverband/utils/absolute_file_converter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Utils
+    class AbsoluteFileConverter
+      def initialize(roots)
+        @cache = {}
+        @roots = roots.map { |root| "#{File.expand_path(root)}/" }
+      end
+
+      def self.instance
+        @instance ||= new(Coverband.configuration.all_root_paths)
+      end
+
+      def self.reset
+        @instance = nil
+      end
+
+      def self.convert(relative_path)
+        instance.convert(relative_path)
+      end
+
+      def convert(relative_path)
+        @cache[relative_path] ||= begin
+                                    relative_filename = relative_path
+                                    local_filename = relative_filename
+                                    @roots.each do |root|
+                                      relative_filename = relative_filename.sub(/^#{root}/, './')
+                                      # once we have a relative path break out of the loop
+                                      break if relative_filename.start_with? './'
+                                    end
+                                    # the filename for our reports is expected to be a full path.
+                                    # roots.last should be roots << current_root}/
+                                    # a fully expanded path of config.root
+                                    # filename = filename.gsub('./', roots.last)
+                                    # above only works for app files
+                                    # we need to rethink some of this logic
+                                    # gems aren't at project root and can have multiple locations
+                                    local_root = @roots.find do |root|
+                                      File.exist?(relative_filename.gsub('./', root))
+                                    end
+                                    local_root ? relative_filename.gsub('./', local_root) : local_filename
+                                  end
+      end
+    end
+  end
+end

data/lib/coverband/utils/file_hasher.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Utils
+    class FileHasher
+      @cache = {}
+
+      def self.hash(file, path_converter: AbsoluteFileConverter.instance)
+        @cache[file] ||= begin
+                           file = path_converter.convert(file)
+                           Digest::MD5.file(file).hexdigest if File.exist?(file)
+                         end
+      end
+    end
+  end
+end

data/lib/coverband/utils/file_list.rb

@@ -13,24 +13,28 @@ module Coverband
       # Returns the count of lines that have coverage
       def covered_lines
         return 0.0 if empty?
+
         map { |f| f.covered_lines.count }.inject(:+)
       end
 
       # Returns the count of lines that have been missed
       def missed_lines
         return 0.0 if empty?
+
         map { |f| f.missed_lines.count }.inject(:+)
       end
 
       # Returns the count of lines that are not relevant for coverage
       def never_lines
         return 0.0 if empty?
+
         map { |f| f.never_lines.count }.inject(:+)
       end
 
       # Returns the count of skipped lines
       def skipped_lines
         return 0.0 if empty?
+
         map { |f| f.skipped_lines.count }.inject(:+)
       end
 
@@ -40,11 +44,6 @@ module Coverband
         map(&:covered_percent)
       end
 
-      # Finds the least covered file and returns that file's name
-      def least_covered_file
-        sort_by(&:covered_percent).first.filename
-      end
-
       # Returns the overall amount of relevant lines of code across all files in this list
       def lines_of_code
         covered_lines + missed_lines
@@ -54,15 +53,27 @@ module Coverband
       # @return [Float]
       def covered_percent
         return 100.0 if empty? || lines_of_code.zero?
+
         Float(covered_lines * 100.0 / lines_of_code)
       end
 
+      # Computes the coverage based upon lines covered and lines missed, formatted
+      # @return [Float]
+      def formatted_covered_percent
+        covered_percent.round(2)
+      end
+
       # Computes the strength (hits / line) based upon lines covered and lines missed
       # @return [Float]
       def covered_strength
         return 0.0 if empty? || lines_of_code.zero?
+
         Float(map { |f| f.covered_strength * f.lines_of_code }.inject(:+) / lines_of_code)
       end
+
+      def first_seen_at
+        map(&:first_updated_at).reject { |el| el.is_a?(String) }.min
+      end
     end
   end
 end

data/lib/coverband/utils/html_formatter.rb

@@ -21,22 +21,34 @@ module Coverband
         @coverage_result = Coverband::Utils::Results.new(report) if report
       end
 
-      def format!
+      def format_static_html!
         format(@coverage_result)
       end
 
-      def format_html!
+      def format_dynamic_html!
         format_html(@coverage_result)
       end
 
+      def format_dynamic_data!
+        format_data(@coverage_result)
+      end
+
       def format_settings!
         format_settings
       end
 
+      def format_view_tracker!
+        format_view_tracker
+      end
+
       def format_source_file!(filename)
         source_file = @coverage_result.file_from_path_with_type(filename)
-  
-        formatted_source_file(@coverage_result, source_file)
+
+        if source_file
+          formatted_source_file(@coverage_result, source_file)
+        else
+          'File No Longer Available'
+        end
       end
 
       private
@@ -45,6 +57,10 @@ module Coverband
         template('settings').result(binding)
       end
 
+      def format_view_tracker
+        template('view_tracker').result(binding)
+      end
+
       def format(result)
         Dir[File.join(File.dirname(__FILE__), '../../../public/*')].each do |path|
           FileUtils.cp_r(path, asset_output_path)
@@ -59,6 +75,10 @@ module Coverband
         template('layout').result(binding)
       end
 
+      def format_data(result)
+        template('data').result(binding)
+      end
+
       # Returns the an erb instance for the template of given name
       def template(name)
         ERB.new(File.read(File.join(File.dirname(__FILE__), '../../../views/', "#{name}.erb")))
@@ -70,16 +90,25 @@ module Coverband
 
       def asset_output_path
         return @asset_output_path if defined?(@asset_output_path) && @asset_output_path
+
         @asset_output_path = File.join(output_path)
         FileUtils.mkdir_p(@asset_output_path)
         @asset_output_path
       end
 
+      def served_html?
+        !static_html?
+      end
+
+      def static_html?
+        base_path.nil?
+      end
+
       def assets_path(name)
-        if base_path
-          File.join(base_path, name)
-        else
+        if static_html?
           File.join(name)
+        else
+          File.join(base_path, name)
         end
       end
 
@@ -91,6 +120,10 @@ module Coverband
         button + '</form>'
       end
 
+      def display_nav(nav_options = {})
+        template('nav').result(binding)
+      end
+
       # Returns the html for the given source_file
       def formatted_source_file(result, source_file)
         template('source_file').result(binding)
@@ -157,7 +190,11 @@ module Coverband
       end
 
       def timeago(time)
-        "<abbr class=\"timeago\" title=\"#{time.iso8601}\">#{time.iso8601}</abbr>"
+        if time
+          "<abbr class=\"timeago\" title=\"#{time.iso8601}\">#{time.iso8601}</abbr>"
+        else
+          'Not Available'
+        end
       end
 
       def shortened_filename(source_file)

data/lib/coverband/utils/lines_classifier.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 ####
+#
+# NOTE: with Ruby 2.6.0 and beyond we can replace this classifier with
+# ::Coverage.line_stub
+# https://ruby-doc.org/stdlib-2.6.1/libdoc/coverage/rdoc/Coverage.html#method-c-line_stub
+#
 # Thanks for all the help SimpleCov https://github.com/colszowka/simplecov-html
 # initial version pulled into Coverband from Simplecov 12/04/2018
 #