cover_rage 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb5a49ec54d2f39963fa0704561b1d49f27fd04b4070b760ad1a0dd361eaa2e4
+  data.tar.gz: 926ef7443cf1efecfe908d9d6e2a74799b1cf5ddf260d16f03ddc9cd6c821ada
+SHA512:
+  metadata.gz: 9ada124a26bd41c144f54391c5d424f396a1f260e2c2210d4d971c0905ff04578d3bd346d33115b5de1168e8476a869fb8710ab3f3b0b1201c01fcfaf5629bb9
+  data.tar.gz: 0264676faf4d418cc51b27560fa3645b6a7d806aae8ac22aed6b835463d3318bc42083b6ca00766378bcbc8948276ac9d5a49c9412c1a855d1881aeb572a9bda

data/bin/config.ru

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'cover_rage/viewer'
+require 'cover_rage/config'
+run CoverRage::Viewer.new(store: CoverRage::Config.store)

data/bin/cover_rage

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rackup'
+Dir.chdir(__dir__) { Rackup::Server.start }

data/lib/cover_rage/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'uri'
+module CoverRage
+  module Config
+    def self.root_path
+      @root_path ||= ENV.fetch('COVER_RAGE_ROOT_PATH', defined?(Rails) && Rails.root ? Rails.root.to_s : Dir.pwd)
+    end
+
+    def self.store
+      @store ||= begin
+        uri = URI.parse(ENV.fetch('COVER_RAGE_STORE_URL'))
+        case uri.scheme
+        when 'redis'
+          require 'cover_rage/stores/redis'
+          CoverRage::Stores::Redis.new(uri.to_s)
+        when 'sqlite'
+          require 'cover_rage/stores/sqlite'
+          CoverRage::Stores::Sqlite.new(uri.path)
+        end
+      end
+    end
+
+    def self.sleep_duration
+      @sleep_duration ||= begin
+        args =
+          ENV.fetch('COVER_RAGE_SLEEP_DURATION', '60:90').split(':').map!(&:to_i).first(2)
+        args.push(args.first.succ) if args.length < 2
+        Range.new(*args, true)
+      end
+    end
+  end
+end

data/lib/cover_rage/fork_hook.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CoverRage
+  module ForkHook
+    def _fork
+      pid = super
+      CoverRage::Launcher.start if pid.zero?
+      pid
+    end
+  end
+end

data/lib/cover_rage/launcher.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'cover_rage/recorder'
+require 'cover_rage/config'
+require 'cover_rage/fork_hook'
+require 'coverage'
+
+module CoverRage
+  class Launcher
+    def self.start(**kwargs)
+      if @recorder.nil?
+        @recorder = CoverRage::Recorder.new(
+          store: CoverRage::Config.store,
+          root_path: CoverRage::Config.root_path,
+          **kwargs
+        )
+      end
+      @recorder.start
+      return unless Process.respond_to?(:_fork)
+      return if Process.singleton_class < CoverRage::ForkHook
+
+      Process.singleton_class.prepend(CoverRage::ForkHook)
+    end
+  end
+end

data/lib/cover_rage/record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CoverRage
+  Record = Data.define(:path, :revision, :source, :execution_count) do
+    def self.merge(existing, current)
+      records_to_save = []
+      current.each do |record|
+        found = existing.find { _1.path == record.path }
+        records_to_save <<
+          if found.nil? || record.revision != found.revision
+            record
+          else
+            record + found
+          end
+      end
+      records_to_save
+    end
+
+    def +(other)
+      with(
+        execution_count: execution_count.map.with_index do |item, index|
+          item.nil? ? nil : item + other.execution_count[index]
+        end
+      )
+    end
+  end
+end

data/lib/cover_rage/recorder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'cover_rage/config'
+require 'cover_rage/record'
+require 'digest'
+
+module CoverRage
+  class Recorder
+    SLEEP_DURATION = Config.sleep_duration
+    COVERAGE_STOP_STATES = %i[idle suspended].freeze
+    attr_reader :store
+
+    def initialize(root_path:, store:)
+      @store = store
+      @root_path = root_path.end_with?('/') ? root_path : "#{root_path}/"
+      @digest = Digest::MD5.new
+      @file_cache = {}
+    end
+
+    def start
+      return if @thread&.alive?
+
+      Coverage.start if COVERAGE_STOP_STATES.include?(Coverage.state)
+      @thread = Thread.new do
+        loop do
+          sleep(rand(SLEEP_DURATION))
+          save(Coverage.result(stop: false, clear: true))
+        end
+      ensure
+        save(Coverage.result)
+      end
+    end
+
+    private
+
+    def save(coverage_result)
+      records = []
+      coverage_result.map do |filepath, execution_count|
+        filepath = File.expand_path(filepath) unless filepath.start_with?('/')
+        next unless filepath.start_with?(@root_path)
+        next if execution_count.all? { _1.nil? || _1.zero? }
+
+        relative_path = filepath.delete_prefix(@root_path)
+        revision, source = read_file_with_revision(filepath)
+
+        records << Record.new(
+          path: relative_path,
+          revision: revision,
+          source: source,
+          execution_count: execution_count
+        )
+      end
+      @store.import(records) if records.any?
+    end
+
+    def read_file_with_revision(path)
+      return @file_cache[path] if @file_cache.key?(path)
+
+      @file_cache[path] = begin
+        content = File.read(path)
+        [@digest.hexdigest(content), content]
+      end
+    end
+  end
+end

data/lib/cover_rage/stores/redis.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'redis'
+require 'json'
+
+module CoverRage
+  module Stores
+    class Redis
+      KEY = 'cover_rage_records'
+      def initialize(url)
+        @redis = ::Redis.new(url: url)
+      end
+
+      def import(records)
+        loop do
+          break if @redis.watch(KEY) do
+            records_to_save = Record.merge(list, records)
+            if records_to_save.any?
+              arguments = []
+              records_to_save.each do |record|
+                arguments.push(record.path, JSON.dump(record.to_h))
+              end
+              @redis.multi { _1.hset(KEY, *arguments) }
+            end
+          end
+        end
+      end
+
+      def find(path)
+        result = @redis.hget(KEY, path)
+        return nil if result.nil?
+
+        Record.new(**JSON.parse(result))
+      end
+
+      def list
+        result = @redis.hgetall(KEY)
+        return [] if result.empty?
+
+        result.map { |_, value| Record.new(**JSON.parse(value)) }
+      end
+
+      def clear
+        @redis.del(KEY)
+      end
+    end
+  end
+end

data/lib/cover_rage/stores/sqlite.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'cover_rage/record'
+require 'sqlite3'
+require 'json'
+
+module CoverRage
+  module Stores
+    class Sqlite
+      def initialize(path)
+        @db = SQLite3::Database.new(path)
+        @db.execute <<-SQL
+          create table if not exists records (
+            path text primary key not null,
+            revision blob not null,
+            source text not null,
+            execution_count text not null
+          )
+        SQL
+      end
+
+      def import(records)
+        @db.transaction do
+          records_to_save = Record.merge(list, records)
+          if records_to_save.any?
+            @db.execute(
+              "insert or replace into records (path, revision, source, execution_count) values #{
+                (['(?,?,?,?)'] * records_to_save.length).join(',')
+              }",
+              records_to_save.each_with_object([]) do |record, memo|
+                memo.push(
+                  record.path,
+                  record.revision,
+                  record.source,
+                  JSON.dump(record.execution_count)
+                )
+              end
+            )
+          end
+        end
+      end
+
+      def find(path)
+        rows = @db.execute(
+          'select revision, source, execution_count from records where path = ? limit 1',
+          [path]
+        )
+        return nil if rows.empty?
+
+        revision, source, execution_count = rows.first
+        Record.new(
+          path: path,
+          revision: revision,
+          source: source,
+          execution_count: JSON.parse(execution_count)
+        )
+      end
+
+      def list
+        @db
+          .execute('select path, revision, source, execution_count from records')
+          .map! do |(path, revision, source, execution_count)|
+            Record.new(
+              path: path,
+              revision: revision,
+              source: source,
+              execution_count: JSON.parse(execution_count)
+            )
+          end
+      end
+
+      def clear
+        @db.execute('delete from records')
+      end
+    end
+  end
+end

data/lib/cover_rage/viewer/file.erb

@@ -0,0 +1,51 @@
+<link
+  rel="stylesheet"
+  href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/styles/default.min.css"
+/>
+<style>
+  .line {
+    width: 100%;
+    display: inline-block;
+    counter-increment: line_number;
+  }
+
+  .green {
+    background-color: rgb(221, 255, 221);
+  }
+
+  .red {
+    background-color: rgb(255, 212, 212);
+  }
+
+  .number {
+    display: inline-block;
+    text-align: right;
+    margin-right: 0.5em;
+    background-color: lightgray;
+    padding: 0 0.5em 0 1.5em;
+  }
+</style>
+<h1><%= path %></h1>
+<pre><code id="code"><%= source_code.encode(xml: :text) %></code></pre>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/highlight.min.js"></script>
+<script id="execution_count" type="application/json"><%= execution_count.encode(xml: :text) %></script>
+<script>
+  const execution_count = JSON.parse(
+    document.querySelector("#execution_count").childNodes[0].nodeValue
+  );
+  const digit_width = Math.floor(Math.log10(Math.max(...execution_count))) + 1;
+  const $code = document.querySelector("#code");
+  $code.innerHTML = hljs
+    .highlight($code.textContent, {
+      language: "ruby",
+    })
+    .value.split("\n")
+    .map((line, index) => {
+      const value = execution_count[index];
+      let color = "";
+      if (typeof value === "number") color = value > 0 ? "green" : "red";
+      const number = typeof value === "number" ? value : "-";
+      return `<span class="line ${color}"><span class="number">${number.toString().padStart(digit_width, ' ')}</span>${line}</span>`;
+    })
+    .join("\n");
+</script>

data/lib/cover_rage/viewer/index.erb

@@ -0,0 +1,28 @@
+<table>
+  <thead>
+    <tr>
+      <th>path</th>
+      <th>lines</th>
+      <th>relevancy</th>
+      <th>hit</th>
+      <th>miss</th>
+      <th>coverage (%)</th>
+    </tr>
+  </thead>
+  <tbody>
+    <% items.each do |item| %>
+    <tr>
+      <td>
+        <a href="/file?path=<%= URI.encode_uri_component(item.path) %>"
+          ><%= item.path %></a
+        >
+      </td>
+      <td style="text-align: right"><%= item.number_of_lines %></td>
+      <td style="text-align: right"><%= item.number_of_relevancies %></td>
+      <td style="text-align: right"><%= item.number_of_hits %></td>
+      <td style="text-align: right"><%= item.number_of_misses %></td>
+      <td style="text-align: right"><%= '%.2f' % (item.coverage * 100) %></td>
+    </tr>
+    <% end %>
+  </tbody>
+</table>

data/lib/cover_rage/viewer/layout.erb

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>CoverRage</title>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/lib/cover_rage/viewer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'cover_rage/record'
+require 'erb'
+require 'json'
+
+module CoverRage
+  class Viewer
+    LAYOUT_PAGE = ERB.new(File.read("#{__dir__}/viewer/layout.erb"))
+    INDEX_PAGE = ERB.new(File.read("#{__dir__}/viewer/index.erb"))
+    FILE_PAGE = ERB.new(File.read("#{__dir__}/viewer/file.erb"))
+
+    class Item
+      attr_reader(
+        :path,
+        :execution_count,
+        :number_of_lines,
+        :number_of_hits,
+        :number_of_misses,
+        :number_of_relevancies,
+        :coverage
+      )
+
+      def initialize(record)
+        @path = record.path
+        @execution_count = record.execution_count
+        @number_of_lines = record.execution_count.length
+        @number_of_hits = record.execution_count.count { _1&.positive? }
+        @number_of_misses = record.execution_count.count { _1&.zero? }
+        @number_of_relevancies = record.execution_count.count { !_1.nil? }
+        @coverage = @number_of_hits.to_f / @number_of_relevancies
+      end
+    end
+
+    def initialize(store:)
+      @store = store
+    end
+
+    def call(env)
+      template =
+        case env['PATH_INFO']
+        when '/'
+          items =
+            @store
+            .list
+            .map! { Item.new(_1) }
+            .sort! do |a, b|
+              next -1 if b.coverage.nan?
+              next 1 if a.coverage.nan?
+
+              a.coverage <=> b.coverage
+            end
+          INDEX_PAGE
+        when '/file'
+          path = URI.decode_www_form(env['QUERY_STRING']).assoc('path').last
+
+          record = @store.find(path)
+          return [404, {}, []] if record.nil?
+
+          source_code = record.source
+          execution_count = JSON.dump(record.execution_count)
+          FILE_PAGE
+        when '/clear'
+          return [405, {}, []] unless env['REQUEST_METHOD'] == 'DELETE'
+
+          @store.clear
+          return [302, { 'location' => '/' }, []]
+        else return [404, {}, []]
+        end
+      body = layout { template.result(binding) }
+      [200, {}, [body]]
+    end
+
+    private
+
+    def layout
+      LAYOUT_PAGE.result(binding)
+    end
+  end
+end

data/lib/cover_rage.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'cover_rage/launcher'
+CoverRage::Launcher.start

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: cover_rage
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Weihang Jian
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: coverage recorder
+email: tonytonyjan@gmail.com
+executables:
+- cover_rage
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/config.ru
+- bin/cover_rage
+- lib/cover_rage.rb
+- lib/cover_rage/config.rb
+- lib/cover_rage/fork_hook.rb
+- lib/cover_rage/launcher.rb
+- lib/cover_rage/record.rb
+- lib/cover_rage/recorder.rb
+- lib/cover_rage/stores/redis.rb
+- lib/cover_rage/stores/sqlite.rb
+- lib/cover_rage/viewer.rb
+- lib/cover_rage/viewer/file.erb
+- lib/cover_rage/viewer/index.erb
+- lib/cover_rage/viewer/layout.erb
+homepage: https://github.com/tonytonyjan/cover_rage
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: coverage recorder
+test_files: []