crystalball 0.5.0 → 0.6.0

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/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/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/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/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/strategies_collection.rb

@@ -10,12 +10,12 @@ module Crystalball
         @strategies = strategies
       end
 
-      # Calls every strategy on the given case map and returns the modified case map
-      # @param [Crystalball::CaseMap] case_map - initial case map
-      # @return [Crystalball::CaseMap] case map augmented by each strategy
-      def run(case_map, example, &block)
-        run_for_strategies(case_map, example, *_strategies.reverse, &block)
-        case_map
+      # 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)
@@ -32,11 +32,11 @@ module Crystalball
         @strategies
       end
 
-      def run_for_strategies(case_map, example, *strats, &block)
-        return yield(case_map) if strats.empty?
+      def run_for_strategies(example_group_map, example, *strats, &block)
+        return yield(example_group_map) if strats.empty?
 
         strat = strats.shift
-        strat.call(case_map, example) { |c| run_for_strategies(c, example, *strats, &block) }
+        strat.call(example_group_map, example) { |c| run_for_strategies(c, example, *strats, &block) }
       end
     end
   end

data/lib/crystalball/map_storage/yaml_storage.rb

@@ -17,11 +17,11 @@ module Crystalball
         # @param [String] path to map
         # @return [Crystalball::ExecutionMap]
         def load(path)
-          meta, cases = *read_files(path).transpose
+          meta, example_groups = *read_files(path).transpose
 
           guard_metadata_consistency(meta)
 
-          Object.const_get(meta.first[:type]).new(metadata: meta.first, cases: cases.inject(&:merge!))
+          Object.const_get(meta.first[:type]).new(metadata: meta.first, example_groups: example_groups.inject(&:merge!))
         end
 
         private
@@ -29,15 +29,15 @@ module Crystalball
         def read_files(path)
           paths = path.directory? ? path.each_child.select(&:file?) : [path]
 
-          raise NoFilesFoundError unless paths.any?(&:exist?)
+          raise NoFilesFoundError, "No files or folder exists #{path}" unless paths.any?(&:exist?)
 
           paths.map do |file|
-            metadata, *cases = file.read.split("---\n").reject(&:empty?).map do |yaml|
+            metadata, *example_groups = file.read.split("---\n").reject(&:empty?).map do |yaml|
               YAML.safe_load(yaml, [Symbol])
             end
-            cases = cases.inject(&:merge!)
+            example_groups = example_groups.inject(&:merge!)
 
-            [metadata, cases]
+            [metadata, example_groups]
           end
         end
 
@@ -61,6 +61,7 @@ module Crystalball
       #
       # @param [Hash] data to write to storage file
       def dump(data)
+        path.dirname.mkpath
         path.open('a') { |f| f.write YAML.dump(data) }
       end
     end

data/lib/crystalball/prediction.rb

@@ -3,32 +3,33 @@
 module Crystalball
   # Class for Crystalball prediction results
   class Prediction
-    def initialize(cases)
-      @cases = cases
+    def initialize(records)
+      @records = records
     end
 
+    # When the records are something like:
+    #   ./spec/foo ./spec/foo/bar_spec.rb
+    # this returns just ./spec/foo
     def compact
-      result = []
-      sort_by(&:length).each do |c|
-        result << c unless result.any? { |r| c.start_with?(r, "./#{r}") }
-      end
-      result
+      sort_by(&:length).each_with_object([]) do |c, result|
+        result << c unless result.any? { |r| c.start_with?(r) }
+      end.compact
     end
 
     def to_a
-      cases
+      records
     end
 
     def method_missing(*args, &block)
-      cases.respond_to?(*args) ? cases.public_send(*args, &block) : super
+      records.respond_to?(*args) ? records.public_send(*args, &block) : super
     end
 
     def respond_to_missing?(*args)
-      cases.respond_to?(*args)
+      records.respond_to?(*args)
     end
 
     private
 
-    attr_reader :cases
+    attr_reader :records
   end
 end

data/lib/crystalball/predictor.rb

@@ -29,10 +29,12 @@ module Crystalball
     def prediction
       Prediction.new(filter(raw_prediction(diff)))
     end
-    alias cases prediction
 
     def diff
-      repo.diff(from, to)
+      @diff ||= begin
+                  ancestor = repo.merge_base(from, to || 'HEAD').sha
+                  repo.diff(ancestor, to)
+                end
     end
 
     private
@@ -45,11 +47,11 @@ module Crystalball
 
     attr_reader :repo
 
-    def filter(raw_cases)
-      raw_cases.compact.select { |example| example_to_file_path(example).exist? }.uniq
+    def filter(example_groups)
+      example_groups.compact.select { |example_group| extract_file_path(example_group).exist? }.uniq
     end
 
-    def example_to_file_path(example)
+    def extract_file_path(example)
       repo.repo_path.join(example.split('[').first).expand_path
     end
   end