coverband 4.2.0 → 4.2.1.rc1

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

@@ -13,19 +13,45 @@ module Coverband
           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
+          # 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)
+          file_patterns = ["#{Coverband.configuration.current_root}/{app,lib,config}/**/*.{rb}"]
+          if Coverband.configuration.track_gems
+            file_patterns.concat(Bundler.definition.specs.reject { |spec| spec.name == 'coverband' }.map(&:full_require_paths)
+              .flatten.map { |path| "#{path}/**/*.{rb}" })
+          end
+          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, file_patterns)
+
+            # 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.info "fixing root: #{roots.join(', ')}" if Coverband.configuration.verbose
 
           # normalize names across servers
           report_hash.each_with_object({}) do |(name, report), fixed_report|
@@ -33,12 +59,12 @@ module Coverband
             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
+                                               merged_data = merge_arrays(fixed_report[name][filename]['data'], vals['data'])
+                                               vals['data'] = merged_data
+                                               vals
+                                             else
+                                               vals
+                                             end
             end
           end
         end

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,34 @@ 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
 
       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
 
-        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)
+      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
 
-          # apply coverband filters
-          report_files.each_pair do |file, data|
-            next if Coverband.configuration.ignore.any? { |i| file.match(i) }
+        Coverband::Utils::S3Report.instance.persist! if Coverband.configuration.s3_bucket
+      end
 
-            filtered_report_files[report_name][file] = data
-          end
-        end
+      def report_dynamic_html
+        Coverband::Utils::HTMLFormatter.new(filtered_report_files,
+                                            base_path: base_path,
+                                            notice: notice).format_dynamic_html!
       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
@@ -26,10 +27,6 @@ module Coverband
             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
@@ -55,7 +52,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
@@ -77,12 +74,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,16 +95,6 @@ module Coverband
         [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
       end
 
-      def reload_files
-        Coverband.configuration&.safe_reload_files&.each do |safe_file|
-          load safe_file
-        end
-        # force reload
-        Coverband.configure
-        notice = 'coverband files reloaded'
-        [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
-      end
-
       private
 
       # This method should get the root mounted endpoint

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/file_path_helper.rb

@@ -6,6 +6,8 @@
 module Coverband
   module Utils
     module FilePathHelper
+      module_function
+
       ###
       # Takes a full path and converts to a relative path
       ###

data/lib/coverband/utils/html_formatter.rb

@@ -21,11 +21,11 @@ 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
 
@@ -35,8 +35,12 @@ module Coverband
 
       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
@@ -70,16 +74,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
 
@@ -157,7 +170,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
 #

data/lib/coverband/utils/railtie.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-Coverband.eager_loading_coverage!
 module Coverband
-  class Railtie < Rails::Railtie
-    initializer 'coverband.configure' do |app|
-      app.middleware.use Coverband::Middleware
-    end
-
-    config.after_initialize do
-      Coverband.report_coverage(true)
-      Coverband.configuration.logger&.debug('Coverband: reported after_initialize')
+  module RailsEagerLoad
+    def eager_load!
+      Coverband.eager_loading_coverage!
+      super
+    ensure
+      Coverband.report_coverage
       Coverband.runtime_coverage!
     end
+  end
+  Rails::Engine.prepend(RailsEagerLoad)
 
-    config.before_initialize do
-      Coverband.configuration.logger&.debug('Coverband: set to eager_loading')
-      Coverband.eager_loading_coverage!
+  class Railtie < Rails::Railtie
+    initializer 'coverband.configure' do |app|
+      app.middleware.use Coverband::BackgroundMiddleware
     end
 
     rake_tasks do

data/lib/coverband/utils/result.rb

@@ -22,11 +22,8 @@ module Coverband
       alias source_files files
       # Explicitly set the Time this result has been created
       attr_writer :created_at
-      # Explicitly set the command name that was used for this coverage result.
-      # Defaults to Coverband.command_name
-      attr_writer :command_name
 
-      def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines
+      def_delegators :files, :covered_percent, :covered_percentages, :covered_strength, :covered_lines, :missed_lines
       def_delegator :files, :lines_of_code, :total_lines
 
       # Initialize a new Coverband::Result from given Coverage.result (a Hash of filenames each containing an array of
@@ -37,7 +34,6 @@ module Coverband
         @files = Coverband::Utils::FileList.new(@original_result.map do |filename, coverage|
           Coverband::Utils::SourceFile.new(filename, coverage) if File.file?(filename)
         end.compact.sort_by(&:short_name))
-        filter!
       end
 
       # Returns all filenames for source files contained in this result
@@ -55,51 +51,16 @@ module Coverband
         @created_at ||= Time.now
       end
 
-      # The command name that launched this result.
-      # Delegated to Coverband.command_name if not set manually
-      def command_name
-        @command_name ||= 'Coverband'
-      end
-
-      # Returns a hash representation of this Result that can be used for marshalling it into JSON
-      def to_hash
-        { command_name => { 'coverage' => coverage, 'timestamp' => created_at.to_i } }
-      end
-
-      # Loads a Coverband::Result#to_hash dump
-      def self.from_hash(hash)
-        command_name, data = hash.first
-        result = new(data['coverage'])
-        result.command_name = command_name
-        result.created_at = Time.at(data['timestamp'])
-        result
-      end
-
       # Finds files that were to be tracked but were not loaded and initializes
       # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc).
-      def self.add_not_loaded_files(result, tracked_files)
-        if tracked_files
-          result = result.dup
-          Dir[tracked_files].each do |file|
+      def self.add_not_loaded_files(result, file_patterns)
+        file_patterns.each_with_object(result.dup) do |file_pattern, results_dup|
+          Dir[file_pattern].each do |file|
             absolute = File.expand_path(file)
 
-            result[absolute] ||= Coverband::Utils::LinesClassifier.new.classify(File.foreach(absolute))
+            results_dup[absolute] ||= Coverband::Utils::LinesClassifier.new.classify(File.foreach(absolute))
           end
         end
-
-        result
-      end
-
-      private
-
-      def coverage
-        keys = original_result.keys & filenames
-        Hash[keys.zip(original_result.values_at(*keys))]
-      end
-
-      # Applies all configured Coverband filters on this result's source files
-      def filter!
-        @files = files
       end
     end
   end