crystalball 0.5.0 → 0.6.0

data/lib/crystalball/rails/tables_map.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Crystalball
+  module Rails
+    # Storage for tables map
+    class TablesMap
+      extend Forwardable
+
+      # Simple data object for map metadata information
+      class Metadata
+        attr_reader :commit, :version
+
+        # @param [String] commit - SHA of commit
+        # @param [Numeric] version - map generator version number
+        def initialize(commit: nil, version: nil, **_)
+          @commit = commit
+          @version = version
+        end
+
+        def to_h
+          {type: TablesMap.name, commit: commit, version: version}
+        end
+      end
+
+      attr_reader :example_groups, :metadata
+
+      delegate %i[commit version] => :metadata
+      delegate %i[size [] []=] => :example_groups
+
+      # @param [Hash] metadata - add or override metadata of execution map
+      # @param [Hash] example_groups - initial list of tables
+      def initialize(metadata: {}, example_groups: {})
+        @metadata = Metadata.new(**metadata)
+        @example_groups = example_groups
+      end
+
+      # Remove all example_groups
+      def clear!
+        self.example_groups = {}
+      end
+
+      def add(files:, for_table:)
+        example_groups[for_table] ||= []
+        example_groups[for_table] += files
+        example_groups[for_table].uniq!
+      end
+
+      private
+
+      attr_writer :example_groups, :metadata
+    end
+  end
+end

data/lib/crystalball/rails/tables_map_generator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'crystalball/rails/tables_map'
+require 'crystalball/rails/tables_map_generator/configuration'
+
+module Crystalball
+  module Rails
+    # Class to generate tables to files map during RSpec build execution
+    class TablesMapGenerator
+      extend Forwardable
+
+      attr_reader :configuration
+      delegate %i[map_storage object_sources_detector] => :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.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?
+        object_sources_detector.after_register
+      end
+
+      # Prepares metadata for execution map
+      def start!
+        self.map = nil
+        map_storage.clear!
+
+        map_storage.dump(map.metadata.to_h)
+
+        self.started = true
+      end
+
+      # Finalizes and saves map
+      def finalize!
+        return unless started
+
+        collect_tables_info
+
+        object_sources_detector.before_finalize
+        map_storage.dump(map.example_groups) if map.size.positive?
+      end
+
+      # @return [Crystalball::Rails::TablesMap]
+      def map
+        @map ||= TablesMap.new(metadata: {commit: configuration.commit, version: configuration.version})
+      end
+
+      private
+
+      def repo
+        @repo = GitRepo.open('.') unless defined?(@repo)
+        @repo
+      end
+
+      def collect_tables_info
+        ActiveRecord::Base.descendants.each do |descendant|
+          table_name = descendant.table_name
+
+          next if table_name.nil?
+
+          files = object_sources_detector.detect([descendant])
+
+          map.add(files: files, for_table: table_name)
+        end
+      end
+
+      attr_writer :map
+      attr_accessor :started
+    end
+  end
+end

data/lib/crystalball/rails/tables_map_generator/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'crystalball/map_generator/object_sources_detector'
+
+module Crystalball
+  module Rails
+    class TablesMapGenerator
+      # Configuration of tables map generator. Is can be accessed as a first argument inside
+      # `Crystalball::Rails::TablesMapGenerator.start! { |config| config } block.
+      class Configuration
+        attr_writer :map_storage
+        attr_accessor :commit
+        attr_accessor :version
+        attr_writer :root_path
+        attr_writer :object_sources_detector
+
+        def map_storage_path
+          @map_storage_path ||= Pathname('tables_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 root_path
+          @root_path ||= Dir.pwd
+        end
+
+        def object_sources_detector
+          @object_sources_detector ||= ::Crystalball::MapGenerator::ObjectSourcesDetector.new(root_path: root_path)
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/rspec/filtering.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Crystalball
+  module RSpec
+    # This class is meant to remove the example filtering options
+    # for example_groups when a prediction contains a file path and the same file
+    # example id.
+    #
+    # For example, if a prediction contains `./spec/foo_spec.rb[1:1] ./spec/foo_spec.rb`,
+    # only `./spec/foo_spec.rb[1:1]` would run, because of the way RSpec
+    # filters are designed.
+    #
+    # Therefore, we need to manually remove the filters from such example_groups.
+    class Filtering
+      # @param [RSpec::Core::Configuration] config
+      # @param [Array<String>] paths
+      def self.remove_unnecessary_filters(config, paths)
+        new(config).remove_unnecessary_filters(paths)
+      end
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def remove_unnecessary_filters(files_or_directories)
+        directories, files = files_or_directories.partition { |f| File.directory?(f) }
+        remove_unecessary_filters_from_files(files)
+        remove_unecessary_filters_from_directories(directories)
+      end
+
+      def remove_unecessary_filters_from_directories(directories)
+        directories.each do |dir|
+          files = configuration.__send__(:gather_directories, dir)
+          remove_unecessary_filters_from_files(files)
+        end
+      end
+
+      def remove_unecessary_filters_from_files(files)
+        files.select { |f| ::RSpec::Core::Example.parse_id(f).last.nil? }.each do |file|
+          next remove_unecessary_filters(fd) if File.directory?(file)
+
+          path = ::RSpec::Core::Metadata.relative_path(File.expand_path(file))
+          configuration.filter_manager.inclusions[:ids]&.delete(path)
+        end
+      end
+
+      private
+
+      attr_reader :configuration
+    end
+  end
+end

data/lib/crystalball/rspec/prediction_builder.rb

@@ -14,29 +14,39 @@ module Crystalball
       end
 
       def prediction
-        base_predictor.prediction
+        predictor.prediction
       end
 
       def expired_map?
-        return false if config['map_expiration_period'] <= 0
+        expiration_period = config['map_expiration_period'].to_i
+        return false unless expiration_period.positive?
 
-        map_commit = repo.gcommit(map.commit) || raise("Cant find map commit info #{map.commit}")
-
-        map_commit.date < Time.now - config['map_expiration_period']
+        execution_map.timestamp.to_i <= Time.now.to_i - config['map_expiration_period']
       end
 
-      def map
-        @map ||= Crystalball::MapStorage::YAMLStorage.load(config['map_path'])
+      def execution_map
+        @execution_map ||= Crystalball::MapStorage::YAMLStorage.load(config['execution_map_path'])
       end
 
-      private
-
       def repo
         @repo ||= Crystalball::GitRepo.open(config['repo_path'])
       end
 
-      def base_predictor
-        @base_predictor ||= config['predictor_class'].new(map, repo, from: config['diff_from'], to: config['diff_to'])
+      private
+
+      # This method should be overridden in ancestor. Example:
+      #
+      # def predictor
+      #   super do |p|
+      #     p.use Crystalball::Predictor::ModifiedExecutionPaths.new
+      #     p.use Crystalball::Predictor::ModifiedSpecs.new
+      #   end
+      # end
+      #
+      def predictor(&block)
+        raise NotImplementedError, 'Configure `prediction_builder_class_name` in `crystalball.yml` and override `predictor` method' unless block_given?
+
+        @predictor ||= Crystalball::Predictor.new(execution_map, repo, from: config['diff_from'], to: config['diff_to'], &block)
       end
     end
   end

data/lib/crystalball/rspec/prediction_pruning.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'crystalball/rspec/prediction_pruning/examples_pruner'
+
+module Crystalball
+  module RSpec
+    # Module contains logic related to examples_limit configuration option for our runner.
+    module PredictionPruning
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Class methods for prediction pruning logic
+      module ClassMethods
+        def examples_limit
+          config['examples_limit'].to_i
+        end
+
+        private
+
+        def prune_prediction_to_limit(prediction)
+          return prediction if !examples_limit.positive? || prediction.size <= examples_limit
+
+          Crystalball.log :warn, "Prediction size #{prediction.size} is over the limit (#{examples_limit})"
+          Crystalball.log :warn, "Prediction is pruned to fit the limit!"
+
+          # Actual examples size is not less than prediction size.
+          prediction.first(examples_limit)
+        end
+      end
+
+      private
+
+      def examples_limit
+        self.class.examples_limit
+      end
+
+      def reconfiguration_needed?
+        examples_limit.positive? && @world.example_count > examples_limit
+      end
+
+      def reconfigure_to_limit
+        pruner = ExamplesPruner.new(@world, to: examples_limit)
+
+        @options = ::RSpec::Core::ConfigurationOptions.new(pruner.pruned_set)
+        @world.reset
+        @world.filtered_examples.clear
+        @world.instance_variable_get(:@example_group_counts_by_spec_file).clear
+        @configuration.reset
+        @configuration.reset_filters
+
+        @options.configure(@configuration)
+      end
+    end
+  end
+end

data/lib/crystalball/rspec/prediction_pruning/examples_pruner.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Crystalball
+  module RSpec
+    module PredictionPruning
+      # A class to prune given world example groups to fit the limit.
+      class ExamplesPruner
+        # Simple data object for holding context ids array with total examples size
+        class ContextIdsSet
+          attr_reader :ids, :size
+          alias to_a ids
+
+          def initialize
+            @size = 0
+            @ids = []
+          end
+
+          def add(id, size = 1)
+            @size += size
+            @ids << id
+          end
+        end
+
+        attr_reader :world, :limit
+
+        # @param [RSpec::Core::World] rspec_world RSpec world instance
+        # @param [Integer] to upper bound limit for prediction.
+        def initialize(rspec_world, to:)
+          @world = rspec_world
+          @limit = to
+        end
+
+        # @return [Array<String>] set of example and context ids to run
+        def pruned_set
+          resulting_set = ContextIdsSet.new
+          world.ordered_example_groups.each { |g| prune_to_limit(g, resulting_set) }
+          resulting_set.to_a
+        end
+
+        private
+
+        def prune_to_limit(group, resulting_set)
+          return if resulting_set.size >= limit
+
+          group_size = world.example_count([group])
+
+          if resulting_set.size + group_size > limit
+            (group.descendants - [group]).each do |g|
+              prune_to_limit(g, resulting_set)
+            end
+
+            add_examples(group, resulting_set)
+          else
+            resulting_set.add(group.id, group_size)
+          end
+        end
+
+        def add_examples(group, resulting_set)
+          limit_diff = limit - resulting_set.size
+
+          return unless limit_diff.positive?
+
+          group.filtered_examples.first(limit_diff).each do |example|
+            resulting_set.add(example.id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/rspec/runner.rb

@@ -2,17 +2,26 @@
 
 require 'rspec/core'
 require 'crystalball/rspec/prediction_builder'
+require 'crystalball/rspec/filtering'
+require 'crystalball/rspec/prediction_pruning'
 
 module Crystalball
   module RSpec
     # Our custom RSpec runner to run predictions
     class Runner < ::RSpec::Core::Runner
+      include PredictionPruning
+
       class << self
         def run(args, err = $stderr, out = $stdout)
           return config['runner_class'].run(args, err, out) unless config['runner_class'] == self
 
-          out.puts "Crystalball starts to glow..."
-          super(args + build_prediction(out), err, out)
+          Crystalball.log :info, "Crystalball starts to glow..."
+          prediction = build_prediction
+
+          Crystalball.log :debug, "Prediction: #{prediction.first(5).join(' ')}#{'...' if prediction.size > 5}"
+          Crystalball.log :info, "Starting RSpec."
+
+          super(args + prediction, err, out)
         end
 
         def reset!
@@ -21,11 +30,11 @@ module Crystalball
         end
 
         def prepare
-          config['runner_class'].load_map
+          config['runner_class'].load_execution_map
         end
 
         def prediction_builder
-          @prediction_builder ||= PredictionBuilder.new(config)
+          @prediction_builder ||= config['prediction_builder_class'].new(config)
         end
 
         def config
@@ -43,9 +52,9 @@ module Crystalball
 
         protected
 
-        def load_map
-          check_map($stdout) unless ENV['CRYSTALBALL_SKIP_MAP_CHECK']
-          prediction_builder.map
+        def load_execution_map
+          check_map
+          prediction_builder.execution_map
         end
 
         private
@@ -58,35 +67,38 @@ module Crystalball
           file.exist? ? file : nil
         end
 
-        def build_prediction(out)
-          check_map(out) unless ENV['CRYSTALBALL_SKIP_MAP_CHECK']
-          prediction = prediction_builder.prediction.compact
-          out.puts "Prediction: #{prediction.first(5).join(' ')}#{'...' if prediction.size > 5}"
-          out.puts "Starting RSpec."
-          prediction
+        def build_prediction
+          check_map
+          prune_prediction_to_limit(prediction_builder.prediction.sort_by(&:length))
         end
 
-        def check_map(out)
-          out.puts 'Maps are outdated!' if prediction_builder.expired_map?
+        def check_map
+          Crystalball.log :warn, 'Maps are outdated!' if prediction_builder.expired_map?
         end
       end
 
-      def run_specs(example_groups)
-        check_examples_limit(example_groups)
-        super
-      end
+      def setup(err, out)
+        configure(err, out)
+        @configuration.load_spec_files
 
-      def check_examples_limit(example_groups)
-        limit = self.class.config['examples_limit'].to_i
-        return if ENV['CRYSTALBALL_SKIP_EXAMPLES_LIMIT'] || !limit.positive?
+        Filtering.remove_unnecessary_filters(@configuration, @options.options[:files_or_directories_to_run])
 
-        examples_count = @world.example_count(example_groups)
+        if reconfiguration_needed?
+          Crystalball.log :warn, "Prediction examples size #{@world.example_count} is over the limit (#{examples_limit})"
+          Crystalball.log :warn, "Prediction is pruned to fit the limit!"
 
-        return if examples_count <= limit
+          reconfigure_to_limit
+          @configuration.load_spec_files
+        end
+
+        @world.announce_filters
+      end
 
-        @configuration.output_stream.puts "Example group size (#{examples_count}) is over the limit (#{limit})"
-        @configuration.output_stream.puts "Aborting spec run"
-        exit
+      # Backward compatibility for RSpec < 3.7
+      def configure(err, out)
+        @configuration.error_stream = err
+        @configuration.output_stream = out if @configuration.output_stream == $stdout
+        @options.configure(@configuration)
       end
     end
   end