coverband 2.0.0 → 2.0.3

data/lib/coverband/adapters/redis_store.rb

@@ -7,53 +7,88 @@ module Coverband
 
       def initialize(redis, opts = {})
         @redis = redis
+        @ttl             = opts[:ttl]
+        @redis_namespace = opts[:redis_namespace]
       end
 
       def clear!
-        @redis.smembers(BASE_KEY).each { |key| @redis.del("#{BASE_KEY}.#{key}") }
-        @redis.del(BASE_KEY)
+        @redis.smembers(base_key).each { |key| @redis.del("#{base_key}.#{key}") }
+        @redis.del(base_key)
+      end
+
+      def base_key
+        @base_key ||= [BASE_KEY, @redis_namespace].compact.join('.')
       end
 
       def save_report(report)
-        store_array(BASE_KEY, report.keys)
+        store_array(base_key, report.keys)
 
-        report.each do |file, lines|
-          store_map("#{BASE_KEY}.#{file}", lines)
-        end
+        file_keys = report.keys.map {|file| "#{base_key}.#{file}"}
+        existing_records = existing_records(file_keys)
+        combined_report = combined_report(file_keys, report, existing_records)
+        pipelined_save(combined_report)
       end
 
       def coverage
         data = {}
-        redis.smembers(BASE_KEY).each do |key|
+        redis.smembers(base_key).each do |key|
           data[key] = covered_lines_for_file(key)
         end
         data
       end
 
       def covered_files
-        redis.smembers(BASE_KEY)
+        redis.smembers(base_key)
       end
 
       def covered_lines_for_file(file)
-        @redis.hgetall("#{BASE_KEY}.#{file}")
+        @redis.hgetall("#{base_key}.#{file}")
       end
 
       private
 
       attr_reader :redis
+      
+      def pipelined_save(combined_report)
+        redis.pipelined do
+          combined_report.each do |file, values|
+            existing = values[:existing]
+            new = values[:new]
+            unless values.empty?
+              # in redis all file_keys are strings
+              new_string_values = Hash[new.map {|k, val| [k.to_s, val]}]
+              new_string_values.merge!(existing) {|_k, old_v, new_v| old_v.to_i + new_v.to_i}
+              redis.mapped_hmset(file, new_string_values)
+              redis.expire(file, @ttl) if @ttl
+            end
+          end
+        end
+      end
+
+      def existing_records(file_keys)
+        redis.pipelined do
+          file_keys.each do |key|
+            redis.hgetall(key)
+          end
+        end
+      end
+
+      def combined_report(file_keys, report, existing_records)
+        combined_report = {}
 
-      def store_map(key, values)
-        unless values.empty?
-          existing = redis.hgetall(key)
-          # in redis all keys are strings
-          values = Hash[values.map { |k, val| [k.to_s, val] }]
-          values.merge!(existing) { |_k, old_v, new_v| old_v.to_i + new_v.to_i }
-          redis.mapped_hmset(key, values)
+        file_keys.each_with_index do |key, i|
+          combined_report[key] = {
+            new: report.values[i],
+            existing: existing_records[i]
+          }
         end
+        
+        return combined_report
       end
 
       def store_array(key, values)
         redis.sadd(key, values) unless values.empty?
+        redis.expire(key, @ttl) if @ttl
         values
       end
     end

data/lib/coverband/collectors/base.rb

@@ -87,7 +87,7 @@ module Coverband
       end
 
       def output_file_line_usage
-        @logger.info 'coverband debug coverband file:line usage:'
+        @logger.debug 'coverband debug coverband file:line usage:'
         @file_line_usage.sort_by { |_key, value| value.length }.each do |pair|
           file = pair.first
           lines = pair.last

data/lib/coverband/collectors/coverage.rb

@@ -18,7 +18,7 @@ module Coverband
         end
 
         if failed_recently?
-          @logger.info 'coverage reporting standing-by because of recent failure' if @verbose
+          @logger.error 'coverage reporting standing-by because of recent failure' if @verbose
           return
         end
 
@@ -31,16 +31,16 @@ module Coverband
         end
 
         if @verbose
-          @logger.info "coverband file usage: #{file_usage.inspect}"
+          @logger.debug "coverband file usage: #{file_usage.inspect}"
           output_file_line_usage if @verbose == 'debug'
         end
 
         if @store
-          @store.save_report(@file_line_usage)
+          @store.save_report(files_with_line_usage)
           @file_line_usage.clear
         elsif @verbose
-          @logger.info 'coverage report: '
-          @logger.info @file_line_usage.inspect
+          @logger.debug 'coverage report: '
+          @logger.debug @file_line_usage.inspect
         end
       # StandardError might be better option
       # coverband previously had RuntimeError here
@@ -49,15 +49,22 @@ module Coverband
       rescue StandardError => err
         failed!
         if @verbose
-          @logger.info 'coverage missing'
-          @logger.info "error: #{err.inspect} #{err.message}"
+          @logger.error 'coverage missing'
+          @logger.error "error: #{err.inspect} #{err.message}"
+          @logger.error err.backtrace
         end
       end
 
       private
 
+      def files_with_line_usage
+        @file_line_usage.select do |_file_name, coverage|
+          coverage.values.any? { |value| value != 0 }
+        end
+      end
+
       def array_diff(latest, original)
-        latest.map.with_index { |v, i| v ? v - original[i] : nil }
+        latest.map.with_index { |v, i| (v && original[i]) ? v - original[i] : nil }
       end
 
       def previous_results
@@ -116,6 +123,11 @@ module Coverband
         else
           ::Coverage.start
         end
+        if Coverband.configuration.safe_reload_files
+          Coverband.configuration.safe_reload_files.each do |safe_file|
+            load safe_file
+          end
+        end
         @semaphore = Mutex.new
         @@previous_results = nil
         reset_instance

data/lib/coverband/collectors/trace.rb

@@ -2,8 +2,16 @@
 
 module Coverband
   module Collectors
+    ###
+    # NOTE: While this still works it is slower than Coverage.
+    # I recommend using the Coverage adapter.
+    # As baseline is removed the Trace collector also doesn't have a good way
+    # to collect initial code usage during app boot up.
+    #
+    # I am leaving Trace around as I believe there are some interesting use cases
+    # also, it illustrates an alternative collector, and I have some others I would like to implement
+    ###
     class Trace < Base
-
       def reset_instance
         super
         @tracer_set = false
@@ -21,8 +29,9 @@ module Coverband
       rescue RuntimeError => err
         failed!
         if @verbose
-          @logger.info 'error stating recording coverage'
-          @logger.info "error: #{err.inspect} #{err.message}"
+          @logger.error 'error stating recording coverage'
+          @logger.error "error: #{err.inspect} #{err.message}"
+          @logger.error err.backtrace
         end
       end
 
@@ -39,12 +48,12 @@ module Coverband
         unset_tracer
 
         if failed_recently?
-          @logger.info 'coverage reporting standing-by because of recent failure' if @verbose
+          @logger.error 'coverage reporting standing-by because of recent failure' if @verbose
           return
         end
 
         if @verbose
-          @logger.info "coverband file usage: #{file_usage.inspect}"
+          @logger.debug "coverband file usage: #{file_usage.inspect}"
           output_file_line_usage if @verbose == 'debug'
         end
 
@@ -58,8 +67,9 @@ module Coverband
       rescue RuntimeError => err
         failed!
         if @verbose
-          @logger.info 'coverage missing'
-          @logger.info "error: #{err.inspect} #{err.message}"
+          @logger.error 'coverage missing'
+          @logger.error "error: #{err.inspect} #{err.message}"
+          @logger.error err.backtrace
         end
       end
 

data/lib/coverband/configuration.rb

@@ -5,9 +5,11 @@ module Coverband
     attr_accessor :redis, :root_paths, :root,
                   :ignore, :additional_files, :percentage, :verbose,
                   :reporter, :startup_delay, :memory_caching,
-                  :include_gems, :s3_bucket,
-                  :collector, :disable_on_failure_for
-    attr_writer :logger
+                  :include_gems, :collector, :disable_on_failure_for,
+                  :redis_namespace, :redis_ttl,
+                  :safe_reload_files
+
+    attr_writer :logger, :s3_region, :s3_bucket, :s3_access_key_id, :s3_secret_access_key
 
     def initialize
       @root = Dir.pwd
@@ -29,12 +31,34 @@ module Coverband
       @memory_caching = false
       @store = nil
       @disable_on_failure_for = nil
+      @s3_region = nil
+      @s3_bucket = nil
+      @s3_access_key_id = nil
+      @s3_secret_access_key = nil
+      @redis_namespace = nil
+      @redis_ttl = nil
     end
 
     def logger
       @logger ||= Logger.new(STDOUT)
     end
 
+    def s3_bucket
+      @s3_bucket || ENV['AWS_BUCKET']
+    end
+
+    def s3_region
+      @s3_region || ENV['AWS_REGION']
+    end
+
+    def s3_access_key_id
+      @s3_access_key_id || ENV['AWS_ACCESS_KEY_ID']
+    end
+
+    def s3_secret_access_key
+      @s3_secret_access_key || ENV['AWS_SECRET_ACCESS_KEY']
+    end
+
     def store
       return @store if @store
       raise 'no valid store configured'
@@ -43,10 +67,11 @@ module Coverband
     def store=(store)
       if store.is_a?(Coverband::Adapters::Base)
         @store = store
-      elsif defined?(Redis) && store.is_a?(Redis)
-        @store = Coverband::Adapters::RedisStore.new(redis)
+      elsif defined?(Redis) && redis && redis.is_a?(Redis)
+        @store = Coverband::Adapters::RedisStore.new(redis, ttl: Coverband.configuration.redis_ttl,
+                                                            redis_namespace: Coverband.configuration.redis_namespace)
       elsif store.is_a?(String)
-        @store = Coverband::Adapters::FileStore.new(coverage_file)
+        @store = Coverband::Adapters::FileStore.new(store)
       end
     end
   end

data/lib/coverband/reporters/base.rb

@@ -9,13 +9,13 @@ module Coverband
 
         if Coverband.configuration.verbose
           Coverband.configuration.logger.info "fixing root: #{roots.join(', ')}"
-          Coverband.configuration.logger.info "additional data:\n #{additional_coverage_data}"
+          Coverband.configuration.logger.debug "additional data:\n #{additional_coverage_data}"
         end
 
         scov_style_report = report_scov_with_additional_data(store, additional_coverage_data, roots)
 
         if Coverband.configuration.verbose
-          Coverband.configuration.logger.info "report:\n #{scov_style_report.inspect}"
+          Coverband.configuration.logger.debug "report:\n #{scov_style_report.inspect}"
         end
         scov_style_report
       end

data/lib/coverband/reporters/simple_cov_report.rb

@@ -38,7 +38,12 @@ module Coverband
           Coverband.configuration.logger.info "report is ready and viewable: open #{SimpleCov.coverage_dir}/index.html"
         end
 
-        S3ReportWriter.new(Coverband.configuration.s3_bucket).persist! if Coverband.configuration.s3_bucket
+        s3_writer_options = {
+          region: Coverband.configuration.s3_region,
+          access_key_id: Coverband.configuration.s3_access_key_id,
+          secret_access_key: Coverband.configuration.s3_secret_access_key
+        }
+        S3ReportWriter.new(Coverband.configuration.s3_bucket, s3_writer_options).persist! if Coverband.configuration.s3_bucket
       end
     end
   end

data/lib/coverband/reporters/web.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+module Coverband
+  module Reporters
+    # TODO: move to reports and drop need for S3 allow reading from adapters?
+    class Web
+      attr_reader :request
+
+      def initialize
+        @static = Rack::Static.new(self,
+          root: File.expand_path('public', Gem::Specification.find_by_name('simplecov-html').full_gem_path),
+          urls: [/.*\.css/, /.*\.js/, /.*\.gif/, /.*\.png/]
+        )
+      end
+
+      def call(env)
+        @request = Rack::Request.new(env)
+
+        if request.post?
+          case request.path_info
+          when /\/collect_update_and_view/
+            collect_update_and_view
+          when /\/clear/
+            clear
+          when /\/update_report/
+            update_report
+          when /\/collect_coverage/
+            collect_coverage
+          when /\/reload_files/
+            reload_files
+          else
+            [404, {'Content-Type' => 'text/html'}, ['404 error!']]
+          end
+        else
+          case request.path_info
+          when /.*\.(css|js|gif|png)/
+            @static.call(env)
+          when /\/show/
+            [200, {'Content-Type' => 'text/html'}, [show]]
+          when /\//
+            [200, {'Content-Type' => 'text/html'}, [index]]
+          else
+            [404, {'Content-Type' => 'text/html'}, ['404 error!']]
+          end
+        end
+      end
+
+      # todo move to file or template
+      def index
+        html = "<html>"
+        html += "<strong>Notice:</strong> #{Rack::Utils.escape_html(request.params['notice'])}<br/>" if request.params['notice']
+        html += "<ul>"
+        html += "<li><a href='#{base_path}'>Coverband Web Admin Index</a></li>"
+        html += "<li>#{button("#{base_path}collect_update_and_view",'collect data, update report, & view')}</li>"
+        html += "<li><a href='#{base_path}show'>view coverage report</a></li>"
+        html += "<li>#{button("#{base_path}collect_coverage",'update coverage data (collect coverage)')}</li>"
+        html += "<li>#{button("#{base_path}update_report",'update coverage report (rebuild report)')}</li>"
+        html += "<li>#{button("#{base_path}clear",'clear coverage report')}</li>"
+        html += "<li>#{button("#{base_path}reload_files",'reload Coverband files')}</li>"
+        html += "</ul>"
+        html += "<br/>"
+        html += "version: #{Coverband::VERSION}<br/>"
+        html += "<a href='https://github.com/danmayer/coverband'>Coverband</a>"
+        html += "</html>"
+        html
+      end
+
+      def show
+        html = s3.get_object(bucket: Coverband.configuration.s3_bucket, key: 'coverband/index.html').body.read
+        # hack the static HTML assets to link to the path where this was mounted
+        html = html.gsub("src='", "src='#{base_path}")
+        html = html.gsub("href='", "href='#{base_path}")
+        html = html.gsub("loading.gif", "#{base_path}loading.gif")
+        html = html.gsub("/images/", "#{base_path}images/")
+        html
+      end
+
+      def collect_update_and_view
+        collect_coverage
+        update_report
+        [301, { 'Location' => "#{base_path}show" }, []]
+      end
+
+      def update_report
+        Coverband::Reporters::SimpleCovReport.report(Coverband.configuration.store, open_report: false)
+        notice = 'coverband coverage updated'
+        [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
+      end
+
+      def collect_coverage
+        Coverband::Collectors::Base.instance.report_coverage
+        notice = 'coverband coverage collected'
+        [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
+      end
+
+      def clear
+        Coverband.configuration.store.clear!
+        notice = 'coverband coverage cleared'
+        [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
+      end
+
+      def reload_files
+        if Coverband.configuration.safe_reload_files
+          Coverband.configuration.safe_reload_files.each do |safe_file|
+            load safe_file
+          end
+        end
+        # force reload
+        Coverband.configure
+        notice = 'coverband files reloaded'
+        [301, { 'Location' => "#{base_path}?notice=#{notice}" }, []]
+      end
+
+      private
+
+      def button(url, title)
+        button = "<form action='#{url}' method='post'>"
+        button += "<button type='submit'>#{title}</button>"
+        button + '</form>'
+      end
+
+      # This method should get the root mounted endpoint
+      # for example if the app is mounted like so:
+      # mount Coverband::S3Web, at: '/coverage'
+      # "/coverage/collect_coverage?" become:
+      # /coverage/
+      def base_path
+        request.path.match("\/.*\/") ? request.path.match("\/.*\/")[0] : '/'
+      end
+
+      def s3
+        begin
+          require 'aws-sdk'
+        rescue StandardError
+          Coverband.configuration.logger.error "coverband requires 'aws-sdk' in order use S3ReportWriter."
+          return
+        end
+        @s3 ||= begin
+          client_options = {
+            region: Coverband.configuration.s3_region,
+            access_key_id: Coverband.configuration.s3_access_key_id,
+            secret_access_key: Coverband.configuration.s3_secret_access_key
+          }
+          client_options = {} if client_options.values.any?(&:nil?)
+          Aws::S3::Client.new(client_options)
+        end
+      end
+    end
+  end
+end

data/lib/coverband/s3_report_writer.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+# possibly move to / make an adapter or more likely a reporter
 class S3ReportWriter
-  def initialize(bucket_name)
+  def initialize(bucket_name, options = {})
     @bucket_name = bucket_name
+    @region = options[:region]
+    @access_key_id = options[:access_key_id]
+    @secret_access_key = options[:secret_access_key]
     begin
       require 'aws-sdk'
     rescue StandardError
@@ -29,7 +33,14 @@ class S3ReportWriter
   end
 
   def s3
-    Aws::S3::Resource.new
+    client_options = {
+      region: @region,
+      access_key_id: @access_key_id,
+      secret_access_key: @secret_access_key
+    }
+    resource_options = { client: Aws::S3::Client.new(client_options) }
+    resource_options = {} if client_options.values.any?(&:nil?)
+    Aws::S3::Resource.new(resource_options)
   end
 
   def bucket

data/lib/coverband/tasks.rb

@@ -1,52 +1,6 @@
 # frozen_string_literal: true
 
 namespace :coverband do
-  def safely_import_files(files_to_cover)
-    if files_to_cover.any?
-      files = Coverband::Baseline.exclude_files(files_to_cover)
-      files.each do |file|
-        begin
-          require_dependency file
-        rescue Exception => err
-          if Coverband.configuration.verbose
-            Coverband.configuration.logger.info "error adding file to baseline: #{file}"
-            Coverband.configuration.logger.info "error: #{err}"
-          end
-        end
-      end
-    end
-  end
-
-  desc 'record coverband coverage baseline'
-  task :baseline do
-    Coverband::Baseline.record do
-      if Rake::Task.tasks.any? { |key| key.to_s.match(/environment$/) }
-        Coverband.configuration.logger.info 'invoking rake environment'
-        Rake::Task['environment'].invoke
-      elsif Rake::Task.tasks.any? { |key| key.to_s.match(/env$/) }
-        Coverband.configuration.logger.info 'invoking rake env'
-        Rake::Task['env'].invoke
-      end
-
-      baseline_files = [File.expand_path('./config/boot.rb', Dir.pwd),
-                        File.expand_path('./config/application.rb', Dir.pwd),
-                        File.expand_path('./config/environment.rb', Dir.pwd)]
-
-      baseline_files.each do |baseline_file|
-        require baseline_file if File.exist?(baseline_file)
-      end
-
-      safely_import_files(Coverband.configuration.additional_files.flatten)
-
-      if defined? Rails
-        safely_import_files(Dir.glob("#{Rails.root}/app/**/*.rb"))
-        if File.exist?("#{Rails.root}/lib")
-          safely_import_files(Dir.glob("#{Rails.root}/lib/**/*.rb"))
-        end
-      end
-    end
-  end
-
   ###
   # note: If your project has set many simplecov filters.
   # You might want to override them and clear the filters.

data/lib/coverband/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coverband
-  VERSION = '2.0.0'
+  VERSION = '2.0.3'
 end

data/lib/coverband.rb

@@ -12,10 +12,10 @@ require 'coverband/adapters/file_store'
 require 'coverband/collectors/base'
 require 'coverband/collectors/trace'
 require 'coverband/collectors/coverage'
-require 'coverband/baseline'
 require 'coverband/reporters/base'
 require 'coverband/reporters/simple_cov_report'
 require 'coverband/reporters/console_report'
+require 'coverband/reporters/web'
 require 'coverband/middleware'
 require 'coverband/s3_report_writer'
 
@@ -27,14 +27,15 @@ module Coverband
   end
 
   def self.configure(file = nil)
+    configuration_file = file || CONFIG_FILE
+
     configuration
     if block_given?
       yield(configuration)
-    elsif File.exist?(CONFIG_FILE)
-      file ||= CONFIG_FILE
-      require file
+    elsif File.exist?(configuration_file)
+      require configuration_file
     else
-      raise ArgumentError, "configure requires a block or the existance of a #{CONFIG_FILE} in your project"
+      raise ArgumentError, "configure requires a block, the existance of a #{CONFIG_FILE} in your project, or a path to a config file passed in to configure"
     end
   end