gitlab-crystalball 0.8.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfe4631fc79255c0c4091aca48807cb31f7a596730233b3afaa5a7cf1e913be7
-  data.tar.gz: af6a47b8418995cd7845041d8a0c773ecfb40c64d1cd3c3e0292a574979b5a1a
+  metadata.gz: 0f042eadd4e47f777de23c64b43723187f1f1ae907cea2c28dbf037f78b0bf8a
+  data.tar.gz: 8a6ba30fcf62bfd0ab606ecf696c018577c5822f856f9d8bc1112842ac5d48bb
 SHA512:
-  metadata.gz: b8c59e192fe8be3eee41156660274e82338122e9057b2323c5a72adc66a570ea99b3dc5bbf6aa99f4c4742fbdfebb81c07fc01bf0f7565fcfdf2380fccbe2ce2
-  data.tar.gz: f2352dc108e8ffa284b4a4505f5df7312f970771f573cfdf46bfa9d93090f2a88136c0e9bb39ab393ddcd8411dc8bacbd2e40d064ef5b5aa89f9acc6266acfc9
+  metadata.gz: d3b53dc72d8378fb0e0a5de23f15090a9c2ad04ee30f329c29da6863efd94dc9e3556c102a23d43b052e0d8a6273fa5682b6adf8978e594a4e8821b9b3e86094
+  data.tar.gz: 78eb78621614e18e319558343ba8c20a2464b05b9ae382fc1eec49cea1708dfefbabfbb47628a7e7f9d0c4bc45272de765269df8072f87f4efca688590f5c081

data/README.md

@@ -1,7 +1,7 @@
 # Crystalball
 
 ![Build Status](https://gitlab.com/gitlab-org/ruby/gems/crystalball/badges/main/pipeline.svg)
-![Test Coverage](https://gitlab.com/gitlab-org/ruby/gems/crystalball/badges/main/coverage.svg?job=rspec%20spec)
+![Test Coverage](https://gitlab.com/gitlab-org/ruby/gems/crystalball/badges/main/coverage.svg?job=rspec)
 
 Crystalball is a Ruby library which implements [Regression Test Selection mechanism](https://tenderlovemaking.com/2015/02/13/predicting-test-failues.html) originally published by Aaron Patterson.
 Its main purpose is to select a minimal subset of your test suite which should be run to ensure your changes didn't break anything.

data/lib/crystalball/example_group_map.rb

@@ -3,9 +3,10 @@
 module Crystalball
   # Data object to store execution map for specific example
   class ExampleGroupMap
-    attr_reader :uid, :file_path, :used_files
     extend Forwardable
 
+    attr_reader :uid, :file_path, :used_files
+
     delegate %i[push each] => :used_files
 
     # @param [Example|ExampleGroup] example - RSpec example or example group

data/lib/crystalball/execution_map.rb

@@ -20,7 +20,7 @@ module Crystalball
       end
 
       def to_h
-        {type: type, commit: commit, timestamp: timestamp, version: version}
+        { type: type, commit: commit, timestamp: timestamp, version: version }
       end
     end
 

data/lib/crystalball/logging.rb

@@ -6,9 +6,11 @@ module Crystalball
   # This module logs information to the standard output based on the configured log level,
   # and also logs unfiltered information to the configured log file.
   module Logging
-    def log(severity_sym, *args, &block)
-      output_stream.log(severity(severity_sym), *args, &block)
-      log_file_output_stream.log(severity(severity_sym), *args, &block)
+    def log(severity_sym, message, prefix_class_name: false)
+      msg = prefix_class_name ? "[#{self.class.name.split('::').last}] #{message}" : message
+
+      output_stream.log(severity(severity_sym), msg)
+      log_file_output_stream.log(severity(severity_sym), msg)
     end
 
     def self.extended(base)
@@ -26,7 +28,7 @@ module Crystalball
     end
 
     def output_stream
-      @output_stream ||= ::Logger.new(STDOUT).tap do |logger|
+      @output_stream ||= ::Logger.new(STDOUT, progname: "crystalball").tap do |logger|
         logger.level = severity(configured_level)
       end
     end

data/lib/crystalball/map_generator/base_strategy.rb

@@ -4,19 +4,40 @@ module Crystalball
   class MapGenerator
     # Map generator strategy interface
     module BaseStrategy
+      include Logging
+
       def after_register; end
 
       def after_start; end
 
       def before_finalize; end
 
-      # Each strategy must implement #call augmenting the used_files list and
-      # yielding back the ExampleGroupMap.
-      # @param [Crystalball::ExampleGroupMap] _example_map - object holding example metadata and used files
-      # @param [RSpec::Core::Example] _example - a RSpec example
-      def call(_example_map, _example)
+      # Run before the execution of the example or example group
+      #
+      # @param _example [RSpec::Core::ExampleGroup, RSpec::Core::Example]
+      # @return [void]
+      def run_before(_example)
+        raise NotImplementedError
+      end
+
+      # Run after the execution of the example or example group
+      #
+      # @param _example_map [Crystalball::ExampleGroupMap]
+      # @param _example [RSpec::Core::ExampleGroup, RSpec::Core::Example]
+      # @return [Crystalball::ExampleGroupMap]
+      def run_after(_example_map, _example)
         raise NotImplementedError
       end
+
+      private
+
+      # Print debug log messages with included strategy class name prefix
+      #
+      # @param msg [String]
+      # @return [void]
+      def log_debug(msg)
+        log(:debug, msg, prefix_class_name: true)
+      end
     end
   end
 end

data/lib/crystalball/map_generator/configuration.rb

@@ -7,15 +7,14 @@ module Crystalball
     # Configuration of map generator. Is can be accessed as a first argument inside
     # `Crystalball::MapGenerator.start! { |config| config } block.
     class Configuration
-      attr_writer :map_storage
-      attr_writer :map_class
+      attr_writer :map_storage, :map_class
       attr_accessor :commit, :version, :compact_map
-
-      attr_reader :strategies
+      attr_reader :strategies, :hook_type
 
       def initialize
         @strategies = StrategiesCollection.new
         @compact_map = true
+        @hook_type = :example
       end
 
       def compact_map?
@@ -46,6 +45,13 @@ module Crystalball
         @dump_threshold = value.to_i
       end
 
+      def hook_type=(type)
+        valid_types = %i[example context]
+        raise ArgumentError, "hook type should be one of #{valid_types}" unless valid_types.include?(type)
+
+        @hook_type = type
+      end
+
       # Register new strategy for map generation
       #
       # @param [Crystalball::MapGenerator::BaseStrategy] strategy

data/lib/crystalball/map_generator/coverage_strategy.rb

@@ -14,22 +14,33 @@ module Crystalball
 
       def initialize(execution_detector: ExecutionDetector.new)
         @execution_detector = execution_detector
+        @before_coverage = nil
       end
 
       def after_register
-        Coverage.start(lines: true) unless Coverage.running?
+        return if Coverage.running?
+
+        log_debug("Starting coverage capture")
+        Coverage.start(lines: true)
+      end
+
+      def run_before(example)
+        log_debug("Fetching current coverage state before execution of example id: #{example.id}")
+        @before_coverage = Coverage.peek_result
       end
 
-      # Adds to the example_map's used files the ones the ones in which
-      # the coverage has changed after the tests runs.
-      # @param [Crystalball::ExampleGroupMap] example_map - object holding example metadata and used files
-      # @param [RSpec::Core::Example] example - a RSpec example
-      def call(example_map, example)
-        before = Coverage.peek_result
-        yield example_map, example
-        after = Coverage.peek_result
-        example_map.push(*execution_detector.detect(before, after))
+      def run_after(example_map, example)
+        log_debug("Recording mappings for example id: #{example.id}")
+        mappings = execution_detector.detect(before_coverage, Coverage.peek_result)
+        log_debug("#{example.id} recorded #{mappings.size} files")
+        example_map.push(*mappings)
+      ensure
+        @before_coverage = nil
       end
+
+      private
+
+      attr_reader :before_coverage
     end
   end
 end

data/lib/crystalball/map_generator/described_class_strategy.rb

@@ -9,6 +9,7 @@ module Crystalball
     # ancestors.
     class DescribedClassStrategy
       include BaseStrategy
+
       extend Forwardable
 
       attr_reader :execution_detector
@@ -21,14 +22,21 @@ module Crystalball
         @execution_detector = execution_detector
       end
 
+      def run_before(_example); end
+
       # @param [Crystalball::ExampleGroupMap] example_map - object holding example metadata and used files
       # @param [RSpec::Core::Example] example - a RSpec example
-      def call(example_map, example)
-        yield example_map, example
-
+      def run_after(example_map, example)
+        log_debug("Recording mappings for example id: #{example.id}")
         described_class = example.metadata[:described_class]
 
-        example_map.push(*execution_detector.detect([described_class])) if described_class
+        if described_class
+          mappings = execution_detector.detect([described_class])
+          log_debug("#{example.id} recorded #{mappings.size} files")
+          example_map.push(*mappings)
+        else
+          log_debug("#{example.id} did not record any mappings because it has no described_class")
+        end
       end
     end
   end

data/lib/crystalball/map_generator/oneshot_coverage_strategy.rb

@@ -10,36 +10,30 @@ module Crystalball
     # Map generator strategy based on harvesting Coverage information during example execution
     class OneshotCoverageStrategy
       include BaseStrategy
-      include Logging
       include Helpers::PathFilter
 
       def after_register
         raise "Coverage must not be started for oneshot_line strategy" if Coverage.running?
       end
 
+      def run_before(_example)
+        log_debug("Starting oneshot_line coverage capture")
+        return Coverage.start(oneshot_lines: true) unless Coverage.running?
+
+        log(:warn, "Coverage has been already started, restarting coverage for oneshot_lines!", prefix_class_name: true)
+        Coverage.result(stop: true, clear: true)
+        Coverage.start(oneshot_lines: true)
+      end
+
       # Adds to the example_map's used files the ones the ones in which
       # the coverage has changed after the tests runs.
       # @param [Crystalball::ExampleGroupMap] example_map - object holding example metadata and used files
       # @param [RSpec::Core::Example] example - a RSpec example
-      def call(example_map, example)
-        start_coverage
-        yield example_map, example
+      def run_after(example_map, example)
         paths = filter(Coverage.result(stop: true, clear: true).keys)
-        log(:debug, "[Crystalball] #{example.id} recorded #{paths.size} files")
+        log_debug("#{example.id} recorded #{paths.size} files")
         example_map.push(*paths)
       end
-
-      # Start coverage or restart it if it was already started
-      #
-      # @return [void] <description>
-      def start_coverage
-        log(:debug, "[Crystalball] Starting oneshot_line coverage capture")
-        return Coverage.start(oneshot_lines: true) unless Coverage.running?
-
-        log(:warn, "[Crystalball] Coverage has been already started, restarting coverage for oneshot_lines!")
-        Coverage.result(stop: true, clear: true)
-        Coverage.start(oneshot_lines: true)
-      end
     end
   end
 end

data/lib/crystalball/map_generator/strategies_collection.rb

@@ -10,11 +10,24 @@ module Crystalball
         @strategies = strategies
       end
 
-      # Calls every strategy on the given example group map and returns the modified example group map
-      # @param [Crystalball::ExampleGroupMap] example_group_map - initial example group map
-      # @return [Crystalball::ExampleGroupMap] example group map augmented by each strategy
-      def run(example_group_map, example, &block)
-        run_for_strategies(example_group_map, example, *_strategies.reverse, &block)
+      # Run before hook action for example or example group
+      #
+      # @param example [RSpec::Core::Example]
+      # @return [void]
+      def run_before(example)
+        _strategies.reverse_each { |strategy| strategy.run_before(example) }
+      end
+
+      # Run after hook action for example or example group and update example group map
+      #
+      # @param example_group_map [ExampleGroupMap]
+      # @param example [RSpec::Core::Example]
+      # @return [ExampleGroupMap]
+      def run_after(example_group_map, example)
+        _strategies.reverse_each do |strategy|
+          strategy.run_after(example_group_map, example)
+        end
+
         example_group_map
       end
 
@@ -31,13 +44,6 @@ module Crystalball
       def _strategies
         @strategies
       end
-
-      def run_for_strategies(example_group_map, example, *strats, &block)
-        return yield(example_group_map) if strats.empty?
-
-        strat = strats.shift
-        strat.call(example_group_map, example) { |c| run_for_strategies(c, example, *strats, &block) }
-      end
     end
   end
 end

data/lib/crystalball/map_generator.rb

@@ -3,9 +3,11 @@
 module Crystalball
   # Class to generate execution map during RSpec build execution
   class MapGenerator
+    include Logging
     extend Forwardable
 
     attr_reader :configuration
+
     delegate %i[map_storage strategies dump_threshold map_class] => :configuration
 
     class << self
@@ -15,12 +17,17 @@ module Crystalball
       def start!(&block)
         generator = new(&block)
 
-        ::RSpec.configure do |c|
-          c.before(:suite) { generator.start! }
-
-          c.around(:each) { |e| generator.refresh_for_case(e) }
-
-          c.after(:suite) { generator.finalize! }
+        ::RSpec.configure do |config|
+          config.before(:suite) { generator.start! }
+          config.after(:suite) { generator.finalize! }
+
+          if generator.configuration.hook_type == :example
+            config.prepend_before(:example) { |e| generator.execute_before(e) }
+            config.append_after(:example) { |e| generator.execute_after(e) }
+          else
+            config.prepend_before(:context) { |e| generator.execute_before(e.class) }
+            config.append_after(:context) { |e| generator.execute_after(e.class) }
+          end
         end
       end
     end
@@ -33,6 +40,8 @@ module Crystalball
 
     # Registers strategies and prepares metadata for execution map
     def start!
+      log_with_prefix("Starting Crystalball execution map builder")
+
       self.map = nil
       map_storage.clear!
       map_storage.dump(map.metadata.to_h)
@@ -41,26 +50,47 @@ module Crystalball
       self.started = true
     end
 
-    # Runs example and collects execution map for it
-    def refresh_for_case(example)
-      map << strategies.run(ExampleGroupMap.new(example), example) { example.run }
-      check_dump_threshold
+    # Run before step of strategy for given example or example group
+    #
+    # @param example [RSpec::Core::ExampleGroup, RSpec::Core::Example]
+    # @return [void]
+    def execute_before(example)
+      strategies.run_before(example)
+    end
+
+    # Run after step and collect execution map
+    #
+    # @param example [RSpec::Core::ExampleGroup, RSpec::Core::Example]
+    # @return [void]
+    def execute_after(example)
+      result = strategies.run_after(ExampleGroupMap.new(example), example)
+      # do not populate map with nil values
+      map << result unless result.used_files.empty?
+      check_dump_threshold!
     end
 
     # Finalizes strategies and saves map
     def finalize!
       return unless started
 
+      log_with_prefix("Finalizing mappings strategies and saving final map")
       strategies.each(&:before_finalize)
 
-      return unless map.size.positive?
+      unless map.size.positive?
+        log_with_prefix("No files recorded in the execution map")
+        return
+      end
 
       example_groups = (configuration.compact_map? ? MapCompactor.compact_map!(map) : map).example_groups
-      map_storage.dump(example_groups)
+      dump_map_storage(example_groups)
     end
 
     def map
-      @map ||= map_class.new(metadata: {commit: configuration.commit&.sha, timestamp: configuration.commit&.date&.to_i, version: configuration.version})
+      @map ||= map_class.new(metadata: {
+        commit: configuration.commit&.sha,
+        timestamp: configuration.commit&.date&.to_i,
+        version: configuration.version
+      })
     end
 
     private
@@ -68,17 +98,35 @@ module Crystalball
     attr_writer :map
     attr_accessor :started
 
+    def strategy_classes
+      @strategy_classes ||= strategies.map { |strategy| strategy.class.name.split("::").last }.join("|")
+    end
+
     def repo
       @repo = GitRepo.open(".") unless defined?(@repo)
       @repo
     end
 
-    def check_dump_threshold
+    def check_dump_threshold!
       return if configuration.compact_map
       return unless dump_threshold.positive? && map.size >= dump_threshold
 
-      map_storage.dump(map.example_groups)
+      log_with_prefix("Intermediate dump threshold (#{dump_threshold}) reached!")
+      dump_map_storage(map.example_groups)
+    end
+
+    def dump_map_storage(example_groups)
+      log_with_prefix("Dumping #{example_groups.size} examples to #{configuration.map_storage_path} file")
+      map_storage.dump(example_groups)
       map.clear!
     end
+
+    # Log message with prefix containing strategy names
+    #
+    # @param message [String]
+    # @return [void]
+    def log_with_prefix(message)
+      log(:info, "[#{strategy_classes}]: #{message}")
+    end
   end
 end

data/lib/crystalball/rails/map_generator/action_view_strategy/patch.rb

@@ -23,7 +23,7 @@ module Crystalball
             # Reverts original behavior of `ActionView::Template#compile!`
             def revert!
               ::ActionView::Template.class_eval do
-                alias_method :compile!, :cb_original_compile! # rubocop:disable Lint/DuplicateMethods
+                alias_method :compile!, :cb_original_compile!
                 undef_method :cb_patched_compile!
               end
             end

data/lib/crystalball/rails/map_generator/action_view_strategy.rb

@@ -33,12 +33,23 @@ module Crystalball
           Patch.revert!
         end
 
+        # Reset affected views before test execution starts
+        #
+        # @param _example [RSpec::Core::Example, RSpec::Core::ExampleGroup]
+        # @return [void]
+        def run_before(_example)
+          self.class.reset_views
+        end
+
         # Adds views related to the spec to the example group map
+        #
         # @param [Crystalball::ExampleGroupMap] example_group_map - object holding example metadata and used files
-        def call(example_group_map, _)
-          self.class.reset_views
-          yield example_group_map
-          example_group_map.push(*filter(self.class.views))
+        # @return [void]
+        def run_after(example_group_map, example)
+          log_debug("Recording mappings for example id: #{example.id}")
+          mappings = filter(self.class.views)
+          log_debug("#{example.id} recorded #{mappings.size} files")
+          example_group_map.push(*mappings)
         end
       end
     end

data/lib/crystalball/rails.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "crystalball/rails/map_generator/action_view_strategy"
-require "crystalball/rails/map_generator/i18n_strategy"
 require "crystalball/active_record"
 
 module Crystalball

data/lib/crystalball/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Crystalball
-  VERSION = "0.8.2"
+  VERSION = "1.0.0"
 end

data/lib/crystalball.rb

@@ -17,7 +17,6 @@ require "crystalball/map_generator"
 require "crystalball/map_generator/configuration"
 require "crystalball/map_generator/coverage_strategy"
 require "crystalball/map_generator/oneshot_coverage_strategy"
-require "crystalball/map_generator/allocated_objects_strategy"
 require "crystalball/map_generator/described_class_strategy"
 require "crystalball/map_storage/yaml_storage"
 require "crystalball/map_compactor"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-crystalball
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Developer Experience Team
 bindir: bin
 cert_chain: []
-date: 2025-05-20 00:00:00.000000000 Z
+date: 2025-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -238,32 +238,22 @@ files:
 - lib/crystalball/extensions/git.rb
 - lib/crystalball/extensions/git/base.rb
 - lib/crystalball/extensions/git/lib.rb
-- lib/crystalball/factory_bot.rb
 - lib/crystalball/git_repo.rb
 - lib/crystalball/logging.rb
 - lib/crystalball/map_compactor.rb
 - lib/crystalball/map_compactor/example_context.rb
 - lib/crystalball/map_compactor/example_groups_data_compactor.rb
 - lib/crystalball/map_generator.rb
-- lib/crystalball/map_generator/allocated_objects_strategy.rb
-- lib/crystalball/map_generator/allocated_objects_strategy/object_tracker.rb
 - lib/crystalball/map_generator/base_strategy.rb
 - lib/crystalball/map_generator/configuration.rb
 - lib/crystalball/map_generator/coverage_strategy.rb
 - lib/crystalball/map_generator/coverage_strategy/execution_detector.rb
 - lib/crystalball/map_generator/described_class_strategy.rb
-- lib/crystalball/map_generator/factory_bot_strategy.rb
-- lib/crystalball/map_generator/factory_bot_strategy/dsl_patch.rb
-- lib/crystalball/map_generator/factory_bot_strategy/dsl_patch/factory_path_fetcher.rb
-- lib/crystalball/map_generator/factory_bot_strategy/factory_gem_loader.rb
-- lib/crystalball/map_generator/factory_bot_strategy/factory_runner_patch.rb
 - lib/crystalball/map_generator/helpers/path_filter.rb
 - lib/crystalball/map_generator/object_sources_detector.rb
 - lib/crystalball/map_generator/object_sources_detector/definition_tracer.rb
 - lib/crystalball/map_generator/object_sources_detector/hierarchy_fetcher.rb
 - lib/crystalball/map_generator/oneshot_coverage_strategy.rb
-- lib/crystalball/map_generator/parser_strategy.rb
-- lib/crystalball/map_generator/parser_strategy/processor.rb
 - lib/crystalball/map_generator/strategies_collection.rb
 - lib/crystalball/map_storage/yaml_storage.rb
 - lib/crystalball/prediction.rb
@@ -283,8 +273,6 @@ files:
 - lib/crystalball/rails/helpers/schema_definition_parser/table_content_parser.rb
 - lib/crystalball/rails/map_generator/action_view_strategy.rb
 - lib/crystalball/rails/map_generator/action_view_strategy/patch.rb
-- lib/crystalball/rails/map_generator/i18n_strategy.rb
-- lib/crystalball/rails/map_generator/i18n_strategy/simple_patch.rb
 - lib/crystalball/rails/predictor/modified_schema.rb
 - lib/crystalball/rails/tables_map.rb
 - lib/crystalball/rails/tables_map_generator.rb

data/lib/crystalball/factory_bot.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "crystalball/map_generator/factory_bot_strategy"

data/lib/crystalball/map_generator/allocated_objects_strategy/object_tracker.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-
-module Crystalball
-  class MapGenerator
-    class AllocatedObjectsStrategy
-      # Class to list object classes used during a block
-      class ObjectTracker
-        attr_reader :only_of
-
-        # @param [Array<Module>] only_of - classes or modules to watch on
-        def initialize(only_of: ["Object"])
-          @only_of = only_of
-          @created_object_classes = Set.new
-        end
-
-        # @yield a block to execute
-        # @return [Array<Object>] classes of objects allocated during the block execution
-        def used_classes_during(&block)
-          self.created_object_classes = Set.new
-          trace_point.enable(&block)
-          created_object_classes
-        end
-
-        private
-
-        attr_accessor :created_object_classes
-
-        def whitelisted_constants
-          @whitelisted_constants ||= only_of.map { |str| Object.const_get(str) }
-        end
-
-        def trace_point
-          @trace_point ||= TracePoint.new(:c_call) do |tp|
-            next unless tp.method_id == :new || tp.method_id == :allocate
-            next unless whitelisted_constants.any? { |c| tp.self <= c }
-
-            created_object_classes << tp.self
-          end
-        end
-      end
-    end
-  end
-end

data/lib/crystalball/map_generator/allocated_objects_strategy.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "crystalball/map_generator/base_strategy"
-require "crystalball/map_generator/object_sources_detector"
-require "crystalball/map_generator/allocated_objects_strategy/object_tracker"
-
-module Crystalball
-  class MapGenerator
-    # Map generator strategy to get paths to files contains definition for all objects and its
-    # ancestors allocated during test example.
-    class AllocatedObjectsStrategy
-      include BaseStrategy
-      extend Forwardable
-
-      attr_reader :execution_detector, :object_tracker
-
-      delegate %i[after_register before_finalize] => :execution_detector
-
-      def self.build(only: [], root: Dir.pwd)
-        hierarchy_fetcher = ObjectSourcesDetector::HierarchyFetcher.new(only)
-        execution_detector = ObjectSourcesDetector.new(root_path: root, hierarchy_fetcher: hierarchy_fetcher)
-
-        new(execution_detector: execution_detector, object_tracker: ObjectTracker.new(only_of: only))
-      end
-
-      # @param [#detect] execution_detector
-      # @param [#created_during] object_tracker
-      def initialize(execution_detector:, object_tracker:)
-        @object_tracker = object_tracker
-        @execution_detector = execution_detector
-      end
-
-      # Adds to the used files every file which contain the definition of the
-      # classes of the objects allocated during the spec execution.
-      # @param [Crystalball::ExampleGroupMap] example_map - object holding example metadata and used files
-      # @param [RSpec::Core::Example] example - a RSpec example
-      def call(example_map, example)
-        classes = object_tracker.used_classes_during do
-          yield example_map, example
-        end
-        example_map.push(*execution_detector.detect(classes))
-      end
-    end
-  end
-end

data/lib/crystalball/map_generator/factory_bot_strategy/dsl_patch/factory_path_fetcher.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Crystalball
-  class MapGenerator
-    class FactoryBotStrategy
-      module DSLPatch
-        # This module is used to fetch file path with factory definition from callstack
-        module FactoryPathFetcher
-          # Fetches file path with factory definition from callstack
-          #
-          # @return [String]
-          def self.fetch
-            factories_definition_paths = FactoryBotStrategy
-                                         .factory_bot_constant
-                                         .definition_file_paths
-                                         .map { |path| Pathname(path).expand_path.to_s }
-
-            factory_definition_call = caller.find do |method_call|
-              factories_definition_paths.any? do |path|
-                method_call.start_with?(path)
-              end
-            end
-
-            factory_definition_call.split(":").first
-          end
-        end
-      end
-    end
-  end
-end

data/lib/crystalball/map_generator/factory_bot_strategy/dsl_patch.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "crystalball/map_generator/factory_bot_strategy/dsl_patch/factory_path_fetcher"
-
-module Crystalball
-  class MapGenerator
-    class FactoryBotStrategy
-      # Module to add new `factory` method to FactoryBot::Syntax::Default::DSL and FactoryBot::Syntax::Default::ModifyDSL
-      module DSLPatch
-        class << self
-          # Patches `FactoryBot::Syntax::Default::DSL#factory` and `FactoryBot::Syntax::Default::ModifyDSL#factory`.
-          def apply!
-            classes_to_patch.each { |klass| klass.prepend DSLPatch }
-          end
-
-          private
-
-          def classes_to_patch
-            [
-              FactoryBotStrategy.factory_bot_constant::Syntax::Default::DSL,
-              FactoryBotStrategy.factory_bot_constant::Syntax::Default::ModifyDSL
-            ]
-          end
-        end
-
-        # Overrides `FactoryBot::Syntax::Default::DSL#factory` and `FactoryBot::Syntax::Default::ModifyDSL#factory`.
-        # Pushes path of a factory to `FactoryBotStrategy.factory_definitions` and calls original `factory`
-        def factory(*args, &block)
-          factory_path = FactoryPathFetcher.fetch
-          name = args.first.to_s
-
-          FactoryBotStrategy.factory_definitions[name] ||= []
-          FactoryBotStrategy.factory_definitions[name] << factory_path
-
-          super
-        end
-      end
-    end
-  end
-end

data/lib/crystalball/map_generator/factory_bot_strategy/factory_gem_loader.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Crystalball
-  class MapGenerator
-    class FactoryBotStrategy
-      # A helper module to load `factory_bot` or `factory_girl`
-      module FactoryGemLoader
-        class << self
-          NAMES = %w[factory_bot factory_girl].freeze
-
-          # Tries to require `factory_bot` first. Requires `factory_girl` if `factory_bot` is not available
-          # Raises `LoadError` if both of them are not available.
-          def require!
-            NAMES.any? do |factory_gem_name|
-              begin
-                require factory_gem_name
-                true
-              rescue LoadError
-                false
-              end
-            end || (raise LoadError, "Can't load `factory_bot` or `factory_girl`")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/crystalball/map_generator/factory_bot_strategy/factory_runner_patch.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Crystalball
-  class MapGenerator
-    class FactoryBotStrategy
-      # Module to add new `run` method to FactoryBot::FactoryRunner
-      module FactoryRunnerPatch
-        class << self
-          # Patches `FactoryBot::FactoryRunner#run`.
-          def apply!
-            FactoryBotStrategy.factory_bot_constant::FactoryRunner.prepend FactoryRunnerPatch
-          end
-        end
-
-        # Overrides `FactoryBot::FactoryRunner#run`. Pushes factory name to
-        # `FactoryBotStrategy.used_factories` and calls original `run`
-        def run(*)
-          factory = FactoryBotStrategy.factory_bot_constant.factory_by_name(@name)
-          FactoryBotStrategy.used_factories << factory.name.to_s
-          super
-        end
-      end
-    end
-  end
-end

data/lib/crystalball/map_generator/factory_bot_strategy.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "crystalball/map_generator/factory_bot_strategy/factory_gem_loader"
-
-Crystalball::MapGenerator::FactoryBotStrategy::FactoryGemLoader.require!
-
-require "crystalball/map_generator/base_strategy"
-require "crystalball/map_generator/helpers/path_filter"
-require "crystalball/map_generator/factory_bot_strategy/dsl_patch"
-require "crystalball/map_generator/factory_bot_strategy/factory_runner_patch"
-
-module Crystalball
-  class MapGenerator
-    # Map generator strategy to include list of strategies which was used in an example.
-    class FactoryBotStrategy
-      include ::Crystalball::MapGenerator::BaseStrategy
-      include ::Crystalball::MapGenerator::Helpers::PathFilter
-
-      class << self
-        def factory_bot_constant
-          defined?(::FactoryBot) ? ::FactoryBot : ::FactoryGirl
-        end
-
-        # List of factories used by current example
-        #
-        # @return [Array<String>]
-        def used_factories
-          @used_factories ||= []
-        end
-
-        # Map of factories to files
-        #
-        # @return [Hash<String, String>]
-        def factory_definitions
-          @factory_definitions ||= {}
-        end
-
-        # Reset cached list of factories
-        def reset_used_factories
-          @used_factories = []
-        end
-      end
-
-      def after_register
-        DSLPatch.apply!
-        FactoryRunnerPatch.apply!
-      end
-
-      # Adds factories related to the spec to the map
-      # @param [Crystalball::ExampleGroupMap] example_map - object holding example metadata and used files
-      # @param [RSpec::Core::Example] example - a RSpec example
-      def call(example_map, example)
-        self.class.reset_used_factories
-        yield example_map, example
-        example_map.push(*filter(self.class.used_factories.flat_map { |f| self.class.factory_definitions[f] }))
-      end
-    end
-  end
-end

data/lib/crystalball/map_generator/parser_strategy/processor.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require "parser/current"
-
-module Crystalball
-  class MapGenerator
-    class ParserStrategy
-      # Parses the given source files and adds the class and module definitions
-      # to the `consts_defined` array.
-      class Processor
-        def consts_defined_in(path)
-          self.current_scope = nil
-          self.consts_defined = []
-          parse_and_process(path)
-          consts_defined
-        end
-
-        def consts_interacted_with_in(path)
-          self.current_scope = nil
-          self.consts_interacted_with = []
-          parse_and_process(path)
-          consts_interacted_with
-        end
-
-        protected
-
-        attr_accessor :consts_defined, :consts_interacted_with, :current_scope
-
-        private
-
-        def on_send(node)
-          const = filtered_children(node).detect { |c| c.type == :const }
-          return unless const
-
-          add_constant_interacted(qualified_name_from_node(const), nil)
-        end
-
-        def on_casgn(node)
-          namespace, name, = node.children
-          scope_name = namespace ? qualified_name(qualified_name_from_node(namespace), current_scope) : current_scope
-          add_constant_defined(name, scope_name)
-        end
-
-        def on_class(node)
-          const, superclass, body = node.children
-          add_constant_interacted(qualified_name_from_node(superclass), current_scope) if superclass
-          process_class_or_module(const, body)
-        end
-
-        def on_module(node)
-          const, body = node.children
-          process_class_or_module(const, body)
-        end
-
-        def process_class_or_module(const, body)
-          const_name = qualified_name_from_node(const)
-          result = add_constant_defined(const_name, current_scope)
-          self.current_scope = result if body && nested_consts?(body)
-        end
-
-        def nested_consts?(node)
-          filtered_children(node).any? { |c| %i[const casgn].include?(c.type) || nested_consts?(c) }
-        end
-
-        def filtered_children(node)
-          return [] unless node.is_a?(Parser::AST::Node)
-
-          node.children.grep(Parser::AST::Node)
-        end
-
-        def parse_and_process(path)
-          node = Parser::CurrentRuby.parse(File.read(path))
-          process_node_and_children(node)
-        rescue Parser::SyntaxError
-          nil
-        end
-
-        # @param  [AST::Node, nil] node
-        # @return [String, nil]
-        def process(node)
-          return if node.nil?
-
-          on_handler = :"on_#{node.type}"
-          __send__(on_handler, node) if respond_to?(on_handler, true)
-        end
-
-        def process_node_and_children(node)
-          process(node)
-          filtered_children(node).each do |child|
-            process_node_and_children(child)
-          end
-        end
-
-        def add_constant_defined(name, scope)
-          add_constant(name, scope, collection: consts_defined)
-        end
-
-        def add_constant_interacted(name, scope)
-          add_constant(name, scope, collection: consts_interacted_with)
-        end
-
-        def add_constant(name, scope, collection:)
-          collection ||= []
-          qualified_const_name = qualified_name(name, scope)
-          collection << qualified_const_name
-          qualified_const_name
-        end
-
-        # @param [Parser::AST::Node] node - :const node in format s(:const, scope, :ConstName)
-        #   where scope can be `nil` or another :const node.
-        #   For example, `Foo::Bar` is represented as `s(:const, s(:const, nil, :Foo), :Bar)`
-        def qualified_name_from_node(node)
-          return unless node.is_a?(Parser::AST::Node)
-
-          scope, name = node.to_a
-          return name.to_s unless scope
-
-          qualified_name(name, qualified_name_from_node(scope))
-        end
-
-        def qualified_name(name, scope = nil)
-          return "#{scope.sub(/\A::/, '')}::#{name}" if scope
-
-          name.to_s
-        end
-      end
-    end
-  end
-end

data/lib/crystalball/map_generator/parser_strategy.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "crystalball/map_generator/parser_strategy/processor"
-require "crystalball/map_generator/helpers/path_filter"
-
-module Crystalball
-  class MapGenerator
-    # Map generator strategy based on parsing source files to detect constant definition
-    # and tracing method calls on those constants.
-    class ParserStrategy
-      include BaseStrategy
-      include Helpers::PathFilter
-
-      attr_reader :const_definition_paths
-
-      def initialize(root = Dir.pwd, pattern:)
-        @root_path = Pathname.new(root).realpath.to_s
-        @processor = Processor.new
-        @const_definition_paths = {}
-        @pattern = pattern
-      end
-
-      def after_register
-        files_to_inspect.each do |path|
-          processor.consts_defined_in(path).each do |const|
-            (const_definition_paths[const] ||= []) << path
-          end
-        end
-      end
-
-      # Parses the current example group map seeking calls to class methods and adds
-      #   the classes to the map.
-      # @param [Crystalball::ExampleGroupMap] example_map - object holding example metadata and used files
-      # @param [RSpec::Core::Example] example - a RSpec example
-      def call(example_map, example)
-        paths = []
-        yield example_map, example
-        example_map.each do |path|
-          next unless path.end_with?(".rb")
-
-          used_consts = processor.consts_interacted_with_in(path)
-          paths.push(*used_files(used_consts))
-        end
-        example_map.push(*filter(paths))
-      end
-
-      private
-
-      attr_reader :processor, :pattern, :root_path
-
-      def used_files(used_consts)
-        const_definition_paths.select { |k, _| Array(used_consts).include?(k) }.values.flatten
-      end
-
-      def files_to_inspect
-        Dir.glob(File.join(root_path, "**/*.rb")).grep(pattern)
-      end
-    end
-  end
-end

data/lib/crystalball/rails/map_generator/i18n_strategy/simple_patch.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require "i18n"
-
-module Crystalball
-  module Rails
-    class MapGenerator
-      class I18nStrategy
-        # Module to add new patched `load_file`, `store_translations` and `lookup`
-        # methods to `I18n::Backend::Simple`.
-        module SimplePatch
-          class << self
-            # Patches `I18n::Backend::Simple`.
-            def apply!
-              ::I18n::Backend::Simple.class_eval do
-                include SimplePatch
-
-                %i[load_file store_translations lookup].each do |method|
-                  alias_method :"cb_original_#{method}", method
-                  alias_method method, :"cb_patched_#{method}"
-                end
-              end
-            end
-
-            # Reverts original behavior of `I18n::Backend::Simple`
-            def revert!
-              ::I18n::Backend::Simple.class_eval do
-                %i[load_file store_translations lookup].each do |method|
-                  alias_method method, :"cb_original_#{method}"
-                  undef_method :"cb_patched_#{method}"
-                end
-              end
-              ::I18n.reload!
-            end
-          end
-
-          # Will replace original `I18n::Backend::Simple#load_file`.
-          # Stores filename in current thread
-          def cb_patched_load_file(filename, *args)
-            Thread.current[:cb_locale_file_name] = filename
-            cb_original_load_file(filename, *args)
-          end
-
-          # Will replace original `I18n::Backend::Simple#store_translations`.
-          # Adds filename for each value
-          def cb_patched_store_translations(locale, data, *args)
-            cb_add_filename_to_values(data, Thread.current[:cb_locale_file_name])
-            cb_original_store_translations(locale, data, *args)
-          end
-
-          # Will replace original `I18n::Backend::Simple#lookup`.
-          # Records origin filename of each value used.
-          def cb_patched_lookup(*args)
-            value = cb_original_lookup(*args)
-            cb_remove_and_track_filename_from_values(value)
-          end
-
-          private
-
-          def cb_add_filename_to_values(data, filename)
-            data.each do |key, value|
-              case value
-              when Hash
-                next if value.frozen?
-
-                cb_add_filename_to_values(value, filename)
-              else
-                data[key] = {cb_filename: filename, cb_value: value}.freeze
-              end
-            end
-          end
-
-          def cb_remove_and_track_filename_from_values(data)
-            return data unless data.is_a?(Hash)
-
-            if data.key?(:cb_filename)
-              ::Crystalball::Rails::MapGenerator::I18nStrategy.locale_files << data[:cb_filename]
-              return data[:cb_value]
-            end
-
-            data.each.with_object({}) do |(key, value), collector|
-              collector[key] = cb_remove_and_track_filename_from_values(value)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/crystalball/rails/map_generator/i18n_strategy.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "crystalball/map_generator/base_strategy"
-require "crystalball/map_generator/helpers/path_filter"
-require "crystalball/rails/map_generator/i18n_strategy/simple_patch"
-
-module Crystalball
-  module Rails
-    class MapGenerator
-      # Map generator strategy to build map of locale files used by an example.
-      class I18nStrategy
-        include ::Crystalball::MapGenerator::BaseStrategy
-        include ::Crystalball::MapGenerator::Helpers::PathFilter
-
-        class << self
-          # List of locale files affected by current example
-          #
-          # @return [Array<String>]
-          def locale_files
-            @locale_files ||= []
-          end
-
-          # Reset cached list of locale files
-          def reset_locale_files
-            @locale_files = []
-          end
-        end
-
-        def after_register
-          SimplePatch.apply!
-        end
-
-        def before_finalize
-          SimplePatch.revert!
-        end
-
-        # Adds to the example group map the locale files used by the example
-        # @param [Crystalball::ExampleGroupMap] example_group_map - object holding example metadata and used files
-        def call(example_group_map, _)
-          self.class.reset_locale_files
-          yield example_group_map
-          example_group_map.push(*filter(self.class.locale_files.compact))
-        end
-      end
-    end
-  end
-end