coverband 4.0.1 → 4.2.0

data/lib/coverband/integrations/resque.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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)
+end
+
+module Coverband
+  module ResqueWorker
+    def perform
+      super
+    ensure
+      Coverband.report_coverage(true)
+    end
+  end
+end
+
+Resque::Job.prepend(Coverband::ResqueWorker)

data/lib/coverband/reporters/base.rb

@@ -8,41 +8,38 @@ module Coverband
     ###
     class Base
       class << self
+        include Coverband::Utils::FilePathHelper
         def report(store, _options = {})
-          scov_style_report = get_current_scov_data_imp(store, root_paths)
+          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
+            # Coverband.configuration.logger.debug msg
           end
           scov_style_report
         end
 
         protected
 
-        def root_paths
-          roots = Coverband.configuration.root_paths
-          roots << "#{current_root}/"
-          roots
-        end
-
-        def current_root
-          File.expand_path(Coverband.configuration.root)
-        end
-
         def fix_file_names(report_hash, roots)
           if Coverband.configuration.verbose
             Coverband.configuration.logger.info "fixing root: #{roots.join(', ')}"
           end
 
           # normalize names across servers
-          report_hash.each_with_object({}) do |(key, vals), fixed_report|
-            filename = filename_from_key(key, roots)
-            fixed_report[filename] = if fixed_report.key?(filename)
-                                       merge_arrays(fixed_report[filename], vals)
-                                     else
-                                       vals
-                                     end
+          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
+            end
           end
         end
 
@@ -61,32 +58,23 @@ module Coverband
           merged
         end
 
-        def filename_from_key(key, roots)
-          filename = key
-          roots.each do |root|
-            filename = filename.gsub(/^#{root}/, './')
-          end
-          # the filename for  SimpleCov 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)
-          filename
-        end
-
         ###
         # 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 logic should be pushed to base report
         # 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)
           scov_style_report = {}
-          store.coverage.each_pair do |key, line_data|
-            next if Coverband.configuration.ignore.any? { |i| key.match(i) }
-            next unless line_data
-            scov_style_report[key] = line_data
+          store.get_coverage_report.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
+
+              scov_style_report[name] = {} unless scov_style_report.key?(name)
+              scov_style_report[name][key] = line_data
+            end
           end
 
           scov_style_report = fix_file_names(scov_style_report, roots)

data/lib/coverband/reporters/html_report.rb

@@ -3,23 +3,28 @@
 module Coverband
   module Reporters
     class HTMLReport < Base
-      def self.report(store, options = {})
-        scov_style_report = super(store, options)
-        open_report = options.fetch(:open_report) { true }
-        html = options.fetch(:html) { false }
-        notice = options.fetch(:notice) { nil }
-        base_path = options.fetch(:base_path) { nil }
+      attr_accessor :filtered_report_files, :open_report, :html, :notice,
+                    :base_path, :filename
 
-        # list all files, even if not tracked by Coverband (0% coverage)
-        tracked_glob = "#{current_root}/{app,lib,config}/**/*.{rb}"
-        report_files = Coverband::Utils::Result.add_not_loaded_files(scov_style_report, tracked_glob)
-        # apply coverband filters
-        filtered_report_files = {}
-        report_files.each_pair do |file, data|
-          next if Coverband.configuration.ignore.any? { |i| file.match(i) }
-          filtered_report_files[file] = data
-        end
+      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 }
+        # TODO: refactor notice out to top level of web only
+        self.notice = options.fetch(:notice) { nil }
+        self.base_path = options.fetch(:base_path) { nil }
+        self.filename = options.fetch(:filename) { nil }
+
+        self.filtered_report_files = self.class.fix_reports(coverband_reports)
+      end
 
+      def file_details
+        Coverband::Utils::HTMLFormatter.new(filtered_report_files,
+                                            base_path: base_path,
+                                            notice: notice).format_source_file!(filename)
+      end
+
+      def report
         if html
           Coverband::Utils::HTMLFormatter.new(filtered_report_files,
                                               base_path: base_path,
@@ -35,6 +40,26 @@ module Coverband
           Coverband::Utils::S3Report.instance.persist! if Coverband.configuration.s3_bucket
         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 = {}
+
+        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
+      end
     end
   end
 end

data/lib/coverband/reporters/web.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require 'rack'
+begin
+  require 'rack'
+rescue LoadError
+end
 
 module Coverband
   module Reporters
@@ -19,6 +22,8 @@ module Coverband
 
         if request.post?
           case request.path_info
+          when %r{\/clear_file}
+            clear_file
           when %r{\/clear}
             clear
           when %r{\/collect_coverage}
@@ -32,7 +37,13 @@ module Coverband
           case request.path_info
           when /.*\.(css|js|gif|png)/
             @static.call(env)
-          when %r{\/}
+          when %r{\/settings}
+            [200, { 'Content-Type' => 'text/html' }, [settings]]
+          when %r{\/debug_data}
+            [200, { 'Content-Type' => 'text/json' }, [debug_data]]
+          when %r{\/load_file_details}
+            [200, { 'Content-Type' => 'text/json' }, [load_file_details]]
+          when %r{\/$}
             [200, { 'Content-Type' => 'text/html' }, [index]]
           else
             [404, { 'Content-Type' => 'text/html' }, ['404 error!']]
@@ -43,22 +54,53 @@ module Coverband
       def index
         notice = "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params['notice'])}<br/>"
         notice = request.params['notice'] ? notice : ''
-        Coverband::Reporters::HTMLReport.report(Coverband.configuration.store,
-                                                html: true,
-                                                base_path: base_path,
-                                                notice: notice,
-                                                open_report: false)
+        Coverband::Reporters::HTMLReport.new(Coverband.configuration.store,
+                                             html: true,
+                                             base_path: base_path,
+                                             notice: notice,
+                                             open_report: false).report
+      end
+
+      def settings
+        Coverband::Utils::HTMLFormatter.new(nil, base_path: base_path).format_settings!
+      end
+
+      def debug_data
+        Coverband.configuration.store.get_coverage_report.to_json
+      end
+
+      def load_file_details
+        filename = request.params['filename']
+        Coverband::Reporters::HTMLReport.new(Coverband.configuration.store,
+                                             filename: filename,
+                                             base_path: base_path,
+                                             open_report: false).file_details
       end
 
       def collect_coverage
-        Coverband::Collectors::Coverage.instance.report_coverage(true)
+        Coverband.report_coverage(true)
         notice = 'coverband coverage collected'
         [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
       end
 
       def clear
-        Coverband.configuration.store.clear!
-        notice = 'coverband coverage cleared'
+        if Coverband.configuration.web_enable_clear
+          Coverband.configuration.store.clear!
+          notice = 'coverband coverage cleared'
+        else
+          notice = 'web_enable_clear isnt enabled in your configuration'
+        end
+        [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
+      end
+
+      def clear_file
+        if Coverband.configuration.web_enable_clear
+          filename = request.params['filename']
+          Coverband.configuration.store.clear_file!(filename)
+          notice = "coverage for file #{filename} cleared"
+        else
+          notice = 'web_enable_clear isnt enabled in your configuration'
+        end
         [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
       end
 

data/lib/coverband/utils/file_groups.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+#
+# Applies the configured groups to the given array of Coverband::SourceFile items
+#
+module Coverband
+  module Utils
+    class FileGroups
+      def initialize(files)
+        @grouped = {}
+        @files = files
+        filter_to_groups
+      end
+
+      def grouped_results
+        @grouped
+      end
+
+      private
+
+      def filter_to_groups
+        grouped_files = []
+        Coverband.configuration.groups.each do |name, filter|
+          if name == 'Gems'
+            gem_lists = gem_files(name, filter)
+            grouped_files.concat(gem_lists.flatten) if gem_lists.flatten.any?
+          else
+            app_files(name, filter)
+            grouped_files += @grouped[name]
+          end
+        end
+        if !Coverband.configuration.groups.empty? && !(other_files = @files.reject do |source_file|
+                                                         grouped_files.include?(source_file)
+                                                       end).empty?
+          @grouped['Ungrouped'] = Coverband::Utils::FileList.new(other_files)
+        end
+      end
+
+      def gem_files(name, filter)
+        grouped_gems = @files.select { |source_file| source_file.filename =~ /#{filter}/ }.group_by(&:gem_name)
+        gem_lists = grouped_gems.values.map { |gem_files| Coverband::Utils::FileList.new(gem_files) }
+        @grouped[name] = Coverband::Utils::GemList.new(gem_lists) if gem_lists.flatten.any?
+        gem_lists
+      end
+
+      def app_files(name, filter)
+        @grouped[name] = Coverband::Utils::FileList.new(@files.select do |source_file|
+          source_file.filename =~ /#{filter}/ && source_file.filename !~ /#{Coverband.configuration.gem_paths.first}/
+        end)
+      end
+    end
+  end
+end

data/lib/coverband/utils/file_path_helper.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+####
+# Helper functions for shared logic related to file path manipulation
+####
+module Coverband
+  module Utils
+    module FilePathHelper
+      ###
+      # Takes a full path and converts to a relative path
+      ###
+      def full_path_to_relative(full_path)
+        relative_filename = full_path
+        Coverband.configuration.all_root_paths.each do |root|
+          relative_filename = relative_filename.gsub(/^#{root}/, './')
+          # once we have a relative path break out of the loop
+          break if relative_filename.start_with? './'
+        end
+        relative_filename
+      end
+
+      ###
+      # relative_path_to_full code takes:
+      # relative_path: which is a full path the same as reported by Coverage
+      # roots: if a collection of all possible full app paths
+      #    EX: [Coverband.configuration.root_paths, "#{current_root}/"]
+      # The LAST item should be the current file system root
+      # it expands that expands and adds a '/' as that isn't there from Dir.pwd
+      #
+      # NOTEs on configuration.root_paths usage
+      # strings: matching is pretty simple for full string paths
+      # regex: to get regex to work for changing deploy directories
+      #        the regex must be double escaped in double quotes
+      #          (if using \d for example)
+      #        or use single qoutes
+      #        example: '/box/apps/app_name/releases/\d+/'
+      #        example: '/var/local/company/company.d/[0-9]*/'
+      ###
+      def relative_path_to_full(relative_path, roots)
+        relative_filename = relative_path
+        local_filename = relative_filename
+        roots.each do |root|
+          relative_filename = relative_filename.gsub(/^#{root}/, './')
+        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/gem_list.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+####
+# An array of  FileLists instances with helpers to roll up the stats
+# methods for calculating coverage across them etc.
+####
+module Coverband
+  module Utils
+    class GemList < FileList
+      # Returns the count of lines that have coverage
+      def covered_lines
+        to_a.map(&:covered_lines).inject(:+)
+      end
+
+      # Returns the count of lines that have been missed
+      def missed_lines
+        to_a.map(&:missed_lines).inject(:+)
+      end
+
+      # Returns the count of lines that are not relevant for coverage
+      def never_lines
+        to_a.map(&:never_lines).inject(:+)
+      end
+
+      # Returns the count of skipped lines
+      def skipped_lines
+        to_a.map(&:skipped_lines).inject(:+)
+      end
+    end
+  end
+end

data/lib/coverband/utils/html_formatter.rb

@@ -18,7 +18,7 @@ module Coverband
       def initialize(report, options = {})
         @notice = options.fetch(:notice) { nil }
         @base_path = options.fetch(:base_path) { nil }
-        @coverage_result = Coverband::Utils::Result.new(report)
+        @coverage_result = Coverband::Utils::Results.new(report) if report
       end
 
       def format!
@@ -29,8 +29,22 @@ module Coverband
         format_html(@coverage_result)
       end
 
+      def format_settings!
+        format_settings
+      end
+
+      def format_source_file!(filename)
+        source_file = @coverage_result.file_from_path_with_type(filename)
+  
+        formatted_source_file(@coverage_result, source_file)
+      end
+
       private
 
+      def format_settings
+        template('settings').result(binding)
+      end
+
       def format(result)
         Dir[File.join(File.dirname(__FILE__), '../../../public/*')].each do |path|
           FileUtils.cp_r(path, asset_output_path)
@@ -56,7 +70,7 @@ 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, 'assets', Coverband::VERSION)
+        @asset_output_path = File.join(output_path)
         FileUtils.mkdir_p(@asset_output_path)
         @asset_output_path
       end
@@ -78,24 +92,47 @@ module Coverband
       end
 
       # Returns the html for the given source_file
-      def formatted_source_file(source_file)
+      def formatted_source_file(result, source_file)
         template('source_file').result(binding)
       rescue Encoding::CompatibilityError => e
-        puts "Encoding problems with file #{source_file.filename}. Coverband/ERB can't handle non ASCII characters in filenames. Error: #{e.message}."
+        puts "Encoding error file:#{source_file.filename} Coverband/ERB error #{e.message}."
+      end
+
+      # Returns the html to ajax load a given source_file
+      def formatted_source_file_loader(result, source_file)
+        template('source_file_loader').result(binding)
+      rescue Encoding::CompatibilityError => e
+        puts "Encoding error file:#{source_file.filename} Coverband/ERB error #{e.message}."
       end
 
       # Returns a table containing the given source files
-      def formatted_file_list(title, 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:
         # "warning: possibly useless use of a variable in void context"
         # The variable is used by ERB via binding.
         title_id = title_id
-        template('file_list').result(binding)
+        options = options
+
+        if title == 'Gems'
+          template('gem_list').result(binding)
+        else
+          template('file_list').result(binding)
+        end
+      end
+
+      def view_gems?
+        Coverband.configuration.track_gems
+      end
+
+      def gem_details?
+        Coverband.configuration.gem_details
       end
 
       def coverage_css_class(covered_percent)
-        if covered_percent > 90
+        if covered_percent.nil?
+          ''
+        elsif covered_percent > 90
           'green'
         elsif covered_percent > 80
           'yellow'
@@ -124,7 +161,12 @@ module Coverband
       end
 
       def shortened_filename(source_file)
-        source_file.filename.sub(Coverband.configuration.root, '.').gsub(/^\.\//, '')
+        source_file.short_name
+      end
+
+      def link_to_gem_list(gem_name)
+        gem_id = gem_name.gsub(/^[^a-zA-Z]+/, '').gsub(/[^a-zA-Z0-9\-\_]/, '')
+        %(<a href="##{gem_id}" class="gem-link" title="#{gem_name}">#{gem_name}</a>)
       end
 
       def link_to_source_file(source_file)

data/lib/coverband/utils/railtie.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+Coverband.eager_loading_coverage!
 module Coverband
   class Railtie < Rails::Railtie
     initializer 'coverband.configure' do |app|
@@ -7,7 +8,14 @@ module Coverband
     end
 
     config.after_initialize do
-      Coverband::Collectors::Coverage.instance.report_coverage(true)
+      Coverband.report_coverage(true)
+      Coverband.configuration.logger&.debug('Coverband: reported after_initialize')
+      Coverband.runtime_coverage!
+    end
+
+    config.before_initialize do
+      Coverband.configuration.logger&.debug('Coverband: set to eager_loading')
+      Coverband.eager_loading_coverage!
     end
 
     rake_tasks do

data/lib/coverband/utils/result.rb

@@ -14,26 +14,29 @@ module Coverband
   module Utils
     class Result
       extend Forwardable
-      # Returns the original Coverage.result used for this instance of SimpleCov::Result
+      # Returns the original Coverage.result used for this instance of Coverband::Result
       attr_reader :original_result
-      # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
+      # Returns all files that are applicable to this result (sans filters!)
+      # as instances of Coverband::SourceFile. Aliased as :source_files
       attr_reader :files
       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 SimpleCov.command_name
+      # 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_delegator :files, :lines_of_code, :total_lines
 
-      # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
+      # Initialize a new Coverband::Result from given Coverage.result (a Hash of filenames each containing an array of
       # coverage data)
       def initialize(original_result)
-        @original_result = original_result.freeze
-        @files = Coverband::Utils::FileList.new(original_result.map do |filename, coverage|
+        @original_result = (original_result || {}).freeze
+
+        @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(&:filename))
+        end.compact.sort_by(&:short_name))
         filter!
       end
 
@@ -42,15 +45,9 @@ module Coverband
         files.map(&:filename)
       end
 
-      # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models'
-      # Coverband doesn't currently support groups
+      # Returns a Hash of groups for this result. Define groups using Coverband.add_group 'Models', 'app/models'
       def groups
-        @groups ||= [] # SimpleCov.grouped(files)
-      end
-
-      # Applies the configured SimpleCov.formatter on this result
-      def format!
-        # SimpleCov.formatter.new.format(self)
+        @groups ||= FileGroups.new(files).grouped_results
       end
 
       # Defines when this result has been created. Defaults to Time.now
@@ -59,9 +56,9 @@ module Coverband
       end
 
       # The command name that launched this result.
-      # Delegated to SimpleCov.command_name if not set manually
+      # Delegated to Coverband.command_name if not set manually
       def command_name
-        @command_name ||= 'SimpleCov.command_name'
+        @command_name ||= 'Coverband'
       end
 
       # Returns a hash representation of this Result that can be used for marshalling it into JSON
@@ -69,7 +66,7 @@ module Coverband
         { command_name => { 'coverage' => coverage, 'timestamp' => created_at.to_i } }
       end
 
-      # Loads a SimpleCov::Result#to_hash dump
+      # Loads a Coverband::Result#to_hash dump
       def self.from_hash(hash)
         command_name, data = hash.first
         result = new(data['coverage'])
@@ -100,7 +97,7 @@ module Coverband
         Hash[keys.zip(original_result.values_at(*keys))]
       end
 
-      # Applies all configured SimpleCov filters on this result's source files
+      # Applies all configured Coverband filters on this result's source files
       def filter!
         @files = files
       end