oyencov 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 829c5d959c386d08c7d81c836251104461d0875fc4fb6e04d1963cd32301235b
+  data.tar.gz: 4f14f7447a5278cc84b89d7c6bcd9d4fa97c6ea3f12f4d898e89b042a5de880d
+SHA512:
+  metadata.gz: 11a0471aae67aa816d1840f1882eaa206be0ad339ab40fae872567985579a8e84dbae85573b5466083450849b33c30e9ee7a136c48d7ad08d1976849ce46290f
+  data.tar.gz: f896668dcbdf7deb0cb392da50f410fca1a0361f20181844fd99753df1ebd83ea3d5d870a9e3790cce60debe8fef09b88430a58149b40ac016c95c7244a3c23e

data/bin/oyencov

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+unless File.exist?('./Gemfile')
+  abort 'Please run oyencov from the root of the project.'
+end
+
+require 'rubygems'
+begin
+  require 'bundler'
+  Bundler.setup
+rescue StandardError
+end
+
+here = File.expand_path(File.dirname __FILE__)
+$LOAD_PATH << "#{here}/../lib"
+
+require "oyencov/cli"
+OyenCov::CLI.start(ARGV)

data/lib/oyencov/api_connection.rb

@@ -0,0 +1,53 @@
+require "faraday"
+require "singleton"
+
+module OyenCov
+  class APIConnection < Faraday::Connection
+    include Singleton
+
+    def initialize
+      super({
+        url: (ENV["OYENCOV_API_URL"] || "https://telemetry-api.oyencov.com"),
+        headers: {
+          "Authorization" => "Bearer #{ENV["OYENCOV_API_KEY"]}",
+          "Content-Type" => "application/json",
+          "User-Agent" => "oyencov-ruby 0.0.1"
+        }
+      }) do |f|
+        f.request :json
+        f.response :json
+      end
+    end
+
+    # Used in `background.rb` to determine whether to start background
+    def get_data_submission_clearance
+      attempts = 3
+      begin
+        response = get("/v1/data_submission_clearance")
+      rescue Faraday::Error => e
+        if ENV["OYENCOV_DEBUG"]
+          warn(e)
+        end
+
+        if attempts > 0
+          attempts -= 1
+          sleep(5)
+          retry
+        end
+        nil
+      end
+
+      response
+    end
+
+    def post_runtime_report(body)
+      post("/v1/runtime_reports", body)
+    rescue Faraday::Error
+      false
+    end
+
+    def post_test_report(body)
+      post("/v1/test_reports", body)
+    end
+  end
+end

data/lib/oyencov/background.rb

@@ -0,0 +1,81 @@
+require "securerandom"
+require "singleton"
+require_relative "api_connection"
+require_relative "coverage_peek_delta"
+
+# Bootstrap the thread that starts Coverage module data collection.
+#
+# Every 60 secs or so:
+# 1. Get the coverage peek_result delta
+# 2. Parse source code and determine which method being run
+# 3. Get controller actions' hits
+# 4. Call the reporter
+#
+# Most of the codes here are inspired by danmayer's coverband gem.
+#
+module OyenCov
+  class Background
+    @loop_interval = 60 # seconds, can be set from server
+    @semaphore = Mutex.new
+    @thread = nil
+    @reporter = nil
+    @api_conn = OyenCov::APIConnection.instance
+    @config = OyenCov.config
+
+    def self.start
+      puts "Hello #{Rails.env}"
+
+      # Start `Coverage` as soon as possible before other codes are loaded
+      CoveragePeekDelta.start
+
+      @thread = Thread.new {
+        # Check with backend to get parameters
+        sleep(3)
+        clearance = @api_conn.get_data_submission_clearance
+
+        if clearance.nil?
+          puts "Unable to obtain oyencov submission clearance. Stopping OyenCov background thread."
+          Thread.stop
+        end
+
+        if ENV["OYENCOV_DEBUG"]
+          puts(clearance.body)
+        end
+
+        @config.mode == "production" && loop do
+          sleep(@loop_interval + 3 - rand(6))
+          new_method_hits = CoveragePeekDelta.snapshot_delta
+          new_controller_hits = ControllerTracking.snapshot_and_reset!
+
+          puts new_method_hits
+
+          runtime_report = {
+            git_commit_sha: @config.release,
+            controller_action_hits: new_controller_hits,
+            method_hits: new_method_hits
+          }
+          response = @api_conn.post_runtime_report(runtime_report)
+
+          if response && response.body["status"] == "ok"
+            puts "[OyenOnsen] POST runtime_report ok."
+          else
+            warn "[OyenOnsen] POST runtime_report failed. Stopping background thread."
+            Thread.stop
+          end
+        end # loop
+      }
+
+      @thread.run
+
+      nil
+    end
+
+    # If production/staging etc, we can exit without further processing.
+    # For `test`, persist controller report.
+    def self.stop
+      @thread.stop
+    end
+
+    private_class_method
+  end
+end

data/lib/oyencov/cli.rb

@@ -0,0 +1,97 @@
+require "thor"
+require_relative "./api_connection"
+require_relative "./test_report_merger"
+require_relative "./simplecov_resultset_translator"
+
+# Bootstrapped from `bin/oyencov`
+#
+#
+module OyenCov
+  class CLI < Thor
+    desc "translate_simplecov coverage/.resultset.json", "err"
+    long_desc <<~TEXT
+      If you have parallel test jobs, this command is to be run right after
+      finishing the tests, and before artifacts are uploaded.
+
+      Assumes the --coverage-dir path contains both the simplecov .resultset.json,
+      and the oyencov-resultset.json. It parses the .resultset.json file
+      generated by simplecov, and append the translated information into the
+      pre-existing oyencov-resultset.json.
+    TEXT
+    # option :coverage_dir, default: "coverage"
+    option :simplecov_json_path, default: "coverage/.resultset.json"
+    option :oyencov_json_path, default: "coverage/oyencov-resultset.json"
+    option :dry_run, type: :boolean, default: false
+    def translate_simplecov
+      oyencov_json_path = Dir.pwd + "/" + options[:oyencov_json_path]
+      simplecov_json_path = Dir.pwd + "/" + options[:simplecov_json_path]
+
+      # Find existing resultset files
+      if File.exist?(oyencov_json_path)
+        oyencov_json = File.read(oyencov_json_path)
+      else
+        warn("Could not find existing oyencov-resultset.json at #{oyencov_json_path}")
+        exit(1)
+      end
+
+      warn "Starting to translate simplecov"
+
+      if File.exist?(simplecov_json_path)
+        simplecov_translated_json = OyenCov::SimplecovResultsetTranslator.translate(simplecov_json_path)
+      else
+        warn("Could not find existing simplecov's .resultset.json at #{simplecov_json_path}")
+        exit(1)
+      end
+
+      warn "AFTER translate simplecov"
+
+      # Attempt merging
+      oyencov_resultset = JSON.parse(oyencov_json)
+      oyencov_resultset = oyencov_resultset.merge("method_hits" => simplecov_translated_json)
+
+      # Persist, or dry run stdout?
+      new_oyencov_resultset_json = JSON.pretty_generate(oyencov_resultset)
+      if options[:dry_run]
+        puts new_oyencov_resultset_json
+      else
+        File.write(oyencov_json_path, new_oyencov_resultset_json)
+      end
+    end
+
+    desc "submit tmp/coverage-jsons-*/oyencov-resultset.json",
+      "submits the oyencov resultsets data"
+    option :files, type: :array, required: true
+    option :git_commit_sha, required: true
+    option :token
+    def submit
+      resultset_files = options[:files]
+      ENV["OYENCOV_DEBUG"] && if resultset_files.any?
+                                puts "Found #{resultset_files.join(", ")}"
+                              else
+                                puts "No resultset files found"
+                                exit 1
+                              end
+
+      collated_report = OyenCov::TestReportMerger
+        .collate_job_reports(options[:files])
+        .merge({
+          "git_commit_sha" => options[:git_commit_sha]
+        })
+
+      # puts JSON.pretty_generate(collated_report)
+
+      # Add metadaata
+
+      ENV["OYENCOV_API_KEY"] ||= options[:token]
+      unless ENV["OYENCOV_API_KEY"]
+        warn "API token not set. Unable to submit."
+        exit(1)
+      end
+
+      connection = OyenCov::APIConnection.instance
+      post_response = connection.post_test_report(collated_report)
+
+      puts post_response.body
+    end
+  end
+end

data/lib/oyencov/configuration.rb

@@ -0,0 +1,62 @@
+# We encourage configuring OyenOnsen through environment variables.
+#
+# But some can be set through config/ if they are meant to be uniform across environments.
+module OyenCov
+  class Configuration
+    ENV_PARAMETERS = %w[
+      API_KEY
+      API_URL
+      MODE
+      RELEASE
+      TEST_REPORTING_DIR
+      TEST_RESULTSET_PATH
+      PROGRAM_NAME
+    ]
+
+    attr :api_key, :api_url, :mode, :including_file_paths, :excluding_file_paths, :release, :test_reporting_dir, :test_resultset_path, :program_name
+
+    def initialize
+      reset_to_defaults
+      ENV_PARAMETERS.each do |key|
+        if (envvar_value = ENV["OYENONSEN_#{key}"])
+          instance_variable_set(
+            :"@#{key.downcase}", envvar_value
+          )
+        end
+      end
+    end
+
+    def reset_to_defaults
+      @api_key = nil
+      @api_url = "https://telemetry-api.oyencov.com"
+      @mode = ENV["RAILS_ENV"]
+      @including_file_paths = %w[app lib]
+      @excluding_file_paths = []
+      @release = suggest_release
+      @test_reporting_dir = "coverage/"
+      @test_resultset_path = "coverage/oyencov-resultset.json"
+    end
+
+    private
+
+    # Lots of ideas came from sentry-ruby, thanks to nate berkopec.
+    def suggest_release
+      release = `git rev-parse HEAD ||:`.strip
+
+      if release == "" || release.nil?
+        [".source_version", "REVISION"].each do |version_clue|
+          if File.exist?(Rails.root.join(version_clue))
+            release = File.read(Rails.root.join(version_clue)).strip
+            return release
+          end
+        end
+      end
+
+      release
+    end
+
+    # We need to know if this is rails, sidekiq, rake task etc
+    def suggest_program_name
+    end
+  end
+end

data/lib/oyencov/controller_tracking.rb

@@ -0,0 +1,22 @@
+# This module is merely the container data structure.
+#
+# The ACTUAL code that tracks controller is in `railtie.rb`
+module OyenCov
+  module ControllerTracking
+    @hits = {}
+
+    def self.bump(controller_action_name)
+      if @hits[controller_action_name]
+        @hits[controller_action_name] += 1
+      else
+        @hits[controller_action_name] = 1
+      end
+    end
+
+    def self.snapshot_and_reset!
+      current_hits = @hits
+      @hits = {}
+      current_hits
+    end
+  end
+end

data/lib/oyencov/coverage_peek_delta.rb

@@ -0,0 +1,83 @@
+require "coverage"
+require_relative "method_range_parser"
+
+# `CoveragePeekDelta` utility is meant to take...
+#
+# This class won't be governing the state, that will be handled by `OyenCov::Background`. However this will help strip the project path from the hash keys for cleaner reporting.
+module OyenCov
+  module CoveragePeekDelta
+    PWD = Dir.pwd
+
+    @@previous_method_hits = {}
+
+    # We go a bit softer here. If there are other libraries starting
+    #   coverage then don't throw exception.
+    def self.start
+      reset!
+
+      unless Coverage.running?
+        Coverage.start
+      end
+    end
+
+    # 1. Filter only the keys with PWD.
+    # 2. `transform_keys` and remove the PWD
+    # 3. Use MRP to get the impt lines.
+    #
+    # @return [Hash] Method name => line num executions diff from last time
+    def self.snapshot_delta
+      current_peek = Coverage.peek_result
+
+      if ENV["OYENONSEN_DEBUG"]
+        $stdout.puts "current_peek size = #{current_peek.size}, keys like: #{current_peek.keys[0, 3]}"
+      end
+
+      # Filter into project
+      filtered = current_peek.select do |k, _|
+        /^#{PWD}/o.match?(k)
+      end.transform_keys do |k|
+        k.gsub(/#{PWD}\//o, "")
+      end
+
+      if ENV["OYENONSEN_DEBUG"]
+        $stdout.puts "filtered size = #{filtered.size}, keys like: #{filtered.keys[0, 3]}"
+      end
+
+      # Filter inside project to just the paths
+      filtered = filtered.select do |k, _|
+        /^(app|lib)/.match?(k)
+      end
+
+      if ENV["OYENONSEN_DEBUG"]
+        $stdout.puts "filtered size = #{filtered.size}, keys like: #{filtered.keys[0, 3]}"
+      end
+
+      # Find the method ranges, set
+      current_method_hits = {}
+      filtered.each_pair do |fpath, line_hits|
+        MethodRangeParser[fpath]&.each_pair do |method_name, line_num|
+          # puts [method_name, line_num, line_hits[line_num]]
+          next if line_num.nil? || line_hits[line_num].nil?
+          current_method_hits[method_name] = line_hits[line_num]
+        end
+      end
+
+      # Compare and delta
+      new_method_hits = {}
+      current_method_hits.each_pair do |method_name, counter|
+        if counter.nil?; puts method_name; end
+        new_hits = counter - (@@previous_method_hits[method_name] || 0)
+        if new_hits > 0
+          new_method_hits[method_name] = new_hits
+        end
+      end
+
+      @@previous_method_hits = current_method_hits
+      new_method_hits
+    end
+
+    def self.reset!
+      @@previous_method_hits = {}
+    end
+  end
+end

data/lib/oyencov/method_range_parser.rb

@@ -0,0 +1,101 @@
+require "parser/current"
+
+# This module helps scanning source code files and get the definition line
+#   ranges, so we can count how many times a method has been executed.
+module OyenCov
+  class MethodRangeParser < Hash
+    @@parsed_files = {}
+
+    def self.parsed_files
+      @@parsed_files
+    end
+
+    # Check cache
+    def self.[](filepath)
+      @filepath = filepath
+      @@parsed_files[@filepath] ||= parse_file(@filepath)
+    end
+
+    private
+
+    # Considerations:
+    # - Some .rb files do not have valid syntax, we can rescue them. However parser
+    #   stills stderr
+    #
+    # @return [Hash<String, >] Hash of methods to their children starting line count. The line count can be used to read how often the method is executed from `Coverage.peek_result`
+    private_class_method def self.parse_file(filepath)
+      traverse_ast(Parser::CurrentRuby.parse(File.read(filepath)))
+        .to_h
+        .select do |k, v|
+          /\.|\#/.match?(k)
+        end.transform_keys do |k|
+          k.gsub(/^::/, "")
+        end
+    rescue Parser::SyntaxError
+      {}
+    end
+
+    private_class_method def self.declaration_name(node)
+      case node.type
+      when :begin then ""
+      when :defs then ".#{node.children[1]}"
+      when :def then "##{node.children[0]}"
+      when :class, :module # traverse
+        current_name_constant_node = node.children[0]
+        full_constant_name = ""
+        until current_name_constant_node.children[0].nil?
+          full_constant_name = "::#{current_name_constant_node.children[1]}#{full_constant_name}"
+          current_name_constant_node = current_name_constant_node.children[0]
+        end
+        "::#{current_name_constant_node.children[1]}#{full_constant_name}"
+      else "Unsupported AST node type: #{node.type}"
+      end
+    end
+
+    # @return [Integer]
+    private_class_method def self.definition_line_num(node)
+      definition_lines = node.children.find do |i|
+        Parser::AST::Node === i && i.type == :begin
+      end || node.children[-1]
+
+      if definition_lines.nil?
+        nil
+      else
+        definition_lines.loc.first_line
+      end
+    end
+
+    # this be recursion
+    # return array of ["node_type/namespace::nam#node_name" => [startline, endline]
+    private_class_method def self.traverse_ast(node)
+      unless Parser::AST::Node === node
+        return nil
+      end
+
+      unless %i[begin module class defs def].include?(node.type)
+        return nil
+      end
+
+      node_children = node.children.find do |i|
+        Parser::AST::Node === i && i.type == :begin
+      end&.children || [node.children[-1]]
+
+      ownself_name = declaration_name(node)
+      ownself_range = definition_line_num(node)
+
+      children_name_range = []
+
+      node_children&.each do |cnode|
+        if Array === traverse_ast(cnode)
+          children_name_range += traverse_ast(cnode)
+        end
+      end
+
+      children_name_range.map! do |cnode|
+        ["#{ownself_name}#{cnode[0]}", cnode[1]]
+      end
+
+      [[ownself_name, ownself_range]] + children_name_range
+    end
+  end
+end

data/lib/oyencov/railtie.rb

@@ -0,0 +1,26 @@
+require_relative "background"
+require_relative "controller_tracking"
+require_relative "test_reporting"
+
+module OyenCov
+  class Railtie < Rails::Railtie
+    initializer "oyencov.configure" do
+      # puts "lib/oyencov/railtie.rb initializer oyencov.configure"
+      OyenCov::Background.start
+    end
+
+    config.after_initialize do
+      # puts "lib/oyencov/railtie.rb config.after_initialize"
+      ActiveSupport::Notifications.subscribe("start_processing.action_controller") do |name, start, finish, id, payload|
+        # puts(payload)
+        ControllerTracking.bump("#{payload[:controller]}##{payload[:action]}")
+      end
+
+      if OyenCov.config.mode == "test"
+        at_exit do
+          OyenCov::TestReporting.persist_controller_actions!
+        end
+      end
+    end
+  end
+end

data/lib/oyencov/simplecov_resultset_translator.rb

@@ -0,0 +1,54 @@
+require_relative "./method_range_parser"
+require_relative "./test_report_merger"
+
+# This is meant to be run at the end of the fan-out jobs, and the output
+#   artefacts are meant to be persisted for the next job in the workflow.
+#
+# It's possible the full codebase isn't pulled in the final summarising
+#   job. User can opt to just `gem install oyencov` and do the collation
+#   and submission with just the gem.
+#
+# The code should be similar to `CoveragePeekDelta`.
+#
+# A simplecov .resultset.json file looks like this:
+#
+# ```
+# $test_tool (e.g. Minitest, RSpec) # can disregard
+#   "coverage" # constant string
+#     $rb_filepath # root relative paths
+#       [null, 1, 2, null, ...] # raw `Coverage.result` output
+# ```
+#
+module OyenCov
+  module SimplecovResultsetTranslator
+    PWD = Dir.pwd
+
+    # @param [String] Root-relative path to the .resultset.json
+    # @return [String] JSON file
+    def self.translate(resultset_json_path, persist: false)
+      # Open up the JSON
+      resultset = JSON.parse(File.read(resultset_json_path))
+
+      # binding.irb
+
+      # Loop through all the files
+      # Set {"method" => runs, ...}
+      all_methods_hits = resultset[resultset.keys[0]]["coverage"].each_pair.map do |file_path, file_attr|
+        # file_path = file_path.gsub(/#{PWD}\//o, "")
+        line_hits = file_attr["lines"]
+        methods_hits = MethodRangeParser[file_path]&.each_pair&.map do |method_name, line_num|
+          next if line_num.nil? || line_hits[line_num].nil?
+          [method_name, line_hits[line_num]]
+        end&.compact.to_h
+        # methods_hits
+      end.reduce(:merge)
+
+      # Persist to existing oyencov report?
+      if persist
+        OyenCov::TestReportMerger.create_or_append!(method_hits: all_methods_hits)
+      end
+
+      all_methods_hits
+    end
+  end
+end

data/lib/oyencov/test_report_merger.rb

@@ -0,0 +1,71 @@
+require "json"
+
+# Currently Oyencov only tracks
+#
+# Simplecov report collation is not handled here.
+module OyenCov
+  module TestReportMerger
+    def self.create_or_append!(hash_to_merge)
+      resultset_path = OyenCov.config.test_resultset_path
+
+      # Load
+      hash_content = if File.exist?(resultset_path)
+        JSON.parse(File.read(resultset_path))
+      else
+        {}
+      end
+
+      hash_content.merge!(hash_to_merge)
+
+      # Persist
+      File.write(resultset_path, JSON.generate(hash_content))
+    end
+
+    # @param [String]
+    # @param [String]
+    # @return [Hash]
+    def self.collate_job_reports(filepath_glob, save_to = nil)
+      # Read and parse their JSONs
+      job_reports_files = Dir.glob(filepath_glob)
+      # binding.irb
+      return if job_reports_files.count == 0
+
+      job_reports = job_reports_files.map do |f|
+        JSON.parse(File.read(f))
+      end
+
+      # Add them up
+      collated_report = job_reports.reduce({
+        "controller_action_hits" => {},
+        "method_hits" => {}
+      }) do |i, j|
+        ij = {}
+        i.keys.each do |metric|
+          unless j[metric]
+            ij[metric] = i[metric]
+            next
+          end
+
+          case metric
+          when "controller_action_hits", "method_hits"
+            ij[metric] = add_hashes(i[metric], j[metric])
+          end
+        end
+
+        ij
+      end
+
+      # Persist to filesystem as JSON
+      if !!save_to
+      end
+
+      collated_report
+    end
+
+    private_class_method def self.add_hashes(i, j)
+      (i.keys | j.keys).map do |key|
+        [key, (i[key] || 0) + (j[key] || 0)]
+      end.to_h
+    end
+  end
+end

data/lib/oyencov/test_reporting.rb

@@ -0,0 +1,28 @@
+require "securerandom"
+
+# For use in CI only, one-off export
+#
+module OyenCov
+  class TestReporting
+    def self.persist_controller_actions!
+      controller_action_hits = OyenCov::ControllerTracking.snapshot_and_reset!
+
+      # Persist report file
+      test_report_dir = File.expand_path(OyenCov.config.test_reporting_dir)
+      FileUtils.mkdir_p(test_report_dir)
+      test_report_path = OyenCov.config.test_resultset_path
+
+      report_content = {
+        controller_action_hits:
+      }
+
+      report_content_json = JSON.generate(report_content)
+
+      File.open(test_report_path, "w+") do |f|
+        f.puts(report_content_json)
+      end
+
+      puts "[OyenCov] Saved to #{test_report_path}"
+    end
+  end
+end

data/lib/oyencov.rb

@@ -0,0 +1,15 @@
+require_relative "oyencov/configuration"
+require_relative "oyencov/simplecov_resultset_translator"
+
+# For now, support only Rails. We bootstrap from Railtie.
+module OyenCov
+  VERSION = "0.0.1.pre"
+
+  def self.config
+    @config ||= OyenCov::Configuration.new
+  end
+
+  if defined?(Rails::Railtie) && ENV["OYENONSEN_API_KEY"]
+    require_relative "oyencov/railtie"
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: oyencov
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: ruby
+authors:
+- Anonoz Chong
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Runtime and test reporters.
+email: anonoz@oyencov.com
+executables:
+- oyencov
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/oyencov
+- lib/oyencov.rb
+- lib/oyencov/api_connection.rb
+- lib/oyencov/background.rb
+- lib/oyencov/cli.rb
+- lib/oyencov/configuration.rb
+- lib/oyencov/controller_tracking.rb
+- lib/oyencov/coverage_peek_delta.rb
+- lib/oyencov/method_range_parser.rb
+- lib/oyencov/railtie.rb
+- lib/oyencov/simplecov_resultset_translator.rb
+- lib/oyencov/test_report_merger.rb
+- lib/oyencov/test_reporting.rb
+homepage: https://www.oyencov.com
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Client-side telemetry
+test_files: []