crystalball 0.5.0

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'action_view'
+
+module Crystalball
+  module Rails
+    class MapGenerator
+      class ActionViewStrategy
+        # 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
+            # replaces it with custom one
+            def apply!
+              ::ActionView::Template.class_eval do
+                include Patch
+
+                alias_method :cb_original_compile!, :compile!
+                alias_method :compile!, :cb_patched_compile!
+              end
+            end
+
+            # Reverts original behavior of `ActionView::Template#compile!`
+            def revert!
+              ::ActionView::Template.class_eval do
+                alias_method :compile!, :cb_original_compile! # rubocop:disable Lint/DuplicateMethods
+                undef_method :cb_patched_compile!
+              end
+            end
+          end
+
+          # Will replace original `ActionView::Template#compile!`. Pushes path of a view to
+          # `ActionViewStrategy.views` and calls original `compile!`
+          def cb_patched_compile!(*args)
+            ActionViewStrategy.views.push identifier
+            cb_original_compile!(*args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'crystalball/map_generator/base_strategy'
+require 'crystalball/map_generator/helpers/path_filter'
+require 'crystalball/rails/map_generator/i18n_strategy/simple_patch'
+
+module Crystalball
+  module Rails
+    class MapGenerator
+      # Map generator strategy to build map of locale files used by an example.
+      class I18nStrategy
+        include ::Crystalball::MapGenerator::BaseStrategy
+        include ::Crystalball::MapGenerator::Helpers::PathFilter
+
+        class << self
+          # List of locale files affected by current example
+          #
+          # @return [Array<String>]
+          def locale_files
+            @locale_files ||= []
+          end
+
+          # Reset cached list of locale files
+          def reset_locale_files
+            @locale_files = []
+          end
+        end
+
+        def after_register
+          SimplePatch.apply!
+        end
+
+        def before_finalize
+          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, _)
+          self.class.reset_locale_files
+          yield case_map
+          case_map.push(*filter(self.class.locale_files.compact))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'i18n'
+
+module Crystalball
+  module Rails
+    class MapGenerator
+      class I18nStrategy
+        # Module to add new patched `load_file`, `store_translations` and `lookup`
+        # methods to `I18n::Backend::Simple`.
+        module SimplePatch
+          class << self
+            # Patches `I18n::Backend::Simple`.
+            def apply!
+              ::I18n::Backend::Simple.class_eval do
+                include SimplePatch
+
+                %i[load_file store_translations lookup].each do |method|
+                  alias_method :"cb_original_#{method}", method
+                  alias_method method, :"cb_patched_#{method}"
+                end
+              end
+            end
+
+            # Reverts original behavior of `I18n::Backend::Simple`
+            def revert!
+              ::I18n::Backend::Simple.class_eval do
+                %i[load_file store_translations lookup].each do |method|
+                  alias_method method, :"cb_original_#{method}"
+                  undef_method :"cb_patched_#{method}"
+                end
+              end
+              ::I18n.reload!
+            end
+          end
+
+          # Will replace original `I18n::Backend::Simple#load_file`.
+          # Stores filename in current thread
+          def cb_patched_load_file(filename, *args)
+            Thread.current[:cb_locale_file_name] = filename
+            cb_original_load_file(filename, *args)
+          end
+
+          # Will replace original `I18n::Backend::Simple#store_translations`.
+          # Adds filename for each value
+          def cb_patched_store_translations(locale, data, *args)
+            cb_add_filename_to_values(data, Thread.current[:cb_locale_file_name])
+            cb_original_store_translations(locale, data, *args)
+          end
+
+          # Will replace original `I18n::Backend::Simple#lookup`.
+          # Records origin filename of each value used.
+          def cb_patched_lookup(*args)
+            value = cb_original_lookup(*args)
+            cb_remove_and_track_filename_from_values(value)
+          end
+
+          private
+
+          def cb_add_filename_to_values(data, filename)
+            data.each do |key, value|
+              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
+              end
+            end
+          end
+
+          def cb_remove_and_track_filename_from_values(data)
+            return data unless data.is_a?(Hash)
+
+            if data.key?(:cb_filename)
+              ::Crystalball::Rails::MapGenerator::I18nStrategy.locale_files << data[:cb_filename]
+              return data[:cb_value]
+            end
+
+            data.each.with_object({}) do |(key, value), collector|
+              collector[key] = cb_remove_and_track_filename_from_values(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/rspec/prediction_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Crystalball
+  module RSpec
+    # Class for building a prediction for RSpec runner.
+    # Accepts configuration hash and builds a prediction according to configuration.
+    class PredictionBuilder
+      attr_reader :config
+
+      def initialize(config = {})
+        @config = config
+      end
+
+      def prediction
+        base_predictor.prediction
+      end
+
+      def expired_map?
+        return false if config['map_expiration_period'] <= 0
+
+        map_commit = repo.gcommit(map.commit) || raise("Cant find map commit info #{map.commit}")
+
+        map_commit.date < Time.now - config['map_expiration_period']
+      end
+
+      def map
+        @map ||= Crystalball::MapStorage::YAMLStorage.load(config['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'])
+      end
+    end
+  end
+end

data/lib/crystalball/rspec/runner.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+require 'crystalball/rspec/prediction_builder'
+
+module Crystalball
+  module RSpec
+    # Our custom RSpec runner to run predictions
+    class Runner < ::RSpec::Core::Runner
+      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)
+        end
+
+        def reset!
+          self.prediction_builder = nil
+          self.config = nil
+        end
+
+        def prepare
+          config['runner_class'].load_map
+        end
+
+        def prediction_builder
+          @prediction_builder ||= PredictionBuilder.new(config)
+        end
+
+        def config
+          @config ||= begin
+            config_src = if config_file
+                           require 'yaml'
+                           YAML.safe_load(config_file.read)
+                         else
+                           {}
+                         end
+
+            Configuration.new(config_src)
+          end
+        end
+
+        protected
+
+        def load_map
+          check_map($stdout) unless ENV['CRYSTALBALL_SKIP_MAP_CHECK']
+          prediction_builder.map
+        end
+
+        private
+
+        attr_writer :config, :prediction_builder
+
+        def config_file
+          file = Pathname.new(ENV.fetch('CRYSTALBALL_CONFIG', 'crystalball.yml'))
+          file = Pathname.new('config/crystalball.yml') unless file.exist?
+          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
+        end
+
+        def check_map(out)
+          out.puts 'Maps are outdated!' if prediction_builder.expired_map?
+        end
+      end
+
+      def run_specs(example_groups)
+        check_examples_limit(example_groups)
+        super
+      end
+
+      def check_examples_limit(example_groups)
+        limit = self.class.config['examples_limit'].to_i
+        return if ENV['CRYSTALBALL_SKIP_EXAMPLES_LIMIT'] || !limit.positive?
+
+        examples_count = @world.example_count(example_groups)
+
+        return if examples_count <= limit
+
+        @configuration.output_stream.puts "Example group size (#{examples_count}) is over the limit (#{limit})"
+        @configuration.output_stream.puts "Aborting spec run"
+        exit
+      end
+    end
+  end
+end
+
+require 'crystalball/rspec/runner/configuration'

data/lib/crystalball/rspec/runner/configuration.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'crystalball/simple_predictor'
+
+module Crystalball
+  module RSpec
+    class Runner
+      # Class for storing local runner configuration
+      class Configuration
+        def initialize(config = {})
+          @values = {
+            'map_path' => 'tmp/execution_maps',
+            'map_expiration_period' => 86_400,
+            'repo_path' => Dir.pwd,
+            'predictor_class_name' => 'Crystalball::SimplePredictor',
+            'requires' => [],
+            'diff_from' => 'HEAD',
+            'diff_to' => nil,
+            'runner_class_name' => 'Crystalball::RSpec::Runner'
+          }.merge(config)
+        end
+
+        def to_h
+          dynamic_values = {}
+          (private_methods - Object.private_instance_methods - %i[run_requires values]).each do |method|
+            dynamic_values[method.to_s] = send(method)
+          end
+
+          values.merge(dynamic_values)
+        end
+
+        def [](key)
+          respond_to?(key, true) ? send(key) : values[key]
+        end
+
+        private
+
+        def predictor_class
+          @predictor_class ||= begin
+            run_requires
+
+            Object.const_get(self['predictor_class_name'])
+          end
+        end
+
+        def runner_class
+          @runner_class ||= begin
+            run_requires
+
+            Object.const_get(self['runner_class_name'])
+          end
+        end
+
+        def map_path
+          @map_path ||= Pathname.new(values['map_path'])
+        end
+
+        def repo_path
+          @repo_path ||= Pathname.new(values['repo_path'])
+        end
+
+        attr_reader :values
+
+        def run_requires
+          self['requires'].each { |f| require f }
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/simple_predictor.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'crystalball/predictor'
+require 'crystalball/predictor/modified_execution_paths'
+require 'crystalball/predictor/modified_specs'
+
+module Crystalball
+  # Class to predict test failures with given execution map and sources diff
+  class SimplePredictor < Predictor
+    def initialize(*args, &block)
+      super(*args) do |p|
+        p.use Crystalball::Predictor::ModifiedExecutionPaths.new
+        p.use Crystalball::Predictor::ModifiedSpecs.new
+        block&.call(p)
+      end
+    end
+  end
+end

data/lib/crystalball/source_diff.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'crystalball/source_diff/file_diff'
+
+module Crystalball
+  # Wrapper class representing Git source diff for given repo
+  class SourceDiff
+    include Enumerable
+    extend Forwardable
+
+    delegate %i[stats size lines from to] => :git_diff
+
+    # @param [Git::Diff] git_diff raw diff made by ruby-git gem
+    def initialize(git_diff)
+      @git_diff = git_diff
+    end
+
+    # Iterates over each changed file of diff
+    #
+    def each
+      changeset.each { |file| yield file }
+    end
+
+    def empty?
+      changeset.none?
+    end
+
+    private
+
+    attr_reader :git_diff
+
+    # TODO: Include untracked to changeset
+    def changeset
+      @changeset ||= git_diff.map { |file_diff| FileDiff.new(file_diff) }
+    end
+  end
+end