coverband 6.0.1 → 6.0.3.rc.1

data/lib/coverband/configuration.rb

@@ -16,7 +16,8 @@ module Coverband
     attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id,
       :s3_secret_access_key, :password, :api_key, :service_url, :coverband_timeout, :service_dev_mode,
       :service_test_mode, :process_type, :track_views, :redis_url,
-      :background_reporting_sleep_seconds, :reporting_wiggle
+      :background_reporting_sleep_seconds, :reporting_wiggle,
+      :send_deferred_eager_loading_data
 
     attr_reader :track_gems, :ignore, :use_oneshot_lines_coverage
 
@@ -67,6 +68,7 @@ module Coverband
       @background_reporting_enabled = true
       @background_reporting_sleep_seconds = nil
       @defer_eager_loading_data = false
+      @send_deferred_eager_loading_data = true
       @test_env = nil
       @web_enable_clear = false
       @track_views = true
@@ -91,7 +93,7 @@ module Coverband
       @coverband_timeout = nil
       @service_dev_mode = nil
       @service_test_mode = nil
-      @proces_type = nil
+      @process_type = nil
 
       @redis_url = nil
       @redis_namespace = nil
@@ -152,7 +154,7 @@ module Coverband
     def background_reporting_sleep_seconds
       @background_reporting_sleep_seconds ||= if service?
         # default to 10m for service
-        Coverband.configuration.coverband_env == "production" ? 600 : 60
+        (Coverband.configuration.coverband_env == "production") ? 600 : 60
       elsif store.is_a?(Coverband::Adapters::HashRedisStore)
         # Default to 5 minutes if using the hash redis store
         300
@@ -178,7 +180,7 @@ module Coverband
     def store=(store)
       raise "Pass in an instance of Coverband::Adapters" unless store.is_a?(Coverband::Adapters::Base)
       raise "invalid configuration: only coverband service expects an API Key" if api_key && store.class.to_s != "Coverband::Adapters::WebServiceStore"
-      raise "invalid configuration: coverband service shouldn't have redis url set" if ENV["COVERBAND_REDIS_URL"] && store.class.to_s == "Coverband::Adapters::WebServiceStore"
+      raise "invalid configuration: coverband service shouldn't have redis url set" if ENV["COVERBAND_REDIS_URL"] && store.instance_of?(::Coverband::Adapters::WebServiceStore)
 
       @store = store
     end
@@ -260,11 +262,11 @@ module Coverband
     end
 
     def coverband_env
-      ENV["RACK_ENV"] || ENV["RAILS_ENV"] || (defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : "unknown")
+      ENV["RACK_ENV"] || ENV["RAILS_ENV"] || ((defined?(Rails) && Rails.respond_to?(:env)) ? Rails.env : "unknown")
     end
 
     def coverband_timeout
-      @coverband_timeout ||= coverband_env == "development" ? 5 : 2
+      @coverband_timeout ||= (coverband_env == "development") ? 5 : 2
     end
 
     def service_dev_mode
@@ -287,6 +289,10 @@ module Coverband
       @defer_eager_loading_data
     end
 
+    def send_deferred_eager_loading_data?
+      @send_deferred_eager_loading_data
+    end
+
     def service_disabled_dev_test_env?
       return false unless service?
 

data/lib/coverband/integrations/rack_server_check.rb

@@ -20,10 +20,8 @@ module Coverband
 
     def rails_server?
       @stack.any? do |location|
-        (
-          location.path.include?("rails/commands/commands_tasks.rb") && location.label == "server" ||
+        location.path.include?("rails/commands/commands_tasks.rb") && location.label == "server" ||
           location.path.include?("rails/commands/server/server_command.rb") && location.label == "perform"
-        )
       end
     end
   end

data/lib/coverband/reporters/base.rb

@@ -4,15 +4,15 @@ module Coverband
   module Reporters
     ###
     # This is the base clase for report generation
-    # it helps with filtering, normalization, etc for final reprort generation
+    # it helps with filtering, normalization, etc for final report generation
     ###
     class Base
       class << self
         DATA_KEY = "data"
 
-        def report(store, _options = {})
+        def report(store, options = {})
           all_roots = Coverband.configuration.all_root_paths
-          scov_style_report = get_current_scov_data_imp(store, all_roots)
+          get_current_scov_data_imp(store, all_roots, options)
 
           # These are extremelhy verbose but useful during coverband development, not generally for users
           # Only available by uncommenting this mode is never released
@@ -20,7 +20,6 @@ module Coverband
           #   # msg = "report:\n #{scov_style_report.inspect}"
           #   # Coverband.configuration.logger.debug msg
           # end
-          scov_style_report
         end
 
         ###
@@ -71,7 +70,7 @@ module Coverband
         # > [nil,0,0,1,0,1]
         def merge_arrays(first, second)
           merged = []
-          longest = first.length > second.length ? first : second
+          longest = (first.length > second.length) ? first : second
 
           longest.each_with_index do |_line, index|
             merged[index] = if first[index] || second[index]
@@ -86,12 +85,13 @@ module Coverband
         # why do we need to merge covered files data?
         # basically because paths on machines or deployed hosts could be different, so
         # two different keys could point to the same filename or `line_key`
+        # this happens when deployment has a dynmaic path or the path change during deployment (hot code reload)
         # TODO: think we are filtering based on ignore while sending to the store
         # and as we also pull it out here
         ###
-        def get_current_scov_data_imp(store, roots)
+        def get_current_scov_data_imp(store, roots, options = {})
           scov_style_report = {}
-          store.get_coverage_report.each_pair do |name, data|
+          store.get_coverage_report(options).each_pair do |name, data|
             data.each_pair do |key, line_data|
               next if Coverband.configuration.ignore.any? { |i| key.match(i) }
               next unless line_data

data/lib/coverband/reporters/html_report.rb

@@ -4,17 +4,23 @@ module Coverband
   module Reporters
     class HTMLReport < Base
       attr_accessor :filtered_report_files, :open_report, :notice,
-        :base_path, :filename
+        :base_path, :filename, :page
 
       def initialize(store, options = {})
-        coverband_reports = Coverband::Reporters::Base.report(store, options)
+        self.page = options.fetch(:page) { nil }
         self.open_report = options.fetch(:open_report) { true }
         # TODO: refactor notice out to top level of web only
         self.notice = options.fetch(:notice) { nil }
         self.base_path = options.fetch(:base_path) { "./" }
         self.filename = options.fetch(:filename) { nil }
 
-        self.filtered_report_files = self.class.fix_reports(coverband_reports)
+        coverband_reports = Coverband::Reporters::Base.report(store, options)
+        # NOTE: at the moment the optimization around paging and filenames only works for hash redis store
+        self.filtered_report_files = if (page || filename) && store.is_a?(Coverband::Adapters::HashRedisStore)
+          coverband_reports
+        else
+          self.class.fix_reports(coverband_reports)
+        end
       end
 
       def file_details
@@ -36,12 +42,14 @@ module Coverband
       def report_dynamic_html
         Coverband::Utils::HTMLFormatter.new(filtered_report_files,
           base_path: base_path,
-          notice: notice).format_dynamic_html!
+          notice: notice,
+          page: page).format_dynamic_html!
       end
 
       def report_dynamic_data
         Coverband::Utils::HTMLFormatter.new(filtered_report_files,
           base_path: base_path,
+          page: page,
           notice: notice).format_dynamic_data!
       end
     end

data/lib/coverband/reporters/json_report.rb

@@ -5,11 +5,22 @@
 module Coverband
   module Reporters
     class JSONReport < Base
-      attr_accessor :filtered_report_files
+      attr_accessor :filtered_report_files, :options, :page, :as_report, :store, :filename
 
       def initialize(store, options = {})
+        self.options = options
+        self.page = options.fetch(:page) { nil }
+        self.filename = options.fetch(:filename) { nil }
+        self.as_report = options.fetch(:as_report) { false }
+        self.store = store
+
         coverband_reports = Coverband::Reporters::Base.report(store, options)
-        self.filtered_report_files = self.class.fix_reports(coverband_reports)
+        # NOTE: paged reports can't find and add in files that has never been loaded
+        self.filtered_report_files = if page || filename
+          coverband_reports
+        else
+          self.class.fix_reports(coverband_reports)
+        end
       end
 
       def report
@@ -21,10 +32,35 @@ module Coverband
       def report_as_json
         result = Coverband::Utils::Results.new(filtered_report_files)
         source_files = result.source_files
-        {
+
+        data = {
           **coverage_totals(source_files),
           files: coverage_files(result, source_files)
-        }.to_json
+        }
+
+        if as_report
+          row_data = []
+          data[:files].each_pair do |key, data|
+            row_data << [
+              key,
+              data[:covered_percent].to_s,
+              data[:runtime_percentage].to_s,
+              data[:lines_of_code].to_s,
+              (data[:lines_covered] + data[:lines_missed]).to_s,
+              data[:lines_covered].to_s,
+              data[:lines_runtime].to_s,
+              data[:lines_missed].to_s,
+              data[:covered_strength].to_s
+            ]
+          end
+          filesreported = store.file_count(:runtime)
+          data["iTotalRecords"] = filesreported
+          data["iTotalDisplayRecords"] = filesreported
+          data["aaData"] = row_data
+          data.delete(:files)
+          data = data.as_json
+        end
+        data.to_json
       end
 
       def coverage_totals(source_files)
@@ -41,11 +77,13 @@ module Coverband
       # Using a hash indexed by file name for quick lookups
       def coverage_files(result, source_files)
         source_files.each_with_object({}) do |source_file, hash|
+          runtime_coverage = result.file_with_type(source_file, Coverband::RUNTIME_TYPE)&.covered_lines_count || 0
           hash[source_file.short_name] = {
             never_loaded: source_file.never_loaded,
             runtime_percentage: result.runtime_relevant_coverage(source_file),
             lines_of_code: source_file.lines.count,
             lines_covered: source_file.covered_lines.count,
+            lines_runtime: runtime_coverage,
             lines_missed: source_file.missed_lines.count,
             covered_percent: source_file.covered_percent,
             covered_strength: source_file.covered_strength

data/lib/coverband/reporters/web.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "base64"
 require "coverband"
 
 begin
@@ -56,7 +57,7 @@ module Coverband
 
         return [401, {"www-authenticate" => 'Basic realm=""'}, [""]] unless check_auth
 
-        request_path_info = request.path_info == "" ? "/" : request.path_info
+        request_path_info = (request.path_info == "") ? "/" : request.path_info
         tracker_route = false
         Coverband.configuration.trackers.each do |tracker|
           if request_path_info.match(tracker.class::REPORT_ROUTE)
@@ -97,6 +98,8 @@ module Coverband
               [200, coverband_headers(content_type: "text/json"), [load_file_details]]
             when %r{\/json}
               [200, coverband_headers(content_type: "text/json"), [json]]
+            when %r{\/report_json}
+              [200, coverband_headers(content_type: "text/json"), [report_json]]
             when %r{\/$}
               [200, coverband_headers, [index]]
             else
@@ -120,6 +123,17 @@ module Coverband
         Coverband::Reporters::JSONReport.new(Coverband.configuration.store).report
       end
 
+      def report_json
+        report_options = {
+          as_report: true
+        }
+        report_options[:page] = (request.params["page"] || 1).to_i if request.params["page"]
+        Coverband::Reporters::JSONReport.new(
+          Coverband.configuration.store,
+          report_options
+        ).report
+      end
+
       def settings
         Coverband::Utils::HTMLFormatter.new(nil, base_path: base_path).format_settings!
       end
@@ -218,7 +232,7 @@ module Coverband
       # %r{\/.*\/}.match?(request.path) ? request.path.match("\/.*\/")[0] : "/"
       # ^^ the above is NOT valid Ruby 2.3/2.4 even though rubocop / standard think it is
       def base_path
-        request.path =~ %r{\/.*\/} ? request.path.match("/.*/")[0] : "/"
+        (request.path =~ %r{\/.*\/}) ? request.path.match("/.*/")[0] : "/"
       end
     end
   end

data/lib/coverband/reporters/web_pager.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "base64"
+require "coverband"
+
+begin
+  require "rack"
+rescue LoadError
+  puts "error loading Coverband web reporter as Rack is not available"
+end
+
+module Coverband
+  module Reporters
+    class WebPager < Web
+      def index
+        notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params["notice"])}<br/>"
+        notice = request.params["notice"] ? notice : ""
+        # TODO: remove the call to the store render empty table
+        Coverband::Reporters::HTMLReport.new(Coverband.configuration.store,
+          page: (request.params["page"] || 1).to_i,
+          static: false,
+          base_path: base_path,
+          notice: notice,
+          open_report: false).report
+      end
+    end
+  end
+end

data/lib/coverband/utils/absolute_file_converter.rb

@@ -22,25 +22,25 @@ module Coverband
 
       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 { |root|
-                                      File.exist?(relative_filename.gsub("./", root))
-                                    }
-                                    local_root ? relative_filename.gsub("./", local_root) : local_filename
-                                  end
+          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 { |root|
+            File.exist?(relative_filename.gsub("./", root))
+          }
+          local_root ? relative_filename.gsub("./", local_root) : local_filename
+        end
       end
     end
   end

data/lib/coverband/utils/file_hasher.rb

@@ -7,9 +7,9 @@ module Coverband
 
       def self.hash_file(file, path_converter: AbsoluteFileConverter.instance)
         @cache[file] ||= begin
-                           file = path_converter.convert(file)
-                           Digest::MD5.file(file).hexdigest if File.exist?(file)
-                         end
+          file = path_converter.convert(file)
+          Digest::MD5.file(file).hexdigest if File.exist?(file)
+        end
       end
     end
   end

data/lib/coverband/utils/html_formatter.rb

@@ -13,12 +13,13 @@ require "time"
 module Coverband
   module Utils
     class HTMLFormatter
-      attr_reader :notice, :base_path, :tracker
+      attr_reader :notice, :base_path, :tracker, :page
 
       def initialize(report, options = {})
         @notice = options.fetch(:notice, nil)
         @base_path = options.fetch(:base_path, "./")
         @tracker = options.fetch(:tracker, nil)
+        @page = options.fetch(:page, nil)
         @coverage_result = Coverband::Utils::Results.new(report) if report
       end
 
@@ -126,11 +127,10 @@ module Coverband
       # Returns a table containing the given source files
       def formatted_file_list(title, result, source_files, options = {})
         title_id = title.gsub(/^[^a-zA-Z]+/, "").gsub(/[^a-zA-Z0-9\-\_]/, "")
-        # Silence a warning by using the following variable to assign to itself:
+        # Silence a warning by using the following variable to assign to `_`:
         # "warning: possibly useless use of a variable in void context"
         # The variable is used by ERB via binding.
-        title_id = title_id
-        options = options
+        _ = title_id, options
 
         template("file_list").result(binding)
       end

data/lib/coverband/utils/method_definition_scanner.rb

@@ -71,7 +71,7 @@ if defined?(RubyVM::AbstractSyntaxTree)
         def scan_node(node, class_name)
           definitions = []
           return definitions unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
-          current_class = node.type == :CLASS ? node.children.first.children.last : class_name
+          current_class = (node.type == :CLASS) ? node.children.first.children.last : class_name
           if node.type == :DEFN
             definitions <<
               MethodDefinition.new(

data/lib/coverband/utils/railtie.rb

@@ -11,12 +11,10 @@ module Coverband
 
   class Railtie < Rails::Railtie
     initializer "coverband.configure" do |app|
-      begin
-        app.middleware.use Coverband::BackgroundMiddleware
-      rescue Redis::CannotConnectError => error
-        Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
-        Coverband.configuration.logger.info "If this is a setup task like assets:precompile feel free to ignore"
-      end
+      app.middleware.use Coverband::BackgroundMiddleware
+    rescue Redis::CannotConnectError => error
+      Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
+      Coverband.configuration.logger.info "If this is a setup task like assets:precompile feel free to ignore"
     end
 
     config.after_initialize do

data/lib/coverband/utils/relative_file_converter.rb

@@ -22,13 +22,13 @@ module Coverband
 
       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
+          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

data/lib/coverband/utils/results.rb

@@ -17,7 +17,11 @@ module Coverband
       def file_with_type(source_file, results_type)
         return unless get_results(results_type)
 
-        get_results(results_type).source_files.find { |file| file.filename == source_file.filename }
+        @files_with_type ||= {}
+        @files_with_type[results_type] ||= get_results(results_type).source_files.map do |source_file|
+          [source_file.filename, source_file]
+        end.to_h
+        @files_with_type[results_type][source_file.filename]
       end
 
       def runtime_relevant_coverage(source_file)
@@ -48,7 +52,11 @@ module Coverband
       def file_from_path_with_type(full_path, results_type = :merged)
         return unless get_results(results_type)
 
-        get_results(results_type).source_files.find { |file| file.filename == full_path }
+        @files_from_path_with_type ||= {}
+        @files_from_path_with_type[results_type] ||= get_results(results_type).source_files.map do |source_file|
+          [source_file.filename, source_file]
+        end.to_h
+        @files_from_path_with_type[results_type][full_path]
       end
 
       def method_missing(method, *args)
@@ -60,21 +68,17 @@ module Coverband
       end
 
       def respond_to_missing?(method)
-        if get_results(type).respond_to?(method)
-          true
-        else
-          false
-        end
+        get_results(type).respond_to?(method)
       end
 
       private
 
       def get_eager_file(source_file)
-        eager_loading_coverage.source_files.find { |file| file.filename == source_file.filename }
+        file_with_type(source_file, Coverband::EAGER_TYPE)
       end
 
       def get_runtime_file(source_file)
-        runtime_coverage.source_files.find { |file| file.filename == source_file.filename }
+        file_with_type(source_file, Coverband::RUNTIME_TYPE)
       end
 
       def eager_loading_coverage
@@ -93,11 +97,7 @@ module Coverband
       def get_results(type)
         return nil unless Coverband::ALL_TYPES.include?(type)
 
-        if @results.key?(type)
-          @results[type]
-        else
-          @results[type] = Coverband::Utils::Result.new(report[type])
-        end
+        @results[type] ||= Coverband::Utils::Result.new(report[type])
       end
     end
   end

data/lib/coverband/utils/source_file.rb

@@ -74,7 +74,7 @@ module Coverband
           return "skipped" if skipped?
           return "never" if never?
           return "missed" if missed?
-          return "covered" if covered?
+          "covered" if covered?
         end
       end
 
@@ -162,7 +162,7 @@ module Coverband
         return 0.0 if relevant_lines.zero?
 
         # handle edge case where runtime in dev can go over 100%
-        [Float(covered_lines.size * 100.0 / relevant_lines.to_f), 100.0].min
+        [Float(covered_lines.size * 100.0 / relevant_lines.to_f), 100.0].min&.round(2)
       end
 
       def formatted_covered_percent

data/lib/coverband/utils/tasks.rb

@@ -35,7 +35,7 @@ namespace :coverband do
       Coverband.configuration.store.merge_mode = true
     end
     Rack::Server.start app: Coverband::Reporters::Web.new,
-                       Port: ENV.fetch("COVERBAND_COVERAGE_PORT", 9022).to_i
+      Port: ENV.fetch("COVERBAND_COVERAGE_PORT", 9022).to_i
   end
 
   ###

data/lib/coverband/version.rb

@@ -5,5 +5,5 @@
 # use format "4.2.1.rc.1" ~> 4.2.1.rc to prerelease versions like v4.2.1.rc.2 and v4.2.1.rc.3
 ###
 module Coverband
-  VERSION = "6.0.1"
+  VERSION = "6.0.3.rc.1"
 end

data/lib/coverband.rb

@@ -82,9 +82,9 @@ module Coverband
   end
 
   def self.tasks_to_ignore?
-    (defined?(Rake) &&
-    Rake.respond_to?(:application) &&
-    (Rake&.application&.top_level_tasks || []).any? { |task| Coverband::Configuration::IGNORE_TASKS.include?(task) })
+    defined?(Rake) &&
+      Rake.respond_to?(:application) &&
+      (Rake&.application&.top_level_tasks || []).any? { |task| Coverband::Configuration::IGNORE_TASKS.include?(task) }
   end
 
   def self.eager_loading_coverage!
@@ -130,6 +130,7 @@ module Coverband
       ###
       def initialize
         require "coverband/reporters/web"
+        require "coverband/reporters/web_pager"
         require "coverband/utils/html_formatter"
         require "coverband/utils/result"
         require "coverband/utils/file_list"
@@ -147,4 +148,19 @@ module Coverband
       end
     end
   end
+
+  module Reporters
+    class WebPager < Web
+      def initialize
+        require "coverband/reporters/web"
+        require "coverband/reporters/web_pager"
+        super
+      end
+
+      def self.call(env)
+        @app ||= new
+        @app.call(env)
+      end
+    end
+  end
 end

data/public/application.js

@@ -33,6 +33,41 @@ $(document).ready(function() {
     ]
   });
 
+  // TODO: add support for searching...
+  // hmm should I just use manual paging? or load more...
+  if ($(".file_list.unsorted").length == 1) {
+    var current_rows = 0;
+    var total_rows = 0;
+    var page = 1;
+
+    // write a function to get a page of data and add it to the table
+    function get_page(page) {
+      $.ajax({
+        url: `/coverage/report_json?page=${page}`,
+        type: 'GET',
+        dataType: 'json',
+        success: function(data) {
+          console.log(data);
+          total_rows = data["iTotalRecords"];
+          // NOTE: we request 250 at a time, but we seem to have some files that we have as a list but 0 coverage,
+          // so we don't get back 250 per page... to ensure we we need to account for filtered out and empty files
+          // this 250 at the moment is synced to the 250 in the hash redis store
+          current_rows += 250; //data["aaData"].length;
+          console.log(current_rows);
+          console.log(total_rows);
+          $(".file_list.unsorted").dataTable().fnAddData(data["aaData"]);
+          page += 1;
+          // the page less than 100 is to stop infinite loop in case of folks never clearing out old coverage reports
+          if (page < 100 && current_rows < total_rows) {
+            get_page(page);
+          }
+        }
+      });
+    }
+    get_page(page);
+  }
+
+
   // Syntax highlight all files up front - deactivated
   // $('.source_table pre code').each(function(i, e) {hljs.highlightBlock(e, '  ')});