peak_flow_utils 0.1.12 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27b80fe472694a76875b46c4bc5e393e6bf02acb13e4ff2b194e5ce4b61698b7
-  data.tar.gz: 4e4bd827165ad878970df19990af1d80ab229188f7d590464faadb772945b324
+  metadata.gz: c01a814a1aad134f668f7144f6addea59f8b8afdc75a2ae8ff2280dbe3a9867c
+  data.tar.gz: b6746741a1ff204c7b2a31319409d84a4529c14a55f8e9cfbf7b7fcad37eacea
 SHA512:
-  metadata.gz: 11cc3ae6a4bed2cec6209846fbe5463e2133c4a5ff3873a63ef93bec83fbf1a58c90282aa279307dc090e3d1ac30d27bcb93193dc7489914b500939d8a389bb1
-  data.tar.gz: 2b20aedf4ba6b0ae8ad2a6882e8f8664c9212310ce4cd2f555ac6c6436cb5943b6096d23e64502deaf6ea3c02f105e7c941614e1b549e767878a08fe9a4d0080
+  metadata.gz: 5a82e952b87453cfde4fbcb42fd43a0f2bca93f43dc2b3dbdca3109c6d25a21dd587745c602680d89c446cda1c1be251167b46248b98bc1e5354f408ae9f2758
+  data.tar.gz: d2020073122505feaa6cb3923f79a76ff6f8608ac45af16625cae83f79c6232a9f4ac677e834faa015bfd1d9e287946b4cc0662557507dcfab89ea7c3faf665e

data/app/controllers/peak_flow_utils/pings/postgres_connections_controller.rb

@@ -3,6 +3,7 @@ class PeakFlowUtils::Pings::PostgresConnectionsController < PeakFlowUtils::Appli
     postgres_connections_count = ActiveRecord::Base.connection.execute("SELECT SUM(numbackends) AS connections_count FROM pg_stat_database").to_a.first
 
     render json: {
+      check_json_status: "OK",
       postgres_connections_count: postgres_connections_count.fetch("connections_count")
     }
   end

data/app/controllers/peak_flow_utils/pings/sidekiq_controller.rb

@@ -5,6 +5,7 @@ class PeakFlowUtils::Pings::SidekiqController < PeakFlowUtils::ApplicationContro
     sidekiq_queue = Sidekiq::Queue.new
 
     render json: {
+      check_json_status: "OK",
       latency: sidekiq_queue.latency,
       queue_size: sidekiq_queue.size
     }

data/app/services/peak_flow_utils/database_initializer_service.rb

@@ -1,6 +1,6 @@
 class PeakFlowUtils::DatabaseInitializerService < PeakFlowUtils::ApplicationService
-  def execute
-    path = File.realpath("#{File.dirname(__FILE__)}/../../../lib/peak_flow_utils/migrations")
+  def perform
+    path = File.realpath("#{__dir__}/../../../lib/peak_flow_utils/migrations")
     create_schema_table unless schema_table_exists?
 
     Dir["#{path}/[0-9]*_*.rb"].sort.map do |filename|
@@ -22,7 +22,7 @@ class PeakFlowUtils::DatabaseInitializerService < PeakFlowUtils::ApplicationServ
 private
 
   def create_schema_table
-    PeakFlowUtils::ApplicationRecord.connection.execute("CREATE TABLE schema_migrations (version VARCHAT)")
+    PeakFlowUtils::ApplicationRecord.connection.execute("CREATE TABLE schema_migrations (version VARCHAR)")
   end
 
   def register_migration_migrated(version)

data/app/services/peak_flow_utils/deep_merger.rb

@@ -0,0 +1,62 @@
+class PeakFlowUtils::DeepMerger < PeakFlowUtils::ApplicationService
+  attr_reader :hashes, :object_mappings
+
+  def initialize(hashes:, object_mappings: {})
+    @hashes = hashes
+    @object_mappings = object_mappings
+  end
+
+  def perform
+    merged = {}
+
+    hashes.each do |hash|
+      merge_hash(hash, merged)
+    end
+
+    succeed! merged
+  end
+
+  def clone_something(object)
+    if object.is_a?(Hash)
+      new_hash = {}
+      merge_hash(object, new_hash)
+      new_hash
+    elsif object.is_a?(Array)
+      new_array = []
+      merge_array(object, new_array)
+      new_array
+    else
+      object
+    end
+  end
+
+  def merge_something(object, merged)
+    if object.is_a?(Array)
+      merge_array(object, merged)
+    elsif object.is_a?(Hash)
+      merge_hash(object, merged)
+    else
+      raise "Unknown object: #{object.class.name}"
+    end
+  end
+
+  def merge_array(array, merged)
+    array.each do |value|
+      merged << clone_something(value)
+    end
+  end
+
+  def merge_hash(hash, merged)
+    hash.each do |key, value|
+      if value.is_a?(Array)
+        merged[key] = []
+        merge_array(value, merged[key])
+      elsif value.is_a?(Hash)
+        merged[key] ||= {}
+        merge_hash(value, merged[key])
+      else
+        merged[key] = clone_something(value)
+      end
+    end
+  end
+end

data/app/services/peak_flow_utils/handlers_finder_service.rb

@@ -1,8 +1,8 @@
 class PeakFlowUtils::HandlersFinderService < PeakFlowUtils::ApplicationService
-  def execute
+  def perform
     handlers = []
 
-    Dir.foreach("#{File.dirname(__FILE__)}/../../handlers/peak_flow_utils") do |file|
+    Dir.foreach("#{__dir__}/../../handlers/peak_flow_utils") do |file|
       match = file.match(/\A(.+)_handler\.rb\Z/)
       next unless match
 

data/app/services/peak_flow_utils/translations_parser_service.rb

@@ -1,7 +1,7 @@
 class PeakFlowUtils::TranslationsParserService < PeakFlowUtils::ApplicationService
   attr_reader :db
 
-  def execute
+  def perform
     PeakFlowUtils::DatabaseInitializerService.execute!
 
     cache_translations_in_dir(Rails.root.join("config/locales"))
@@ -103,11 +103,11 @@ private
     puts message.to_s if @debug # rubocop:disable Rails/Output
   end
 
-  def execute_migrations
+  def perform_migrations
     require "baza_migrations"
 
     executor = BazaMigrations::MigrationsExecutor.new(db: @db)
-    executor.add_dir "#{File.dirname(__FILE__)}/../../db/baza_translations_migrations"
+    executor.add_dir "#{__dir__}/../../db/baza_translations_migrations"
     executor.execute_migrations
   end
 

data/lib/peak_flow_utils/inherited_local_var.rb

@@ -0,0 +1,84 @@
+require "monitor"
+require_relative "thread_callbacks_patch"
+
+Thread.on_initialize do |parent:, thread:|
+  thread.instance_variable_set(:@_inherited_local_vars, parent.instance_variable_get(:@_inherited_local_vars))
+end
+
+Thread.class_eval do
+  def self.inherited_local_vars_mutex
+    @inherited_local_vars_mutex ||= Mutex.new
+  end
+
+  def self._inherited_local_vars
+    Thread.current.instance_variable_set(:@_inherited_local_vars, {}) unless Thread.current.instance_variable_get(:@_inherited_local_vars)
+    Thread.current.instance_variable_get(:@_inherited_local_vars)
+  end
+
+  def self.inherited_local_vars_reset
+    ObjectSpace.each_object(Thread) do |thread|
+      inherited_local_vars_mutex.synchronize do
+        thread.instance_variable_set(:@_inherited_local_vars, nil)
+      end
+    end
+  end
+
+  def self.inherited_local_vars_delete(key)
+    inherited_local_vars_mutex.synchronize do
+      raise "Key didn't exist: #{key}" unless _inherited_local_vars.key?(key)
+
+      _inherited_local_vars.delete(key)
+    end
+  rescue ThreadError # This can happen when process is closing down
+    _inherited_local_vars.delete(key)
+  end
+
+  def self.inherited_local_vars_fetch(key)
+    inherited_local_vars_mutex.synchronize do
+      return _inherited_local_vars.fetch(key)
+    end
+  end
+
+  def self.inherited_local_vars_get(key)
+    inherited_local_vars_mutex.synchronize do
+      return _inherited_local_vars[key]
+    end
+  end
+
+  def self.inherited_local_vars_set(values)
+    inherited_local_vars_mutex.synchronize do
+      current_vars = _inherited_local_vars
+      new_vars = PeakFlowUtils::DeepMerger.execute!(hashes: [current_vars, values])
+      Thread.current.instance_variable_set(:@_inherited_local_vars, new_vars)
+    end
+  end
+end
+
+class PeakFlowUtils::InheritedLocalVar
+  attr_reader :identifier
+
+  def self.finalize(inherited_local_var_object_id)
+    Thread.inherited_local_vars_delete("inherited_local_var_#{inherited_local_var_object_id}")
+  rescue Exception => e # rubocop:disable Lint/RescueException
+    puts e.inspect # rubocop:disable Rails/Output
+    puts e.backtrace # rubocop:disable Rails/Output
+
+    raise e
+  end
+
+  def initialize(new_value = nil)
+    ObjectSpace.define_finalizer(self, PeakFlowUtils::InheritedLocalVar.method(:finalize))
+
+    @identifier = "inherited_local_var_#{__id__}"
+
+    Thread.inherited_local_vars_set(identifier => new_value)
+  end
+
+  def value
+    Thread.inherited_local_vars_fetch(identifier)
+  end
+
+  def value=(new_value)
+    Thread.inherited_local_vars_set(identifier => new_value)
+  end
+end

data/lib/peak_flow_utils/notifier.rb

@@ -2,37 +2,88 @@ class PeakFlowUtils::Notifier
   class FailedToReportError < RuntimeError; end
   class NotConfiguredError < RuntimeError; end
 
-  attr_reader :auth_token
+  attr_reader :auth_token, :mutex, :parameters
 
   def self.configure(auth_token:)
     @current = PeakFlowUtils::Notifier.new(auth_token: auth_token)
   end
 
-  def self.current
-    raise PeakFlowUtils::Notifier::NotConfiguredError, "Hasn't been configured" if !@current && Rails.env.test?
-
+  def self.current # rubocop:disable Style/TrivialAccessors
     @current
   end
 
-  def self.notify(*args)
-    PeakFlowUtils::Notifier.current.notify(*args)
+  def self.notify(*args, **opts, &blk)
+    PeakFlowUtils::Notifier.current&.notify(*args, **opts, &blk)
+  end
+
+  def self.reset_parameters
+    ::PeakFlowUtils::Notifier.current&.instance_variable_set(:@parameters, ::PeakFlowUtils::InheritedLocalVar.new({}))
+  end
+
+  def self.with_parameters(parameters)
+    return yield unless ::PeakFlowUtils::Notifier.current
+
+    random_id = ::SecureRandom.hex(16)
+
+    ::PeakFlowUtils::Notifier.current.mutex.synchronize do
+      raise "'parameters' was nil?" if ::PeakFlowUtils::Notifier.current.parameters.value.nil?
+
+      parameters_with = ::PeakFlowUtils::Notifier.current.parameters.value.clone
+      parameters_with[random_id] = parameters
+
+      ::PeakFlowUtils::Notifier.current.parameters.value = parameters_with
+    end
+
+    begin
+      yield
+    ensure
+      ::PeakFlowUtils::Notifier.current.mutex.synchronize do
+        parameters_without = ::PeakFlowUtils::Notifier.current.parameters.value.clone
+        parameters_without.delete(random_id)
+
+        ::PeakFlowUtils::Notifier.current.parameters.value = parameters_without
+      end
+    end
   end
 
   def initialize(auth_token:)
     @auth_token = auth_token
+    @mutex = ::Mutex.new
+    @parameters = ::PeakFlowUtils::InheritedLocalVar.new({})
+  end
+
+  def current_parameters(parameters: nil)
+    hashes = current_parameters_hashes
+    hashes << parameters if parameters
+
+    ::PeakFlowUtils::DeepMerger.execute!(hashes: hashes)
+  end
+
+  def current_parameters_hashes
+    parameters.value.values
+  end
+
+  def error_message_from_response(response)
+    message = "Couldn't report error to Peakflow (code #{response.code})"
+
+    if response["content-type"]&.starts_with?("application/json")
+      response_data = ::JSON.parse(response.body)
+      message << ": #{response_data.fetch("errors").join(". ")}" if response_data["errors"]
+    end
+
+    message
   end
 
   def notify(error:, environment: nil, parameters: nil)
-    error_parser = PeakFlowUtils::NotifierErrorParser.new(
+    error_parser = ::PeakFlowUtils::NotifierErrorParser.new(
       backtrace: error.backtrace,
       environment: environment,
       error: error
     )
 
-    uri = URI("https://www.peakflow.io/errors/reports")
+    merged_parameters = current_parameters(parameters: parameters)
 
-    https = Net::HTTP.new(uri.host, uri.port)
-    https.use_ssl = true
+    uri = URI("https://www.peakflow.io/errors/reports")
 
     data = {
       auth_token: auth_token,
@@ -43,25 +94,32 @@ class PeakFlowUtils::Notifier
         file_path: error_parser.file_path,
         line_number: error_parser.line_number,
         message: error.message,
-        parameters: parameters,
+        parameters: merged_parameters,
         remote_ip: error_parser.remote_ip,
         url: error_parser.url,
         user_agent: error_parser.user_agent
       }
     }
 
-    request = Net::HTTP::Post.new(uri.path)
+    send_notify_request(data: data, uri: uri)
+  end
+
+  def send_notify_request(data:, uri:)
+    https = ::Net::HTTP.new(uri.host, uri.port)
+    https.use_ssl = true
+
+    request = ::Net::HTTP::Post.new(uri.path)
     request["Content-Type"] = "application/json"
-    request.body = JSON.generate(data)
+    request.body = ::JSON.generate(data)
 
     response = https.request(request)
 
     raise FailedToReportError, error_message_from_response(response) unless response.code == "200"
 
-    response_data = JSON.parse(response.body)
+    response_data = ::JSON.parse(response.body)
 
     # Data not always present so dont use fetch
-    PeakFlowUtils::NotifierResponse.new(
+    ::PeakFlowUtils::NotifierResponse.new(
       bug_report_id: response_data["bug_report_id"],
       bug_report_instance_id: response_data["bug_report_instance_id"],
       project_id: response_data["project_id"],
@@ -69,15 +127,4 @@ class PeakFlowUtils::Notifier
       url: response_data["url"]
     )
   end
-
-  def error_message_from_response(response)
-    message = "Couldn't report error to Peakflow (code #{response.code})"
-
-    if response["content-type"]&.starts_with?("application/json")
-      response_data = JSON.parse(response.body)
-      message << ": #{response_data.fetch("errors").join(". ")}" if response_data["errors"]
-    end
-
-    message
-  end
 end

data/lib/peak_flow_utils/notifier_rack.rb

@@ -9,13 +9,13 @@ class PeakFlowUtils::NotifierRack
   rescue Exception => e # rubocop:disable Lint/RescueException
     controller = env["action_controller.instance"]
     request = controller&.request
-    parameters = {}.merge(request.GET).merge(request.POST)
 
-    PeakFlowUtils::Notifier.notify(
-      environment: env,
-      error: e,
-      parameters: parameters
-    )
+    PeakFlowUtils::Notifier.with_parameters(rack: {get: request.GET, post: request.POST}) do
+      PeakFlowUtils::Notifier.notify(
+        environment: env,
+        error: e
+      )
+    end
 
     raise e
   end

data/lib/peak_flow_utils/thread_callbacks_patch.rb

@@ -0,0 +1,23 @@
+class Thread
+  alias_method :_initialize, :initialize # rubocop:disable Style/Alias
+
+  def self.on_initialize(&callback)
+    @@on_initialize_count = 0 if @on_initialize_count.nil? # rubocop:disable Style/ClassVars
+    count_to_use = @@on_initialize_count
+    @@on_initialize_count += 1 # rubocop:disable Style/ClassVars
+
+    @@on_initialize_callbacks ||= {} # rubocop:disable Style/ClassVars
+    @@on_initialize_callbacks[count_to_use] = callback
+
+    count_to_use
+  end
+
+  def initialize(*args, &block)
+    @@on_initialize_callbacks ||= {} # rubocop:disable Style/ClassVars
+    @@on_initialize_callbacks.each_value do |callback|
+      callback.call(parent: Thread.current, thread: self)
+    end
+
+    _initialize(*args, &block)
+  end
+end

data/lib/peak_flow_utils/version.rb

@@ -1,3 +1,3 @@
 module PeakFlowUtils
-  VERSION = "0.1.12".freeze
+  VERSION = "0.1.16".freeze
 end

data/lib/peak_flow_utils.rb

@@ -4,16 +4,19 @@ require "array_enumerator"
 require "service_pattern"
 
 module PeakFlowUtils
-  path = "#{File.dirname(__FILE__)}/peak_flow_utils"
-  models_path = "#{File.dirname(__FILE__)}/peak_flow_utils/models"
+  path = "#{__dir__}/peak_flow_utils"
+  models_path = "#{__dir__}/peak_flow_utils/models"
+  services_path = File.realpath("#{__dir__}/../app/services/peak_flow_utils")
 
+  autoload :ApplicationService, "#{services_path}/application_service"
+  autoload :DeepMerger, "#{services_path}/deep_merger"
+  autoload :InheritedLocalVar, "#{path}/inherited_local_var"
   autoload :Notifier, "#{path}/notifier"
   autoload :NotifierErrorParser, "#{path}/notifier_error_parser"
   autoload :NotifierRack, "#{path}/notifier_rack"
   autoload :NotifierRails, "#{path}/notifier_rails"
   autoload :NotifierResponse, "#{path}/notifier_response"
   autoload :NotifierSidekiq, "#{path}/notifier_sidekiq"
-  autoload :RspecHelper, "#{path}/rspec_helper"
   autoload :HandlerHelper, "#{path}/handler_helper"
 
   autoload :ApplicationRecord, "#{models_path}/application_record"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: peak_flow_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.16
 platform: ruby
 authors:
 - kaspernj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-06 00:00:00.000000000 Z
+date: 2022-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -58,9 +58,37 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.5
   type: :runtime
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: pry-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -111,8 +139,7 @@ dependencies:
 description: Utilities to be used with PeakFlow.
 email:
 - kaspernj@gmail.com
-executables:
-- peak_flow_rspec_files
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -135,6 +162,7 @@ files:
 - app/services/peak_flow_utils/attribute_service.rb
 - app/services/peak_flow_utils/configuration_service.rb
 - app/services/peak_flow_utils/database_initializer_service.rb
+- app/services/peak_flow_utils/deep_merger.rb
 - app/services/peak_flow_utils/erb_inspector.rb
 - app/services/peak_flow_utils/erb_inspector/file_inspector.rb
 - app/services/peak_flow_utils/erb_inspector/translation_inspector.rb
@@ -143,14 +171,14 @@ files:
 - app/services/peak_flow_utils/model_inspector.rb
 - app/services/peak_flow_utils/translation_service.rb
 - app/services/peak_flow_utils/translations_parser_service.rb
-- bin/peak_flow_rspec_files
 - config/routes.rb
 - lib/peak_flow_utils.rb
 - lib/peak_flow_utils/engine.rb
 - lib/peak_flow_utils/handler_helper.rb
+- lib/peak_flow_utils/inherited_local_var.rb
 - lib/peak_flow_utils/migrations/20150902155200_create_translation_keys.rb
+- lib/peak_flow_utils/migrations/20150907070908_create_handlers.rb
 - lib/peak_flow_utils/migrations/20150907070909_create_groups.rb
-- lib/peak_flow_utils/migrations/20150907090900_create_handlers.rb
 - lib/peak_flow_utils/migrations/20150908085500_create_translation_values.rb
 - lib/peak_flow_utils/migrations/20150908090800_create_handler_texts.rb
 - lib/peak_flow_utils/migrations/20160411190500_create_scanned_files.rb
@@ -167,7 +195,7 @@ files:
 - lib/peak_flow_utils/notifier_rails.rb
 - lib/peak_flow_utils/notifier_response.rb
 - lib/peak_flow_utils/notifier_sidekiq.rb
-- lib/peak_flow_utils/rspec_helper.rb
+- lib/peak_flow_utils/thread_callbacks_patch.rb
 - lib/peak_flow_utils/version.rb
 - lib/tasks/peak_flow_utils_tasks.rake
 homepage: https://github.com/kaspernj/peak_flow_utils
@@ -189,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.2.32
 signing_key: 
 specification_version: 4
 summary: Utilities to be used with PeakFlow.

data/bin/peak_flow_rspec_files

@@ -1,21 +0,0 @@
-#!/usr/bin/env ruby
-
-# This task detects and prints out the RSpec files for the current build group
-
-require "#{File.dirname(__FILE__)}/../lib/peak_flow_utils"
-
-args = {}
-ARGV.each do |arg|
-  if (match = arg.match(/\A--(.+?)=(.+)\Z/))
-    args[match[1]] = match[2]
-  end
-end
-
-rspec_helper = PeakFlowUtils::RspecHelper.new(
-  groups: args.fetch("groups").to_i,
-  group_number: args.fetch("group-number").to_i,
-  only_types: args["only-types"]&.split(","),
-  tags: args["tags"]&.split(",")
-)
-
-print rspec_helper.group_files.map { |group_file| group_file.fetch(:path) }.join(" ")

data/lib/peak_flow_utils/rspec_helper.rb

@@ -1,195 +0,0 @@
-class PeakFlowUtils::RspecHelper
-  attr_reader :only_types, :tags
-
-  def initialize(groups:, group_number:, only_types: nil, tags: nil)
-    @groups = groups
-    @group_number = group_number
-    @example_data_exists = File.exist?("spec/examples.txt")
-    @only_types = only_types
-    @tags = tags
-  end
-
-  def example_data_exists?
-    @example_data_exists
-  end
-
-  def example_data
-    @example_data ||= begin
-      raw_data = File.read("spec/examples.txt")
-
-      result = []
-      raw_data.scan(/^\.\/(.+)\[(.+?)\]\s+\|\s+(.+?)\s+\|\s+((.+?) seconds|)\s+\|$/) do |match|
-        file_path = match[0]
-        spec_result = match[1]
-        seconds = match[4]&.to_f
-
-        spec_data = {
-          file_path: file_path,
-          spec_result: spec_result,
-          seconds: seconds
-        }
-
-        result << spec_data
-      end
-
-      result
-    end
-  end
-
-  def example_files
-    @example_files ||= begin
-      files = {}
-      example_data.each do |spec_data|
-        file_path = spec_data.fetch(:file_path)
-        seconds = spec_data.fetch(:seconds)
-
-        files[file_path] ||= {examples: 0, seconds: 0.0}
-        files[file_path][:examples] += 1
-        files[file_path][:seconds] += seconds if seconds
-      end
-
-      files
-    end
-  end
-
-  def example_file(path)
-    example_files[path]
-  end
-
-  def group_files
-    return @group_files if @group_files
-
-    sorted_files.each do |file|
-      file_path = file.fetch(:path)
-      file_data = example_file(file_path) if example_data_exists?
-
-      if file_data
-        examples = file_data.fetch(:examples)
-        seconds = file_data.fetch(:seconds)
-      else
-        examples = file.fetch(:examples)
-      end
-
-      group = group_with_least
-      group[:examples] += examples
-      group[:files] << file
-      group[:seconds] += seconds if seconds
-    end
-
-    @group_files = group_orders[@group_number - 1].fetch(:files)
-  end
-
-  def group_orders
-    @group_orders ||= begin
-      group_orders = []
-      @groups.times do
-        group_orders << {
-          examples: 0,
-          files: [],
-          seconds: 0.0
-        }
-      end
-      group_orders
-    end
-  end
-
-  def group_with_least
-    group_orders.min do |group1, group2|
-      if example_data_exists? && group1.fetch(:seconds) != 0.0 && group2.fetch(:seconds) != 0.0
-        group1.fetch(:seconds) <=> group2.fetch(:seconds)
-      else
-        group1.fetch(:examples) <=> group2.fetch(:examples)
-      end
-    end
-  end
-
-  # Sort them so that they are sorted by file path in three groups so each group have an equal amount of controller specs, features specs and so on
-  def sorted_files
-    files.values.sort do |file1, file2|
-      file1_path = file1.fetch(:path)
-      file2_path = file2.fetch(:path)
-
-      file1_data = example_file(file1_path) if example_data_exists?
-      file2_data = example_file(file2_path) if example_data_exists?
-
-      if file1_data && file2_data && file1_data.fetch(:seconds) != 0.0 && file2_data.fetch(:seconds) != 0.0
-        value1 = file1_data[:seconds]
-      else
-        value1 = file1.fetch(:points)
-      end
-
-      if file2_data && file1_data && file2_data.fetch(:seconds) != 0.0 && file2_data.fetch(:seconds) != 0.0
-        value2 = file2_data[:seconds]
-      else
-        value2 = file2.fetch(:points)
-      end
-
-      if value1 == value2
-        value2 = file1_path
-        value1 = file2_path
-      end
-
-      value2 <=> value1
-    end
-  end
-
-private
-
-  def dry_result_command
-    command = "bundle exec rspec --dry-run --format json"
-
-    tags&.each do |tag|
-      command << " --tag #{tag}"
-    end
-
-    command
-  end
-
-  def dry_result
-    require "json"
-    @dry_result ||= ::JSON.parse(`#{dry_result_command}`)
-  end
-
-  def dry_file(path)
-    files.fetch(path)
-  end
-
-  def files
-    @files ||= begin
-      result = {}
-      dry_result.fetch("examples").each do |example|
-        file_path = example.fetch("file_path")
-        file_path = file_path[2, file_path.length]
-        type = type_from_path(file_path)
-        points = points_from_type(type)
-
-        next if ignore_type?(type)
-
-        result[file_path] = {examples: 0, path: file_path, points: 0, type: type} unless result.key?(file_path)
-        result[file_path][:examples] += 1
-        result[file_path][:points] += points
-      end
-
-      result
-    end
-  end
-
-  def ignore_type?(type)
-    only_types && !only_types.include?(type) # rubocop:disable Rails/NegateInclude:, Style/SafeNavigation
-  end
-
-  def type_from_path(file_path)
-    match = file_path.match(/^spec\/(.+?)\//)
-    match[1] if match
-  end
-
-  def points_from_type(type)
-    if type == "feature" || type == "system"
-      10
-    elsif type == "controllers"
-      3
-    else
-      1
-    end
-  end
-end