coverband 4.2.0 → 4.2.2

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
@@ -39,6 +47,8 @@ module Coverband
             @static.call(env)
           when %r{\/settings}
             [200, { 'Content-Type' => 'text/html' }, [settings]]
+          when %r{\/view_tracker}
+            [200, { 'Content-Type' => 'text/html' }, [view_tracker]]
           when %r{\/debug_data}
             [200, { 'Content-Type' => 'text/json' }, [debug_data]]
           when %r{\/load_file_details}
@@ -55,7 +65,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,6 +75,10 @@ module Coverband
         Coverband::Utils::HTMLFormatter.new(nil, base_path: base_path).format_settings!
       end
 
+      def view_tracker
+        Coverband::Utils::HTMLFormatter.new(nil, base_path: base_path).format_view_tracker!
+      end
+
       def debug_data
         Coverband.configuration.store.get_coverage_report.to_json
       end
@@ -77,12 +91,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 +112,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/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,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
 
@@ -33,10 +33,18 @@ module Coverband
         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 +53,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)
@@ -70,16 +82,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 +112,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 +182,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,32 @@
 # frozen_string_literal: true
 
-Coverband.eager_loading_coverage!
 module Coverband
+  module RailsEagerLoad
+    def eager_load!
+      Coverband.eager_loading_coverage!
+      super
+    end
+  end
+  Rails::Engine.prepend(RailsEagerLoad)
+
   class Railtie < Rails::Railtie
     initializer 'coverband.configure' do |app|
-      app.middleware.use Coverband::Middleware
-    end
+      app.middleware.use Coverband::BackgroundMiddleware
 
-    config.after_initialize do
-      Coverband.report_coverage(true)
-      Coverband.configuration.logger&.debug('Coverband: reported after_initialize')
-      Coverband.runtime_coverage!
+      if Coverband.configuration.track_views
+        CoverbandViewTracker = Coverband::Collectors::ViewTracker.new
+        Coverband.configuration.view_tracker = CoverbandViewTracker
+
+        ActiveSupport::Notifications.subscribe(/render_partial.action_view|render_template.action_view/) do |name, start, finish, id, payload|
+          CoverbandViewTracker.track_views(name, start, finish, id, payload) unless name.include?('!')
+        end
+      end
     end
 
-    config.before_initialize do
-      Coverband.configuration.logger&.debug('Coverband: set to eager_loading')
+    config.after_initialize do
       Coverband.eager_loading_coverage!
+      Coverband.report_coverage
+      Coverband.runtime_coverage!
     end
 
     rake_tasks do

data/lib/coverband/utils/relative_file_converter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Coverband
+  module Utils
+    class RelativeFileConverter
+      def self.instance
+        @instance ||= new(Coverband.configuration.all_root_paths)
+      end
+
+      def self.reset
+        @instance = nil
+      end
+
+      def self.convert(file)
+        instance.convert(file)
+      end
+
+      def initialize(roots)
+        @cache = {}
+        @roots = normalize(roots)
+      end
+
+      def convert(file)
+        @cache[file] ||= begin
+                           relative_file = file
+                           @roots.each do |root|
+                             relative_file = file.gsub(/^#{root}/, '.')
+                             break relative_file if relative_file.start_with?('.')
+                           end
+                           relative_file
+                         end
+      end
+
+      private
+
+      def normalize(paths)
+        paths.map { |root| File.expand_path(root) }
+      end
+    end
+  end
+end

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

data/lib/coverband/utils/s3_report.rb

@@ -26,8 +26,8 @@ module Coverband
         begin
           require 'aws-sdk-s3'
         rescue StandardError
-          err_msg = 'coverband requires aws-sdk in order use S3Report.'
-          Coverband.configuration.logger.error err_msg
+          err_msg = 'Coverband requires aws-sdk in order use S3Report.'
+          Coverband.configuration.logger&.error err_msg
           return
         end
       end