pangea-core 0.2.0 → 0.3.0

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MaximumCoverageDropCheck
+      def initialize(result, maximum_coverage_drop)
+        @result = result
+        @maximum_coverage_drop = maximum_coverage_drop
+      end
+
+      def failing?
+        return false unless maximum_coverage_drop && last_run
+
+        coverage_drop_violations.any?
+      end
+
+      def report
+        coverage_drop_violations.each do |violation|
+          $stderr.printf(
+            "%<criterion>s coverage has dropped by %<drop_percent>.2f%% since the last time (maximum allowed: %<max_drop>.2f%%).\n",
+            criterion: violation[:criterion].capitalize,
+            drop_percent: SimpleCov.round_coverage(violation[:drop_percent]),
+            max_drop: violation[:max_drop]
+          )
+        end
+      end
+
+      def exit_code
+        SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
+      end
+
+    private
+
+      attr_reader :result, :maximum_coverage_drop
+
+      def last_run
+        return @last_run if defined?(@last_run)
+
+        @last_run = SimpleCov::LastRun.read
+      end
+
+      def coverage_drop_violations
+        @coverage_drop_violations ||=
+          compute_coverage_drop_data.select do |achieved|
+            achieved.fetch(:max_drop) < achieved.fetch(:drop_percent)
+          end
+      end
+
+      def compute_coverage_drop_data
+        maximum_coverage_drop.map do |criterion, percent|
+          {
+            criterion: criterion,
+            max_drop: percent,
+            drop_percent: drop_percent(criterion)
+          }
+        end
+      end
+
+      # if anyone says "max_coverage_drop 0.000000000000000001" I appologize. Please don't.
+      MAX_DROP_ACCURACY = 10
+      def drop_percent(criterion)
+        drop = last_coverage(criterion) -
+               SimpleCov.round_coverage(
+                 result.coverage_statistics.fetch(criterion).percent
+               )
+
+        # floats, I tell ya.
+        # irb(main):001:0* 80.01 - 80.0
+        # => 0.010000000000005116
+        drop.floor(MAX_DROP_ACCURACY)
+      end
+
+      def last_coverage(criterion)
+        last_coverage_percent = last_run[:result][criterion]
+
+        # fallback for old file format
+        last_coverage_percent = last_run[:result][:covered_percent] if !last_coverage_percent && criterion == :line
+
+        last_coverage_percent || 0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MinimumCoverageByFileCheck
+      def initialize(result, minimum_coverage_by_file)
+        @result = result
+        @minimum_coverage_by_file = minimum_coverage_by_file
+      end
+
+      def failing?
+        minimum_violations.any?
+      end
+
+      def report
+        minimum_violations.each do |violation|
+          $stderr.printf(
+            "%<criterion>s coverage by file (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
+            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
+            minimum_coverage: violation.fetch(:minimum_expected),
+            criterion: violation.fetch(:criterion).capitalize
+          )
+        end
+      end
+
+      def exit_code
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      end
+
+    private
+
+      attr_reader :result, :minimum_coverage_by_file
+
+      def minimum_violations
+        @minimum_violations ||=
+          compute_minimum_coverage_data.select do |achieved|
+            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+          end
+      end
+
+      def compute_minimum_coverage_data
+        minimum_coverage_by_file.flat_map do |criterion, expected_percent|
+          result.coverage_statistics_by_file.fetch(criterion).map do |actual_coverage|
+            {
+              criterion: criterion,
+              minimum_expected: expected_percent,
+              actual: SimpleCov.round_coverage(actual_coverage.percent)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    class MinimumOverallCoverageCheck
+      def initialize(result, minimum_coverage)
+        @result = result
+        @minimum_coverage = minimum_coverage
+      end
+
+      def failing?
+        minimum_violations.any?
+      end
+
+      def report
+        minimum_violations.each do |violation|
+          $stderr.printf(
+            "%<criterion>s coverage (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
+            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
+            minimum_coverage: violation.fetch(:minimum_expected),
+            criterion: violation.fetch(:criterion).capitalize
+          )
+        end
+      end
+
+      def exit_code
+        SimpleCov::ExitCodes::MINIMUM_COVERAGE
+      end
+
+    private
+
+      attr_reader :result, :minimum_coverage
+
+      def minimum_violations
+        @minimum_violations ||= calculate_minimum_violations
+      end
+
+      def calculate_minimum_violations
+        coverage_achieved = minimum_coverage.map do |criterion, percent|
+          {
+            criterion: criterion,
+            minimum_expected: percent,
+            actual: result.coverage_statistics.fetch(criterion).percent
+          }
+        end
+
+        coverage_achieved.select do |achieved|
+          achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/exit_codes.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    SUCCESS = 0
+    EXCEPTION = 1
+    MINIMUM_COVERAGE = 2
+    MAXIMUM_COVERAGE_DROP = 3
+  end
+end
+
+require_relative "exit_codes/exit_code_handling"
+require_relative "exit_codes/maximum_coverage_drop_check"
+require_relative "exit_codes/minimum_coverage_by_file_check"
+require_relative "exit_codes/minimum_overall_coverage_check"

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/file_list.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # An array of SimpleCov SourceFile instances with additional collection helper
+  # methods for calculating coverage across them etc.
+  class FileList
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@files,
+                   # For Enumerable
+                   :each,
+                   # also delegating methods implemented in Enumerable as they have
+                   # custom Array implementations which are presumably better/more
+                   # resource efficient
+                   :size, :map, :count,
+                   # surprisingly not in Enumerable
+                   :empty?, :length,
+                   # still act like we're kinda an array
+                   :to_a, :to_ary
+
+    def initialize(files)
+      @files = files
+    end
+
+    def coverage_statistics
+      @coverage_statistics ||= compute_coverage_statistics
+    end
+
+    def coverage_statistics_by_file
+      @coverage_statistics_by_file ||= compute_coverage_statistics_by_file
+    end
+
+    # Returns the count of lines that have coverage
+    def covered_lines
+      coverage_statistics[:line]&.covered
+    end
+
+    # Returns the count of lines that have been missed
+    def missed_lines
+      coverage_statistics[:line]&.missed
+    end
+
+    # Returns the count of lines that are not relevant for coverage
+    def never_lines
+      return 0.0 if empty?
+
+      map { |f| f.never_lines.count }.inject(:+)
+    end
+
+    # Returns the count of skipped lines
+    def skipped_lines
+      return 0.0 if empty?
+
+      map { |f| f.skipped_lines.count }.inject(:+)
+    end
+
+    # Computes the coverage based upon lines covered and lines missed for each file
+    # Returns an array with all coverage percentages
+    def covered_percentages
+      map(&:covered_percent)
+    end
+
+    # Finds the least covered file and returns that file's name
+    def least_covered_file
+      min_by(&:covered_percent).filename
+    end
+
+    # Returns the overall amount of relevant lines of code across all files in this list
+    def lines_of_code
+      coverage_statistics[:line]&.total
+    end
+
+    # Computes the coverage based upon lines covered and lines missed
+    # @return [Float]
+    def covered_percent
+      coverage_statistics[:line]&.percent
+    end
+
+    # Computes the strength (hits / line) based upon lines covered and lines missed
+    # @return [Float]
+    def covered_strength
+      coverage_statistics[:line]&.strength
+    end
+
+    # Return total count of branches in all files
+    def total_branches
+      coverage_statistics[:branch]&.total
+    end
+
+    # Return total count of covered branches
+    def covered_branches
+      coverage_statistics[:branch]&.covered
+    end
+
+    # Return total count of covered branches
+    def missed_branches
+      coverage_statistics[:branch]&.missed
+    end
+
+    def branch_covered_percent
+      coverage_statistics[:branch]&.percent
+    end
+
+  private
+
+    def compute_coverage_statistics_by_file
+      @files.each_with_object(line: [], branch: []) do |file, together|
+        together[:line] << file.coverage_statistics.fetch(:line)
+        together[:branch] << file.coverage_statistics.fetch(:branch) if SimpleCov.branch_coverage?
+      end
+    end
+
+    def compute_coverage_statistics
+      coverage_statistics = {line: CoverageStatistics.from(coverage_statistics_by_file[:line])}
+      coverage_statistics[:branch] = CoverageStatistics.from(coverage_statistics_by_file[:branch]) if SimpleCov.branch_coverage?
+      coverage_statistics
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/filter.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Base filter class. Inherit from this to create custom filters,
+  # and overwrite the passes?(source_file) instance method
+  #
+  # # A sample class that rejects all source files.
+  # class StupidFilter < SimpleCov::Filter
+  #   def passes?(source_file)
+  #     false
+  #   end
+  # end
+  #
+  class Filter
+    attr_reader :filter_argument
+
+    def initialize(filter_argument)
+      @filter_argument = filter_argument
+    end
+
+    def matches?(_source_file)
+      raise "The base filter class is not intended for direct use"
+    end
+
+    def passes?(source_file)
+      warn "#{Kernel.caller.first}: [DEPRECATION] #passes? is deprecated. Use #matches? instead."
+      matches?(source_file)
+    end
+
+    def self.build_filter(filter_argument)
+      return filter_argument if filter_argument.is_a?(SimpleCov::Filter)
+
+      class_for_argument(filter_argument).new(filter_argument)
+    end
+
+    def self.class_for_argument(filter_argument)
+      case filter_argument
+      when String
+        SimpleCov::StringFilter
+      when Regexp
+        SimpleCov::RegexFilter
+      when Array
+        SimpleCov::ArrayFilter
+      when Proc
+        SimpleCov::BlockFilter
+      else
+        raise ArgumentError, "You have provided an unrecognized filter type"
+      end
+    end
+  end
+
+  class StringFilter < SimpleCov::Filter
+    # Returns true when the given source file's filename matches the
+    # string configured when initializing this Filter with StringFilter.new('somestring')
+    def matches?(source_file)
+      source_file.project_filename.include?(filter_argument)
+    end
+  end
+
+  class RegexFilter < SimpleCov::Filter
+    # Returns true when the given source file's filename matches the
+    # regex configured when initializing this Filter with RegexFilter.new(/someregex/)
+    def matches?(source_file)
+      (source_file.project_filename =~ filter_argument)
+    end
+  end
+
+  class BlockFilter < SimpleCov::Filter
+    # Returns true if the block given when initializing this filter with BlockFilter.new {|src_file| ... }
+    # returns true for the given source file.
+    def matches?(source_file)
+      filter_argument.call(source_file)
+    end
+  end
+
+  class ArrayFilter < SimpleCov::Filter
+    def initialize(filter_argument)
+      filter_objects = filter_argument.map do |arg|
+        Filter.build_filter(arg)
+      end
+
+      super(filter_objects)
+    end
+
+    # Returns true if any of the filters in the array match the given source file.
+    # Configure this Filter like StringFilter.new(['some/path', /^some_regex/, Proc.new {|src_file| ... }])
+    def matches?(source_files_list)
+      filter_argument.any? do |arg|
+        arg.matches?(source_files_list)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/formatter/multi_formatter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Formatter
+    class MultiFormatter
+      module InstanceMethods
+        def format(result)
+          formatters.map do |formatter|
+            formatter.new.format(result)
+          rescue StandardError => e
+            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            nil
+          end
+        end
+      end
+
+      def self.new(formatters = nil)
+        Class.new do
+          define_method :formatters do
+            @formatters ||= Array(formatters)
+          end
+          include InstanceMethods
+        end
+      end
+
+      def self.[](*args)
+        warn "#{Kernel.caller.first}: [DEPRECATION] ::[] is deprecated. Use ::new instead."
+        new(Array(args))
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/formatter/simple_formatter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module Formatter
+    #
+    # A ridiculously simple formatter for SimpleCov results.
+    #
+    class SimpleFormatter
+      # Takes a SimpleCov::Result and generates a string out of it
+      def format(result)
+        output = +""
+        result.groups.each do |name, files|
+          output << "Group: #{name}\n"
+          output << "=" * 40
+          output << "\n"
+          files.each do |file|
+            output << "#{file.filename} (coverage: #{file.covered_percent.round(2)}%)\n"
+          end
+          output << "\n"
+        end
+        output
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/formatter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # TODO: Documentation on how to build your own formatters
+  module Formatter
+  end
+end
+
+require_relative "formatter/simple_formatter"
+require_relative "formatter/multi_formatter"

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/last_run.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SimpleCov
+  module LastRun
+    class << self
+      def last_run_path
+        File.join(SimpleCov.coverage_path, ".last_run.json")
+      end
+
+      def read
+        return nil unless File.exist?(last_run_path)
+
+        json = File.read(last_run_path)
+        return nil if json.strip.empty?
+
+        JSON.parse(json, symbolize_names: true)
+      end
+
+      def write(json)
+        File.open(last_run_path, "w+") do |f|
+          f.puts JSON.pretty_generate(json)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/lines_classifier.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Classifies whether lines are relevant for code coverage analysis.
+  # Comments & whitespace lines, and :nocov: token blocks, are considered not relevant.
+
+  class LinesClassifier
+    RELEVANT = 0
+    NOT_RELEVANT = nil
+
+    WHITESPACE_LINE = /^\s*$/.freeze
+    COMMENT_LINE = /^\s*#/.freeze
+    WHITESPACE_OR_COMMENT_LINE = Regexp.union(WHITESPACE_LINE, COMMENT_LINE)
+
+    def self.no_cov_line
+      /^(\s*)#(\s*)(:#{SimpleCov.nocov_token}:)/o
+    end
+
+    def self.no_cov_line?(line)
+      no_cov_line.match?(line)
+    rescue ArgumentError
+      # E.g., line contains an invalid byte sequence in UTF-8
+      false
+    end
+
+    def self.whitespace_line?(line)
+      WHITESPACE_OR_COMMENT_LINE.match?(line)
+    rescue ArgumentError
+      # E.g., line contains an invalid byte sequence in UTF-8
+      false
+    end
+
+    def classify(lines)
+      skipping = false
+
+      lines.map do |line|
+        if self.class.no_cov_line?(line)
+          skipping = !skipping
+          NOT_RELEVANT
+        elsif skipping || self.class.whitespace_line?(line)
+          NOT_RELEVANT
+        else
+          RELEVANT
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/load_global_config.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "etc"
+home_dir = (ENV["HOME"] && File.expand_path("~")) || Etc.getpwuid.dir || (ENV["USER"] && File.expand_path("~#{ENV['USER']}"))
+if home_dir
+  global_config_path = File.join(home_dir, ".simplecov")
+  load global_config_path if File.exist?(global_config_path)
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/no_defaults.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+ENV["SIMPLECOV_NO_DEFAULTS"] = "yes, no defaults"
+require_relative "../simplecov"

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/process.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Process
+  class << self
+    def fork_with_simplecov(&block)
+      if defined?(SimpleCov) && SimpleCov.running
+        fork_without_simplecov do
+          SimpleCov.at_fork.call(Process.pid)
+          block.call if block_given?
+        end
+      else
+        fork_without_simplecov(&block)
+      end
+    end
+
+    alias fork_without_simplecov fork
+    alias fork fork_with_simplecov
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/profiles/bundler_filter.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "bundler_filter" do
+  add_filter "/vendor/bundle/"
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/profiles/hidden_filter.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "hidden_filter" do
+  add_filter %r{^/\..*}
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/profiles/rails.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "rails" do
+  load_profile "test_frameworks"
+
+  add_filter %r{^/config/}
+  add_filter %r{^/db/}
+
+  add_group "Controllers", "app/controllers"
+  add_group "Channels", "app/channels"
+  add_group "Models", "app/models"
+  add_group "Mailers", "app/mailers"
+  add_group "Helpers", "app/helpers"
+  add_group "Jobs", %w[app/jobs app/workers]
+  add_group "Libraries", "lib/"
+
+  track_files "{app,lib}/**/*.rb"
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/profiles/root_filter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "root_filter" do
+  # Exclude all files outside of simplecov root
+  root_filter = nil
+  add_filter do |src|
+    root_filter ||= /\A#{Regexp.escape(SimpleCov.root + File::SEPARATOR)}/io
+    src.filename !~ root_filter
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/simplecov-0.22.0/lib/simplecov/profiles/test_frameworks.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "test_frameworks" do
+  add_filter "/test/"
+  add_filter "/features/"
+  add_filter "/spec/"
+  add_filter "/autotest/"
+end