crystalball 0.5.0 → 0.6.0

data/lib/crystalball/predictor/associated_specs.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require 'crystalball/predictor/strategy'
+
 module Crystalball
   class Predictor
     # Used with `predictor.use Crystalball::Predictor::AssociatedSpecs.new(from: %r{models/(.*).rb}, to: "./spec/models/%s_spec.rb")`.
     # When used will look for files matched to `from` regex and use captures to fill `to` string to
     # get paths of proper specs
     class AssociatedSpecs
+      include Strategy
+
       # @param [Regexp] from - regular expression to match specific files and get proper captures
       # @param [String] to - string in sprintf format to get proper files using captures of regexp
       def initialize(from:, to:)
@@ -13,14 +17,15 @@ module Crystalball
         @to = to
       end
 
-      # This strategy does not depend on a previously generated case map.
+      # This strategy does not depend on a previously generated example group map.
       # It uses the defined regex rules to infer which specs to run.
       # @param [Crystalball::SourceDiff] diff - the diff from which to predict
       #   which specs should run
       # @return [Array<String>] the spec paths associated with the changes
-      def call(diff, _)
-        diff.map(&:relative_path).grep(from)
-            .map { |source_file_path| to % captures(source_file_path) }
+      def call(diff, _map)
+        super do
+          diff.map(&:relative_path).grep(from).map { |source_file_path| to % captures(source_file_path) }
+        end
       end
 
       private

data/lib/crystalball/predictor/helpers/affected_example_groups_detector.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class Predictor
+    module Helpers
+      # Helper module to fetch example groups affected by given list of changed files
+      module AffectedExampleGroupsDetector
+        # Fetch examples affected by given list of files
+        # @param [Array<String>] files - list of files
+        # @param [Crystalball::ExecutionMap] map - execution map with examples
+        # @return [Array<String>] list of affected examples
+        def detect_examples(files, map)
+          map.example_groups.map do |uid, example_group_map|
+            uid if files.any? { |file| example_group_map.include?(file) }
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/predictor/helpers/path_formatter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class Predictor
+    module Helpers
+      # Helper module for converting relative path to RSpec format
+      module PathFormatter
+        def format_paths(paths)
+          paths.map { |path| format_path(path) }
+        end
+
+        def format_path(path)
+          path.start_with?('./') ? path : "./#{path}"
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/predictor/modified_execution_paths.rb

@@ -1,20 +1,26 @@
 # frozen_string_literal: true
 
+require 'crystalball/predictor/strategy'
+require 'crystalball/predictor/helpers/affected_example_groups_detector'
+
 module Crystalball
   class Predictor
     # Used with `predictor.use Crystalball::Predictor::ModifiedExecutionPaths.new`. When used will check the map which
     # specs depend on which files and will return only those specs which depend on files modified since last time map
     # was generated.
     class ModifiedExecutionPaths
+      include Helpers::AffectedExampleGroupsDetector
+      include Strategy
+
       # @param [Crystalball::SourceDiff] diff - the diff from which to predict
       #   which specs should run
-      # @param [Crystalball::CaseMap] map - the map with the relations of
-      #   examples and affected files
+      # @param [Crystalball::ExampleGroupMap] map - the map with the relations of
+      #   examples and used files
       # @return [Array<String>] the spec paths associated with the changes
       def call(diff, map)
-        map.cases.map do |uid, case_map|
-          uid if diff.any? { |file| case_map.include?(file.relative_path) }
-        end.compact
+        super do
+          detect_examples(diff.map(&:relative_path), map)
+        end
       end
     end
   end

data/lib/crystalball/predictor/modified_specs.rb

@@ -1,22 +1,28 @@
 # frozen_string_literal: true
 
+require 'crystalball/predictor/strategy'
+
 module Crystalball
   class Predictor
     # Used with `predictor.use Crystalball::Predictor::ModifiedSpecs.new`. Will find files that match spec regexp and
     # return all new or modified files. You can specify spec regexp using first parameter to `#initialize`.
     class ModifiedSpecs
+      include Strategy
+
       # @param [Regexp] spec_pattern - regexp to filter specs files
       def initialize(spec_pattern = %r{spec/.*_spec\.rb\z})
         @spec_pattern = spec_pattern
       end
 
-      # This strategy does not depend on a previously generated case map.
+      # This strategy does not depend on a previously generated example group map.
       # It uses the spec pattern to determine which specs should run.
       # @param [Crystalball::SourceDiff] diff - the diff from which to predict
       #   which specs should run
       # @return [Array<String>] the spec paths associated with the changes
       def call(diff, _)
-        diff.reject(&:deleted?).map(&:new_relative_path).grep(spec_pattern)
+        super do
+          diff.reject(&:deleted?).map(&:new_relative_path).grep(spec_pattern)
+        end
       end
 
       private

data/lib/crystalball/predictor/modified_support_specs.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'crystalball/predictor/strategy'
+require 'crystalball/predictor/helpers/affected_example_groups_detector'
+
+module Crystalball
+  class Predictor
+    # Used with `predictor.use Crystalball::Predictor::ModifiedSupportSpecs.new`. Will find files that match passed regexp and
+    # return full spec files which uses matched support spec files. Perfectly works for shared_context and shared_examples.
+    class ModifiedSupportSpecs
+      include Strategy
+      include Helpers::AffectedExampleGroupsDetector
+
+      # @param [Regexp] support_spec_pattern - regexp to filter support specs files
+      def initialize(support_spec_pattern = %r{spec/support/.*\.rb\z})
+        @support_spec_pattern = support_spec_pattern
+      end
+
+      # @param [Crystalball::SourceDiff] diff - the diff from which to predict
+      #   which specs should run
+      # @param [Crystalball::ExampleGroupMap] map - the map with the relations of
+      #   examples and used files
+      # @return [Array<String>] the spec paths associated with the changes
+      def call(diff, map)
+        super do
+          changed_support_files = diff.map(&:relative_path).grep(support_spec_pattern)
+
+          examples = detect_examples(changed_support_files, map)
+
+          examples.map { |e| e.to_s.split('[').first }.uniq
+        end
+      end
+
+      private
+
+      attr_reader :support_spec_pattern
+    end
+  end
+end

data/lib/crystalball/predictor/strategy.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'crystalball/predictor/helpers/path_formatter'
+
+module Crystalball
+  class Predictor
+    # Base module to include in any strategy. Provides output formatting similar to RSpec
+    module Strategy
+      include Helpers::PathFormatter
+
+      def call(*)
+        format_paths(yield)
+      end
+    end
+  end
+end

data/lib/crystalball/predictor_evaluator.rb

@@ -39,7 +39,7 @@ module Crystalball
     end
 
     def prediction_size
-      @prediction_size ||= predictor.map.cases.keys.select { |example| prediction.any? { |p| example.include?(p) } }.size
+      @prediction_size ||= predictor.map.example_groups.keys.select { |example| prediction.any? { |p| example.include?(p) } }.size
     end
 
     def map_size

data/lib/crystalball/rails.rb

@@ -2,6 +2,7 @@
 
 require 'crystalball/rails/map_generator/action_view_strategy'
 require 'crystalball/rails/map_generator/i18n_strategy'
+require 'crystalball/active_record'
 
 module Crystalball
   # Module containting Rails-specific stuff for Crystalball

data/lib/crystalball/rails/helpers/base_schema_parser.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Crystalball
+  module Rails
+    module Helpers
+      # Interface for schema parsers
+      module BaseSchemaParser
+        def self.parse(*_)
+          raise NotImplementedError
+        end
+
+        # @return [Hash] stored info about all method calls which ended in #method_missing
+        attr_accessor :hash
+
+        def initialize
+          @hash = {}
+        end
+
+        private
+
+        # Store info about call in hash. First argument of method call used as a key
+        def method_missing(method_name, *args, &block)
+          name = args.shift
+          add_to_hash(name, options: [method_name] + args)
+
+          new_parser = self.class.new
+          add_to_hash(name, content: new_parser.instance_exec(&block)) if block
+          add_to_hash(name, content: new_parser.hash)
+          new_parser
+        end
+
+        def respond_to_missing?(*_)
+          true
+        end
+
+        def add_to_hash(name, options: nil, content: nil)
+          hash[name] ||= {}
+          add_optional(name, :options, options)
+          add_optional(name, :content, content)
+        end
+
+        def add_optional(name, key, value)
+          return unless value
+
+          hash[name][key] ||= []
+          hash[name][key] << value
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/rails/helpers/schema_definition_parser.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'crystalball/rails/helpers/base_schema_parser'
+require 'crystalball/rails/helpers/schema_definition_parser/active_record'
+require 'crystalball/rails/helpers/schema_definition_parser/table_content_parser'
+
+module Crystalball
+  module Rails
+    module Helpers
+      # Class used to parse ActiveRecord::Schema definition and provide hash representation
+      class SchemaDefinitionParser
+        include BaseSchemaParser
+
+        # Parse schema content
+        # @param [String] schema - schema file content
+        # @return [Hash] hash representation of schema
+        def self.parse(schema)
+          return {} if schema&.empty?
+
+          new.instance_eval(schema)
+        end
+
+        private
+
+        def create_table(table_name, *options, &block)
+          add_to_hash(table_name, options: ['create_table'] + options, content: TableContentParser.parse(&block))
+        end
+
+        def add_foreign_key(table1, table2, *options)
+          add_to_hash(table1, options: ['add_foreign_key', table2] + options)
+          add_to_hash(table2, options: ['add_foreign_key', table1] + options) if table1 != table2
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/rails/helpers/schema_definition_parser/active_record.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Crystalball
+  module Rails
+    module Helpers
+      class SchemaDefinitionParser
+        # This mock will be used during SchemaDefinitionParser.parse
+        module ActiveRecord
+          # A simple mock to read definition of schema
+          class Schema
+            def self.define(*_args, &block)
+              collector = SchemaDefinitionParser.new
+              collector.instance_exec(collector, &block)
+              collector.hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/rails/helpers/schema_definition_parser/table_content_parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'crystalball/rails/helpers/base_schema_parser'
+
+module Crystalball
+  module Rails
+    module Helpers
+      class SchemaDefinitionParser
+        # Class used to parse ActiveRecord::Schema create_table definition and provide hash representation
+        class TableContentParser
+          include BaseSchemaParser
+
+          # Parse create_table definition of schema
+          # @param [Proc] block - block for create_table definition
+          # @return [Hash] hash representation of table definition
+          def self.parse(&block)
+            return {} unless block
+
+            collector = new
+            collector.instance_exec(collector, &block)
+            collector.hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,12 +33,12 @@ module Crystalball
           Patch.revert!
         end
 
-        # Adds views related to the spec to the case map
-        # @param [Crystalball::CaseMap] case_map - object holding example metadata and affected files
-        def call(case_map, _)
+        # 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 case_map
-          case_map.push(*filter(self.class.views))
+          yield example_group_map
+          example_group_map.push(*filter(self.class.views))
         end
       end
     end

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

@@ -9,7 +9,7 @@ module Crystalball
         # Module to add new patched `compile!` method to ActionView::Template
         module Patch
           class << self
-            # Patches `ActionView::Template#compile!`. Renames original `compile!` to `old_compile!` and
+            # Patches `ActionView::Template#compile!`. Renames original `compile!` to `cb_original_compile!` and
             # replaces it with custom one
             def apply!
               ::ActionView::Template.class_eval do

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

@@ -34,12 +34,12 @@ module Crystalball
           SimplePatch.revert!
         end
 
-        # Adds to the case map the locale files used by the example
-        # @param [Crystalball::CaseMap] case_map - object holding example metadata and affected files
-        def call(case_map, _)
+        # 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 case_map
-          case_map.push(*filter(self.class.locale_files.compact))
+          yield example_group_map
+          example_group_map.push(*filter(self.class.locale_files.compact))
         end
       end
     end

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

@@ -62,6 +62,7 @@ module Crystalball
               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

data/lib/crystalball/rails/predictor/modified_schema.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'crystalball/rails/helpers/schema_definition_parser'
+require 'crystalball/predictor/helpers/affected_example_groups_detector'
+
+module Crystalball
+  module Rails
+    class Predictor
+      # Used with `predictor.use Crystalball::Rails::Predictor::ModifiedSchema.new(tables_map_path:)`.
+      # When used will check db/schema.rb for changes and add specs which depend on files affected
+      # by changed tables
+      class ModifiedSchema
+        include ::Crystalball::Predictor::Helpers::AffectedExampleGroupsDetector
+        SCHEMA_PATH = 'db/schema.rb'
+
+        attr_reader :tables_map_path
+
+        # @param [String] tables_map_path - path to generated TablesMap
+        def initialize(tables_map_path:)
+          @tables_map_path = tables_map_path
+        end
+
+        # @param [Crystalball::SourceDiff] diff - the diff from which to predict
+        #   which specs should run
+        # @param [Crystalball::ExecutionMap] map - the map with the relations of
+        #   examples and used files
+        # @return [Array<String>] the spec paths associated with the changes
+        def call(diff, map)
+          return [] if schema_diff(diff).nil?
+
+          old_schema = old_schema(diff)
+          new_schema = new_schema(diff)
+
+          changed_tables = changed_tables(old_schema, new_schema)
+
+          files = changed_tables.flat_map do |table_name|
+            files = tables_map[table_name]
+            Crystalball.log :warn, "There are no model files for changed table `#{table_name}`. Check https://github.com/toptal/crystalball#warning for detailed description" unless files&.any?
+            files
+          end.compact
+          detect_examples(files, map)
+        end
+
+        # @return [Crystalball::Rails::TablesMap]
+        def tables_map
+          @tables_map ||= MapStorage::YAMLStorage.load(Pathname(tables_map_path))
+        end
+
+        private
+
+        def schema_diff(diff)
+          diff.find { |file_diff| [SCHEMA_PATH, "./#{SCHEMA_PATH}"].include? file_diff.relative_path }
+        end
+
+        def old_schema(diff)
+          old_schema_contents = schema_content(diff.repository, diff.from)
+          Crystalball::Rails::Helpers::SchemaDefinitionParser.parse(old_schema_contents)
+        end
+
+        def new_schema(diff)
+          new_schema_contents = schema_content(diff.repository, diff.to)
+          Crystalball::Rails::Helpers::SchemaDefinitionParser.parse(new_schema_contents)
+        end
+
+        def schema_content(repository, revision)
+          if revision
+            repository.lib.show(revision, SCHEMA_PATH)
+          else
+            File.read(File.join(repository.dir.path, SCHEMA_PATH))
+          end
+        end
+
+        def changed_tables(schema1, schema2)
+          schema1.map do |table_name, body|
+            table_name if schema2[table_name] != body
+          end.compact
+        end
+      end
+    end
+  end
+end