coverband 4.2.0 → 4.2.4

data/lib/coverband/utils/railtie.rb

@@ -1,21 +1,39 @@
 # 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
+      begin
+        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
+      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
     end
 
-    config.before_initialize do
-      Coverband.configuration.logger&.debug('Coverband: set to eager_loading')
-      Coverband.eager_loading_coverage!
+    config.after_initialize do
+      unless Coverband.tasks_to_ignore?
+        Coverband.eager_loading_coverage!
+        Coverband.report_coverage
+        Coverband.runtime_coverage!
+      end
     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,52 +51,23 @@ module Coverband
         @created_at ||= Time.now
       end
 
-      # The command name that launched this result.
-      # Delegated to Coverband.command_name if not set manually
-      def command_name
-        @command_name ||= 'Coverband'
-      end
-
-      # Returns a hash representation of this Result that can be used for marshalling it into JSON
-      def to_hash
-        { command_name => { 'coverage' => coverage, 'timestamp' => created_at.to_i } }
-      end
-
-      # Loads a Coverband::Result#to_hash dump
-      def self.from_hash(hash)
-        command_name, data = hash.first
-        result = new(data['coverage'])
-        result.command_name = command_name
-        result.created_at = Time.at(data['timestamp'])
-        result
-      end
-
       # Finds files that were to be tracked but were not loaded and initializes
       # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc).
       def self.add_not_loaded_files(result, tracked_files)
         if tracked_files
+          # TODO: Can we get rid of this dup it wastes memory
           result = result.dup
           Dir[tracked_files].each do |file|
             absolute = File.expand_path(file)
-
-            result[absolute] ||= Coverband::Utils::LinesClassifier.new.classify(File.foreach(absolute))
+            result[absolute] ||= {
+              'data' => Array.new(File.foreach(absolute).count) { 0 },
+              'never_loaded' => true
+            }
           end
         end
 
         result
       end
-
-      private
-
-      def coverage
-        keys = original_result.keys & filenames
-        Hash[keys.zip(original_result.values_at(*keys))]
-      end
-
-      # Applies all configured Coverband filters on this result's source files
-      def filter!
-        @files = files
-      end
     end
   end
 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,9 +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
-          return
+          err_msg = 'Coverband requires aws-sdk in order use S3Report.'
+          Coverband.configuration.logger&.error err_msg
         end
       end
 

data/lib/coverband/utils/source_file.rb

@@ -10,7 +10,7 @@
 module Coverband
   module Utils
     class SourceFile
-      include Coverband::Utils::FilePathHelper
+      # TODO: Refactor Line into its own file
       # Representation of a single line in a source file including
       # this specific line's source code, line_number and code coverage,
       # with the coverage being either nil (coverage not applicable, e.g. comment
@@ -35,6 +35,7 @@ module Coverband
           raise ArgumentError, 'Only String accepted for source' unless src.is_a?(String)
           raise ArgumentError, 'Only Integer accepted for line_number' unless line_number.is_a?(Integer)
           raise ArgumentError, 'Only Integer and nil accepted for coverage' unless coverage.is_a?(Integer) || coverage.nil?
+
           @src         = src
           @line_number = line_number
           @coverage    = coverage
@@ -48,7 +49,7 @@ module Coverband
 
         # Returns true if this is a line that has been covered
         def covered?
-          !never? && !skipped? && coverage > 0
+          !never? && !skipped? && coverage.positive?
         end
 
         # Returns true if this line is not relevant for coverage
@@ -64,7 +65,7 @@ module Coverband
         # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
         # # :nocov: comment lines.
         def skipped?
-          !!skipped
+          skipped
         end
 
         # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use
@@ -86,22 +87,34 @@ module Coverband
       attr_reader :first_updated_at
       # the date this version of the file last saw any coverage activity
       attr_reader :last_updated_at
+      # meta data that the file was never loaded during boot or runtime
+      attr_reader :never_loaded
       NOT_AVAILABLE = 'not available'
 
       def initialize(filename, file_data)
         @filename = filename
+        @runtime_relavant_lines = nil
         if file_data.is_a?(Hash)
           @coverage = file_data['data']
           @first_updated_at = @last_updated_at = NOT_AVAILABLE
           @first_updated_at = Time.at(file_data['first_updated_at']) if file_data['first_updated_at']
           @last_updated_at =  Time.at(file_data['last_updated_at']) if file_data['last_updated_at']
+          @never_loaded = file_data['never_loaded'] || false
         else
+          # TODO: Deprecate this code path this was backwards compatability from 3-4
           @coverage = file_data
           @first_updated_at = NOT_AVAILABLE
           @last_updated_at = NOT_AVAILABLE
         end
       end
 
+      def runtime_relavant_calculations(runtime_relavant_lines)
+        @runtime_relavant_lines = runtime_relavant_lines
+        yield self
+      ensure
+        @runtime_relavant_lines = nil
+      end
+
       # The path to this source file relative to the projects directory
       def project_filename
         @filename.sub(/^#{Coverband.configuration.root}/, '')
@@ -148,7 +161,12 @@ module Coverband
 
         return 0.0 if relevant_lines.zero?
 
-        Float(covered_lines.size * 100.0 / relevant_lines.to_f)
+        # handle edge case where runtime in dev can go over 100%
+        [Float(covered_lines.size * 100.0 / relevant_lines.to_f), 100.0].min
+      end
+
+      def formatted_covered_percent
+        covered_percent&.round(2)
       end
 
       def covered_strength
@@ -166,7 +184,7 @@ module Coverband
       end
 
       def relevant_lines
-        lines.size - never_lines.size - skipped_lines.size
+        @runtime_relavant_lines || (lines.size - never_lines.size - skipped_lines.size)
       end
 
       # Returns all covered lines as SimpleCov::SourceFile::Line
@@ -174,6 +192,14 @@ module Coverband
         @covered_lines ||= lines.select(&:covered?)
       end
 
+      def covered_lines_count
+        covered_lines&.count
+      end
+
+      def line_coverage(index)
+        lines[index]&.coverage
+      end
+
       # Returns all lines that should have been, but were not covered
       # as instances of SimpleCov::SourceFile::Line
       def missed_lines
@@ -216,12 +242,12 @@ module Coverband
       # I had previously patched this in my local Rails app
       def short_name
         filename.sub(/^#{Coverband.configuration.root}/, '.')
-                .sub(%r{^.*\/gems}, '.')
+                .sub(%r{^.*\/gems\/}, '.')
                 .gsub(%r{^\.\/}, '')
       end
 
       def relative_path
-        full_path_to_relative(filename)
+        RelativeFileConverter.convert(filename)
       end
 
       def gem?
@@ -229,7 +255,7 @@ module Coverband
       end
 
       def gem_name
-        gem? ? short_name.split('/').first : nil
+        gem? ? short_name.split('/').first.gsub(%r{^\.}, '') : nil
       end
 
       private

data/lib/coverband/utils/tasks.rb

@@ -1,37 +1,37 @@
 # frozen_string_literal: true
 
 namespace :coverband do
-  Coverband.configure
-
-  def environment
-    Rake.application['environment'].invoke if Rake::Task.task_defined?('environment')
-  end
+  # handles configuring in require => false and COVERBAND_DISABLE_AUTO_START cases
+  Coverband.configure unless Coverband.configured?
 
   desc 'report runtime Coverband code coverage'
   task :coverage do
-    environment
     if Coverband.configuration.reporter == 'scov'
-      Coverband::Reporters::HTMLReport.report(Coverband.configuration.store)
+      Coverband::Reporters::HTMLReport.new(Coverband.configuration.store).report
     else
       Coverband::Reporters::ConsoleReport.report(Coverband.configuration.store)
     end
   end
 
+  desc 'report runtime Coverband code coverage'
+  task :coverage_server do
+    Rake.application['environment'].invoke if Rake::Task.task_defined?('environment')
+    Rack::Server.start app: Coverband::Reporters::Web.new, Port: ENV.fetch('COVERBAND_COVERAGE_PORT', 1022).to_i
+  end
+
   ###
   # clear data helpful for development or after configuration issues
   ###
   desc 'reset Coverband coverage data, helpful for development, debugging, etc'
   task :clear do
-    environment
     Coverband.configuration.store.clear!
   end
 
   ###
-  # clear data helpful for development or after configuration issues
+  # Updates the data in the coverband store from one format to another
   ###
   desc 'upgrade previous Coverband datastore to latest format'
   task :migrate do
-    environment
     Coverband.configuration.store.migrate!
   end
 end

data/lib/coverband/version.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+###
+# ensure we properly do release candidate versioning; https://github.com/danmayer/coverband/issues/288
+# 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 = '4.2.0'
+  VERSION = '4.2.4'
 end

data/lib/coverband.rb

@@ -6,10 +6,13 @@ require 'redis'
 require 'coverband/version'
 require 'coverband/at_exit'
 require 'coverband/configuration'
-require 'coverband/utils/file_path_helper'
+require 'coverband/utils/relative_file_converter'
+require 'coverband/utils/absolute_file_converter'
 require 'coverband/adapters/base'
 require 'coverband/adapters/redis_store'
+require 'coverband/adapters/hash_redis_store'
 require 'coverband/adapters/file_store'
+require 'coverband/utils/file_hasher'
 require 'coverband/utils/s3_report'
 require 'coverband/utils/html_formatter'
 require 'coverband/utils/result'
@@ -20,27 +23,26 @@ require 'coverband/utils/file_groups'
 require 'coverband/utils/lines_classifier'
 require 'coverband/utils/results'
 require 'coverband/collectors/coverage'
+require 'coverband/collectors/view_tracker'
 require 'coverband/reporters/base'
 require 'coverband/reporters/html_report'
 require 'coverband/reporters/console_report'
-require 'coverband/integrations/background'
-require 'coverband/integrations/rack_server_check'
 require 'coverband/reporters/web'
-require 'coverband/integrations/middleware'
 require 'coverband/integrations/background'
+require 'coverband/integrations/background_middleware'
+require 'coverband/integrations/rack_server_check'
+
+Coverband::Adapters::RedisStore = Coverband::Adapters::HashRedisStore if ENV['COVERBAND_HASH_REDIS_STORE']
 
 module Coverband
+  @@configured = false
   CONFIG_FILE = './config/coverband.rb'
-  RUNTIME_TYPE = nil
+  RUNTIME_TYPE = :runtime
   EAGER_TYPE = :eager_loading
   MERGED_TYPE = :merged
   TYPES = [RUNTIME_TYPE, EAGER_TYPE]
   ALL_TYPES = TYPES + [:merged]
 
-  class << self
-    attr_accessor :configuration_data
-  end
-
   def self.configure(file = nil)
     configuration_file = file || ENV.fetch('COVERBAND_CONFIG', CONFIG_FILE)
     configuration
@@ -49,45 +51,65 @@ module Coverband
     elsif File.exist?(configuration_file)
       load configuration_file
     else
-      configuration.logger&.debug('using default configuration')
+      configuration.logger.debug('using default configuration')
     end
-    coverage.reset_instance
+    @@configured = true
+    coverage_instance.reset_instance
+  end
+
+  def self.configured?
+    @@configured
   end
 
-  def self.report_coverage(force_report = false)
-    Coverband::Collectors::Coverage.instance.report_coverage(force_report)
+  def self.report_coverage
+    coverage_instance.report_coverage
   end
 
   def self.configuration
-    self.configuration_data ||= Configuration.new
+    @configuration ||= Configuration.new
   end
 
   def self.start
     Coverband::Collectors::Coverage.instance
-    # TODO Railtie sets up at_exit after forks, via middleware, perhaps this hsould be
+    # TODO: Railtie sets up at_exit after forks, via middleware, perhaps this should be
     # added if not rails or if rails but not rackserverrunning
-    AtExit.register
-    Background.start if configuration.background_reporting_enabled && !RackServerCheck.running?
+    AtExit.register unless tasks_to_ignore?
+    Background.start if configuration.background_reporting_enabled && !RackServerCheck.running? && !tasks_to_ignore?
+  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) })
   end
 
   def self.eager_loading_coverage!
-    coverage.eager_loading!
+    coverage_instance.eager_loading!
+  end
+
+  def self.eager_loading_coverage(&block)
+    coverage_instance.eager_loading(&block)
   end
 
   def self.runtime_coverage!
-    coverage.runtime!
+    coverage_instance.runtime!
   end
 
-  def self.coverage
+  private_class_method def self.coverage_instance
     Coverband::Collectors::Coverage.instance
   end
-
   unless ENV['COVERBAND_DISABLE_AUTO_START']
-    # Coverband should be setup as early as possible
-    # to capture usage of things loaded by initializers or other Rails engines
-    configure
-    start
-    require 'coverband/utils/railtie' if defined? ::Rails::Railtie
-    require 'coverband/integrations/resque' if defined? Resque
+    begin
+      # Coverband should be setup as early as possible
+      # to capture usage of things loaded by initializers or other Rails engines
+      configure
+      start
+      require 'coverband/utils/railtie' if defined? ::Rails::Railtie
+      require 'coverband/integrations/resque' if defined? ::Resque
+      require 'coverband/integrations/bundler' if defined? ::Bundler
+    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
   end
 end

data/lua/install.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+LUA_DIR="$HOME/lua51"
+LUA="$LUA_DIR/bin/lua"
+
+if [ ! -f $LUA ]; then
+  echo "Installing lua"
+  pip install hererocks
+  hererocks $LUA_DIR -l5.1 -rlatest
+fi
+source $LUA_DIR/bin/activate
+lua -v
+for i in luacov busted redis-lua inspect lua-cjson; do 
+  luarocks install $i;
+done

data/lua/lib/persist-coverage.lua

@@ -0,0 +1,28 @@
+local hmset = function (key, dict)
+  if next(dict) == nil then return nil end
+  local bulk = {}
+  for k, v in pairs(dict) do
+    table.insert(bulk, k)
+    table.insert(bulk, v)
+  end
+  return redis.call('HMSET', key, unpack(bulk))
+end
+local payload = cjson.decode(redis.call('get', (KEYS[1])))
+local ttl = payload.ttl
+local files_data = payload.files_data
+redis.call('DEL', KEYS[1])
+for _, file_data in ipairs(files_data) do
+
+  local hash_key = file_data.hash_key
+  local first_updated_at = file_data.meta.first_updated_at
+  file_data.meta.first_updated_at = nil
+
+  hmset(hash_key, file_data.meta)
+  redis.call('HSETNX', hash_key, 'first_updated_at', first_updated_at)
+  for line, coverage in pairs(file_data.coverage) do
+    redis.call("HINCRBY", hash_key, line, coverage)
+  end
+  if ttl and ttl ~= cjson.null then
+    redis.call("EXPIRE", hash_key, ttl)
+  end
+end

data/lua/test/bootstrap.lua

@@ -0,0 +1,5 @@
+inspect = require "inspect"
+cjson = require 'cjson'
+require './lua/test/redis-call'
+
+

data/lua/test/harness.lua

@@ -0,0 +1,19 @@
+require './lua/test/bootstrap'
+
+
+KEYS = {}
+ARGV = {}
+
+
+function call_redis_script(script, keys, argv)
+  -- This may not be strictly necessary
+  for k,v in pairs(ARGV) do ARGV[k] = nil end
+  for k,v in pairs(KEYS) do KEYS[k] = nil end
+
+  for k,v in pairs(keys) do table.insert(KEYS, v) end
+  for k,v in pairs(argv) do table.insert(ARGV, v)  end
+
+  return dofile('./lua/lib/' .. script)
+end
+
+return call_redis_script;