gitlab-crystalball 0.7.1

data/lib/crystalball/map_generator/coverage_strategy.rb

@@ -0,0 +1,35 @@
+# 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 unless Coverage.running?
+      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))
+      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::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
+
+        described_class = example.metadata[:described_class]
+
+        example_map.push(*execution_detector.detect([described_class])) if described_class
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,40 @@
+# 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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,59 @@
+# 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/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/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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class MapGenerator
+    class ObjectSourcesDetector
+      # Class to get full hierarchy of a module(including singleton_class)
+      class HierarchyFetcher
+        attr_reader :stop_modules
+
+        # @param [Array<String>] stop_modules - list of classes or modules which
+        #   will be used to stop hierarchy lookup
+        def initialize(stop_modules = [])
+          @stop_modules = stop_modules
+        end
+
+        # @param [Module] mod - the module for which to fetch the ancestors
+        # @return [Array<Module>] list of ancestors of a module
+        def ancestors_for(mod)
+          (pick_ancestors(mod) + pick_ancestors(mod.singleton_class)).uniq
+        end
+
+        private
+
+        def stop_consts
+          @stop_consts ||= stop_modules.map { |str| Object.const_get(str) }
+        end
+
+        def pick_ancestors(mod)
+          ancestors = mod.ancestors
+          index = ancestors.index { |k| stop_consts.include?(k) } || ancestors.size
+          ancestors[0...index]
+        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/parser_strategy/processor.rb

@@ -0,0 +1,129 @@
+# 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

@@ -0,0 +1,60 @@
+# 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/map_generator/strategies_collection.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class MapGenerator
+    # Manages map generation strategies
+    class StrategiesCollection
+      include Enumerable
+
+      def initialize(strategies = [])
+        @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)
+        example_group_map
+      end
+
+      def method_missing(method_name, *args, &block)
+        _strategies.public_send(method_name, *args, &block) || super
+      end
+
+      def respond_to_missing?(method_name, *_args)
+        _strategies.respond_to?(method_name, false) || super
+      end
+
+      private
+
+      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