coverband 4.2.0 → 4.2.1

data/lib/coverband/reporters/base.rb

@@ -9,36 +9,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
+          # 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.current_root}/{app,lib,config}/**/*.{rb}"
+          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.info "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
+              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/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
@@ -17,19 +18,26 @@ 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_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
@@ -55,7 +63,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 +85,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 +106,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,16 +6,25 @@
 module Coverband
   module Utils
     module FilePathHelper
+      module_function
+
+      @@path_cache = {}
+
       ###
       # Takes a full path and converts to a relative path
       ###
       def full_path_to_relative(full_path)
+        return @@path_cache[full_path] if @@path_cache.key?(full_path)
+
         relative_filename = full_path
-        Coverband.configuration.all_root_paths.each do |root|
-          relative_filename = relative_filename.gsub(/^#{root}/, './')
+        Coverband.configuration.all_root_patterns.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
+
+        @@path_cache[full_path] = relative_filename
+
         relative_filename
       end
 
@@ -40,7 +49,9 @@ module Coverband
         relative_filename = relative_path
         local_filename = relative_filename
         roots.each do |root|
-          relative_filename = relative_filename.gsub(/^#{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}/

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,26 +51,6 @@ 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)
@@ -89,18 +65,6 @@ module Coverband
 
         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
 end

data/lib/coverband/utils/results.rb

@@ -20,6 +20,41 @@ module Coverband
         get_results(results_type).source_files.find { |file| file.filename == source_file.filename }
       end
 
+      def runtime_relevant_coverage(source_file)
+        return unless eager_loading_coverage && runtime_coverage
+
+        eager_file = get_eager_file(source_file)
+        runtime_file = get_runtime_file(source_file)
+
+        return 0.0 unless runtime_file
+
+        return runtime_file.formatted_covered_percent unless eager_file
+
+        runtime_relavant_lines = eager_file.relevant_lines - eager_file.covered_lines_count
+        runtime_file.runtime_relavant_calculations(runtime_relavant_lines) { |file| file.formatted_covered_percent }
+      end
+
+      def runtime_relavent_lines(source_file)
+        return 0 unless runtime_coverage
+
+        eager_file = get_eager_file(source_file)
+        runtime_file = get_runtime_file(source_file)
+
+        return runtime_file.covered_lines_count unless eager_file
+
+        eager_file.relevant_lines - eager_file.covered_lines_count
+      end
+
+      ###
+      # TODO: Groups still have some issues, this should be generic for groups, but right now gem_name
+      # is specifically called out, need to revisit all gorups code.
+      ###
+      def group_file_list_with_type(group, file_list, results_type)
+        return unless get_results(results_type)
+
+        get_results(results_type).groups[group].find { |gem_files| gem_files.first.gem_name == file_list.first.gem_name }
+      end
+
       def file_from_path_with_type(full_path, results_type = :merged)
         return unless get_results(results_type)
 
@@ -44,6 +79,22 @@ module Coverband
 
       private
 
+      def get_eager_file(source_file)
+        eager_loading_coverage.source_files.find { |file| file.filename == source_file.filename }
+      end
+
+      def get_runtime_file(source_file)
+        runtime_coverage.source_files.find { |file| file.filename == source_file.filename }
+      end
+
+      def eager_loading_coverage
+        get_results(Coverband::EAGER_TYPE)
+      end
+
+      def runtime_coverage
+        get_results(Coverband::RUNTIME_TYPE)
+      end
+
       ###
       # This is a first version of lazy loading the results
       # for the full advantage we need to push lazy loading to the file level