cover_rage 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f3618b26d2fc9a7c3f32354d8e30bed52f529d9d6f4de7c648a66245300e1c4
-  data.tar.gz: 4bfb79ee930c1886138dc25d90d804bed14e200e0576fc63c3aee9693ca348a9
+  metadata.gz: 56c953122e72d8aaa3a4a50129595cfc36fb20f1c2feea245b255295a5ba8a90
+  data.tar.gz: 7b5b4972c31670c4c9ab6b5298682ce7b8d258f4a0ff31faf8790856f1691428
 SHA512:
-  metadata.gz: 6ea002a43c449f4c7b2f0c323e30c1f1354a8bbdcf10ca3659262acb62ace07138f64cb80a34e1d2a47d07055f5a6b28902d40d3e4234a36fe25322755c179c7
-  data.tar.gz: 93a1ea6738c01fcf076fabc73f6ca0f7708e0db1897efec3944ad1cbdcd33419b42807988356441e564646db51fa72936d82ab0263b0b555a3658447d31e3ee9
+  metadata.gz: 26cd15a4e159851270b8c9b351e1047049eb509e1ebc322634d94ab8c53f2e8e42d22ca4521c07af7d784e3d8fa5993fc59e57bbeba0d2c49fa83b86ba5b5a88
+  data.tar.gz: 38e670bed372e6117c64967fc32a124e2dcac34734e14f05e954b282de01cd557af0847a69c16474e3e13c4352ec57a878d96b95925fc08c88612a5774b6c89c

data/lib/cover_rage/config.rb

@@ -0,0 +1,37 @@
+# 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
+
+    def self.disable?
+      @disable ||= ENV.key?('COVER_RAGE_DISABLE')
+    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/reporters/html_reporter/index.html.erb

@@ -0,0 +1,215 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>CoverRage</title>
+    <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;
+      }
+
+      .nav {
+        display: flex;
+        list-style: none;
+        padding-left: 0;
+      }
+      .nav > * {
+        margin-left: 8px;
+      }
+    </style>
+  </head>
+  <body>
+    <main id="main"></main>
+
+    <div style="display: none">
+      <div id="page-index">
+        <nav>
+          <ul class="nav">
+            <li><a href="#/">Index</a></li>
+          </ul>
+        </nav>
+        <table>
+          <thead>
+            <tr>
+              <th>path</th>
+              <th>lines</th>
+              <th>relevancy</th>
+              <th>hit</th>
+              <th>miss</th>
+              <th>coverage (%)</th>
+            </tr>
+          </thead>
+          <tbody></tbody>
+        </table>
+      </div>
+      <div id="page-file">
+        <nav>
+          <ul class="nav">
+            <li><a href="#/">Index</a></li>
+            <li>></li>
+            <li id="title"></li>
+          </ul>
+        </nav>
+        <pre><code id="code"></code></pre>
+      </div>
+    </div>
+
+    <script id="records" type="application/json"><%= records %></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/highlight.min.js"></script>
+    <script>
+      const main = document.getElementById("main");
+      const page_index = document.getElementById("page-index");
+      const title = document.createTextNode("");
+      document.getElementById("title").appendChild(title);
+      const code = document.getElementById("code");
+      const page_file = document.getElementById("page-file");
+      const records = JSON.parse(
+        document.getElementById("records").childNodes[0].nodeValue
+      );
+
+      const route = (path) => {
+        if (path.startsWith("/file/")) {
+          const filepath = path.slice(6);
+          if (records.find((record) => record.path === filepath))
+            return { page: "file", path: filepath };
+        }
+
+        return { page: "index" };
+      };
+
+      const render = (routing) => {
+        let page;
+        if (routing.page === "file") {
+          const record = records.find(({ path }) => path === routing.path);
+          page = page_file;
+          title.nodeValue = routing.path;
+          const digit_width =
+            Math.floor(Math.log10(Math.max(...record.execution_count))) + 1;
+          code.innerHTML = hljs
+            .highlight(
+              records.find(({ path }) => path === routing.path).source,
+              {
+                language: "ruby",
+              }
+            )
+            .value.split("\n")
+            .map((line, index) => {
+              const value = record.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");
+        }
+        if (routing.page === "index") {
+          page = page_index;
+        }
+        if (main.childNodes.length === 0) main.appendChild(page);
+        else main.replaceChild(page, main.childNodes[0]);
+      };
+      const createTdTextNode = (text) => {
+        const td = document.createElement("td");
+        td.appendChild(document.createTextNode(text));
+        return td;
+      };
+
+      page_index.querySelector("tbody").appendChild(
+        records
+          .map(({ path, revision, source, execution_count }) => {
+            const hit = execution_count.reduce(
+              (accumulator, current) =>
+                current > 0 ? accumulator + 1 : accumulator,
+              0
+            );
+            const miss = execution_count.reduce(
+              (accumulator, current) =>
+                current === 0 ? accumulator + 1 : accumulator,
+              0
+            );
+            const relevancy = execution_count.reduce(
+              (accumulator, current) =>
+                current !== null ? accumulator + 1 : accumulator,
+              0
+            );
+            const coverage = hit / relevancy;
+            return {
+              path,
+              lines: execution_count.length,
+              hit,
+              miss,
+              relevancy,
+              coverage,
+            };
+          })
+          .sort(({ coverage: a }, { coverage: b }) => {
+            if (isNaN(b)) return -1;
+            if (isNaN(a)) return 1;
+            return a - b;
+          })
+          .reduce(
+            (fragment, { path, lines, hit, miss, relevancy, coverage }) => {
+              const tr = document.createElement("tr");
+              tr.appendChild(
+                (() => {
+                  const anchor = document.createElement("a");
+                  anchor.href = `#/file/${path}`;
+                  anchor.appendChild(document.createTextNode(path));
+                  const td = document.createElement("td");
+                  td.appendChild(anchor);
+                  return td;
+                })()
+              );
+              tr.appendChild(createTdTextNode(lines));
+              tr.appendChild(createTdTextNode(relevancy));
+              tr.appendChild(createTdTextNode(hit));
+              tr.appendChild(createTdTextNode(miss));
+              tr.appendChild(
+                createTdTextNode(Math.round(coverage * 10000) / 100)
+              );
+              fragment.appendChild(tr);
+              return fragment;
+            },
+            document.createDocumentFragment()
+          )
+      );
+
+      document.addEventListener("DOMContentLoaded", () => {
+        const routing = route(window.location.hash.slice(1));
+        render(routing);
+      });
+
+      window.addEventListener("popstate", (event) => {
+        const routing = route(window.location.hash.slice(1));
+        render(routing);
+      });
+    </script>
+  </body>
+</html>

data/lib/cover_rage/reporters/html_reporter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'json'
+
+module CoverRage
+  module Reporters
+    class HtmlReporter
+      def report(records)
+        records = JSON.dump(records.map(&:to_h))
+        ERB.new(File.read("#{__dir__}/html_reporter/index.html.erb")).result(binding)
+      end
+    end
+  end
+end

data/lib/cover_rage/reporters/json_reporter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module CoverRage
+  module Reporters
+    class JsonReporter
+      def report(records)
+        JSON.dump(records.map(&:to_h))
+      end
+    end
+  end
+end

data/lib/cover_rage/stores/redis.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'cover_rage/record'
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cover_rage
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Weihang Jian
@@ -52,6 +52,16 @@ extra_rdoc_files: []
 files:
 - 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/reporters/html_reporter.rb
+- lib/cover_rage/reporters/html_reporter/index.html.erb
+- lib/cover_rage/reporters/json_reporter.rb
+- lib/cover_rage/stores/redis.rb
+- lib/cover_rage/stores/sqlite.rb
 homepage: https://github.com/tonytonyjan/cover_rage
 licenses:
 - MIT