crystalball 0.5.0

data/lib/crystalball/map_generator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Crystalball
+  # Class to generate execution map during RSpec build execution
+  class MapGenerator
+    extend Forwardable
+
+    attr_reader :configuration
+    delegate %i[map_storage strategies dump_threshold map_class] => :configuration
+
+    class << self
+      # Registers Crystalball handlers to generate execution map during specs execution
+      #
+      # @param [Proc] block to configure MapGenerator and Register strategies
+      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! }
+        end
+      end
+    end
+
+    def initialize
+      @configuration = Configuration.new
+      @configuration.commit = repo.object('HEAD').sha if repo
+      yield @configuration if block_given?
+    end
+
+    # Registers strategies and prepares metadata for execution map
+    def start!
+      raise 'Repository is not pristine! Please stash all your changes' if repo && !repo.pristine?
+
+      self.map = nil
+      map_storage.clear!
+      map_storage.dump(map.metadata.to_h)
+
+      strategies.reverse.each(&:after_start)
+      self.started = true
+    end
+
+    # Runs example and collects execution map for it
+    def refresh_for_case(example)
+      map << strategies.run(CaseMap.new(example), example) { example.run }
+      check_dump_threshold
+    end
+
+    # Finalizes strategies and saves map
+    def finalize!
+      return unless started
+
+      strategies.each(&:before_finalize)
+      map_storage.dump(map.cases) if map.size.positive?
+    end
+
+    def map
+      @map ||= map_class.new(metadata: {commit: configuration.commit, version: configuration.version})
+    end
+
+    private
+
+    attr_writer :map
+    attr_accessor :started
+
+    def repo
+      @repo = GitRepo.open('.') unless defined?(@repo)
+      @repo
+    end
+
+    def check_dump_threshold
+      return unless dump_threshold.positive? && map.size >= dump_threshold
+
+      map_storage.dump(map.cases)
+      map.clear!
+    end
+  end
+end

data/lib/crystalball/map_generator/allocated_objects_strategy.rb

@@ -0,0 +1,44 @@
+# 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 affected files every file which contain the definition of the
+      # classes of the objects allocated during the spec execution.
+      # @param [Crystalball::CaseMap] case_map - object holding example metadata and affected files
+      def call(case_map, example)
+        classes = object_tracker.used_classes_during do
+          yield case_map, example
+        end
+        case_map.push(*execution_detector.detect(classes))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# 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/base_strategy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class MapGenerator
+    # Map generator strategy interface
+    module BaseStrategy
+      def after_register; end
+
+      def after_start; end
+
+      def before_finalize; end
+
+      # Each strategy must implement #call augmenting the affected_files list and
+      # yielding back the CaseMap.
+      # @param [Crystalball::CaseMap] _case_map - object holding example metadata and affected files
+      def call(_case_map, _example)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/crystalball/map_generator/configuration.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'crystalball/map_generator/strategies_collection'
+
+module Crystalball
+  class MapGenerator
+    # 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_accessor :commit
+      attr_accessor :version
+
+      attr_reader :strategies
+
+      def initialize
+        @strategies = StrategiesCollection.new
+      end
+
+      def map_class
+        @map_class ||= ExecutionMap
+      end
+
+      def map_storage_path
+        @map_storage_path ||= Pathname('execution_map.yml')
+      end
+
+      def map_storage_path=(value)
+        @map_storage_path = Pathname(value)
+      end
+
+      def map_storage
+        @map_storage ||= MapStorage::YAMLStorage.new(map_storage_path)
+      end
+
+      def dump_threshold
+        @dump_threshold ||= 100
+      end
+
+      def dump_threshold=(value)
+        @dump_threshold = value.to_i
+      end
+
+      # Register new strategy for map generation
+      #
+      # @param [Crystalball::MapGenerator::BaseStrategy] strategy
+      def register(strategy)
+        @strategies.push strategy
+        strategy.after_register
+      end
+    end
+  end
+end

data/lib/crystalball/map_generator/coverage_strategy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'coverage'
+require 'crystalball/map_generator/base_strategy'
+require 'crystalball/map_generator/coverage_strategy/execution_detector'
+
+module Crystalball
+  class MapGenerator
+    # Map generator strategy based on harvesting Coverage information during example execution
+    class CoverageStrategy
+      include BaseStrategy
+
+      attr_reader :execution_detector
+
+      def initialize(execution_detector = ExecutionDetector.new)
+        @execution_detector = execution_detector
+      end
+
+      def after_register
+        Coverage.start
+      end
+
+      # Adds to the case_map's affected files the ones the ones in which
+      # the coverage has changed after the tests runs.
+      # @param [Crystalball::CaseMap] case_map - object holding example metadata and affected files
+      def call(case_map, _)
+        before = Coverage.peek_result
+        yield case_map
+        after = Coverage.peek_result
+        case_map.push(*execution_detector.detect(before, after))
+      end
+    end
+  end
+end

data/lib/crystalball/map_generator/coverage_strategy/execution_detector.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/path_filter'
+
+module Crystalball
+  class MapGenerator
+    class CoverageStrategy
+      # Class for detecting code execution path based on coverage information diff
+      class ExecutionDetector
+        include ::Crystalball::MapGenerator::Helpers::PathFilter
+        # Detects files affected during example execution. Transforms absolute paths to relative.
+        # Exclude paths outside of repository
+        #
+        # @param[Array<String>] list of files affected before example execution
+        # @param[Array<String>] list of files affected after example execution
+        # @return [Array<String>]
+        def detect(before, after)
+          filter after.reject { |file_name, after_coverage| before[file_name] == after_coverage }.keys
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/map_generator/described_class_strategy.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'crystalball/map_generator/base_strategy'
+require 'crystalball/map_generator/object_sources_detector'
+
+module Crystalball
+  class MapGenerator
+    # Map generator strategy to get paths to files contains definition of described_class and its
+    # ancestors.
+    class DescribedClassStrategy
+      include BaseStrategy
+      extend Forwardable
+
+      attr_reader :execution_detector
+
+      delegate %i[after_register before_finalize] => :execution_detector
+
+      # @param [#detect] execution_detector - object that, given a list of objects,
+      #   returns the paths where the classes or modules of the list are defined
+      def initialize(execution_detector: ObjectSourcesDetector.new(root_path: Dir.pwd))
+        @execution_detector = execution_detector
+      end
+
+      # @param [Crystalball::CaseMap] case_map - object holding example metadata and affected files
+      # @param [RSpec::Core::Example] example
+      def call(case_map, example)
+        yield case_map
+
+        described_class = example.metadata[:described_class]
+
+        case_map.push(*execution_detector.detect([described_class])) if described_class
+      end
+    end
+  end
+end

data/lib/crystalball/map_generator/helpers/path_filter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class MapGenerator
+    module Helpers
+      # Helper module to filter file paths
+      module PathFilter
+        attr_reader :root_path
+
+        # @param [String] root_path - absolute path to root folder of repository
+        def initialize(root_path = Dir.pwd)
+          @root_path = root_path
+        end
+
+        # @param [Array<String>] paths
+        # @return relatve paths inside root_path only
+        def filter(paths)
+          paths
+            .select { |file_name| file_name.start_with?(root_path) }
+            .map { |file_name| file_name.sub("#{root_path}/", '') }
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/map_generator/object_sources_detector.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'crystalball/map_generator/helpers/path_filter'
+require 'crystalball/map_generator/object_sources_detector/hierarchy_fetcher'
+require 'crystalball/map_generator/object_sources_detector/definition_tracer'
+
+module Crystalball
+  class MapGenerator
+    # Class for files paths affected object definition
+    class ObjectSourcesDetector
+      include ::Crystalball::MapGenerator::Helpers::PathFilter
+
+      attr_reader :definition_tracer, :hierarchy_fetcher
+
+      def initialize(
+        root_path:,
+        definition_tracer: DefinitionTracer.new(root_path),
+        hierarchy_fetcher: HierarchyFetcher.new
+      )
+        super(root_path)
+
+        @definition_tracer = definition_tracer
+        @hierarchy_fetcher = hierarchy_fetcher
+      end
+
+      def after_register
+        definition_tracer.start
+      end
+
+      def before_finalize
+        definition_tracer.stop
+      end
+
+      # Detects files affected during example execution. Transforms absolute paths to relative.
+      # Exclude paths outside of repository
+      #
+      # @param[Array<String>] list of files affected before example execution
+      # @return [Array<String>]
+      def detect(objects)
+        modules = objects.map do |object|
+          object.is_a?(Module) ? object : object.class
+        end.uniq
+
+        paths = modules.flat_map do |mod|
+          hierarchy_fetcher.ancestors_for(mod).flat_map do |ancestor|
+            definition_tracer.constants_definition_paths[ancestor]
+          end
+        end.compact.uniq
+
+        filter paths
+      end
+    end
+  end
+end

data/lib/crystalball/map_generator/object_sources_detector/definition_tracer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class MapGenerator
+    class ObjectSourcesDetector
+      # Class to save paths to classes and modules definitions during code loading. Should be
+      # started as soon as possible. Use #constants_definition_paths to fetch traced info
+      class DefinitionTracer
+        attr_reader :trace_point, :constants_definition_paths, :root_path
+
+        def initialize(root_path)
+          @root_path = root_path
+          @constants_definition_paths = {}
+        end
+
+        def start
+          self.trace_point ||= TracePoint.new(:class) do |tp|
+            mod = tp.self
+            path = tp.path
+
+            next unless path&.start_with?(root_path)
+
+            constants_definition_paths[mod] ||= []
+            constants_definition_paths[mod] << path
+          end.tap(&:enable)
+        end
+
+        def stop
+          trace_point&.disable
+          self.trace_point = nil
+        end
+
+        private
+
+        attr_writer :trace_point, :constants_definition_paths
+      end
+    end
+  end
+end