crystalball 0.5.0

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/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 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
+      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(case_map, example, *strats, &block)
+        return yield(case_map) if strats.empty?
+
+        strat = strats.shift
+        strat.call(case_map, example) { |c| run_for_strategies(c, example, *strats, &block) }
+      end
+    end
+  end
+end

data/lib/crystalball/map_storage/yaml_storage.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Crystalball
+  class MapStorage
+    # Exception class for missing map files
+    class NoFilesFoundError < StandardError; end
+
+    # YAML persistence adapter for execution map storage
+    class YAMLStorage
+      attr_reader :path
+
+      class << self
+        # Loads map from given path
+        #
+        # @param [String] path to map
+        # @return [Crystalball::ExecutionMap]
+        def load(path)
+          meta, cases = *read_files(path).transpose
+
+          guard_metadata_consistency(meta)
+
+          Object.const_get(meta.first[:type]).new(metadata: meta.first, cases: cases.inject(&:merge!))
+        end
+
+        private
+
+        def read_files(path)
+          paths = path.directory? ? path.each_child.select(&:file?) : [path]
+
+          raise NoFilesFoundError unless paths.any?(&:exist?)
+
+          paths.map do |file|
+            metadata, *cases = file.read.split("---\n").reject(&:empty?).map do |yaml|
+              YAML.safe_load(yaml, [Symbol])
+            end
+            cases = cases.inject(&:merge!)
+
+            [metadata, cases]
+          end
+        end
+
+        def guard_metadata_consistency(metadata)
+          uniq = metadata.uniq
+          raise "Can't load execution maps with different metadata. Metadata: #{uniq}" if uniq.size > 1
+        end
+      end
+
+      # @param [String] path to store execution map
+      def initialize(path)
+        @path = path
+      end
+
+      # Removes storage file
+      def clear!
+        path.delete if path.exist?
+      end
+
+      # Writes data to storage file
+      #
+      # @param [Hash] data to write to storage file
+      def dump(data)
+        path.open('a') { |f| f.write YAML.dump(data) }
+      end
+    end
+  end
+end

data/lib/crystalball/prediction.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Crystalball
+  # Class for Crystalball prediction results
+  class Prediction
+    def initialize(cases)
+      @cases = cases
+    end
+
+    def compact
+      result = []
+      sort_by(&:length).each do |c|
+        result << c unless result.any? { |r| c.start_with?(r, "./#{r}") }
+      end
+      result
+    end
+
+    def to_a
+      cases
+    end
+
+    def method_missing(*args, &block)
+      cases.respond_to?(*args) ? cases.public_send(*args, &block) : super
+    end
+
+    def respond_to_missing?(*args)
+      cases.respond_to?(*args)
+    end
+
+    private
+
+    attr_reader :cases
+  end
+end

data/lib/crystalball/predictor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Crystalball
+  # Class to predict test failures with given execution map and sources diff
+  class Predictor
+    attr_reader :map, :from, :to, :prediction_strategies
+
+    # @param [Crystalball::ExecutionMap] map execution map
+    # @param [Crystalball::GitRepo] repo to build execution list on
+    # @param [String] from starting commit for diff. Default: HEAD
+    # @param [String] to ending commit for diff. Default: nil
+    def initialize(map, repo, from: 'HEAD', to: nil)
+      @map = map
+      @repo = repo
+      @from = from
+      @to = to
+      @prediction_strategies = []
+      yield self if block_given?
+    end
+
+    # Adds additional predictor to use
+    #
+    # @param [#call] strategy - the strategy can be any object that responds to #call
+    def use(strategy)
+      prediction_strategies << strategy
+    end
+
+    # @return [Crystalball::Prediction] list of examples which may fail
+    def prediction
+      Prediction.new(filter(raw_prediction(diff)))
+    end
+    alias cases prediction
+
+    def diff
+      repo.diff(from, to)
+    end
+
+    private
+
+    # TODO: check if it would be better to call predictors with one case instead of passing the whole map.
+    def predict!(current_diff)
+      prediction_strategies.flat_map { |strategy| strategy.call(current_diff, map) }
+    end
+    alias raw_prediction predict!
+
+    attr_reader :repo
+
+    def filter(raw_cases)
+      raw_cases.compact.select { |example| example_to_file_path(example).exist? }.uniq
+    end
+
+    def example_to_file_path(example)
+      repo.repo_path.join(example.split('[').first).expand_path
+    end
+  end
+end

data/lib/crystalball/predictor/associated_specs.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+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
+      # @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:)
+        @from = from
+        @to = to
+      end
+
+      # This strategy does not depend on a previously generated case 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) }
+      end
+
+      private
+
+      attr_reader :from, :to
+
+      def captures(file_path)
+        match = file_path.match(from)
+        if match.names.any?
+          match.names.map(&:to_sym).zip(match.captures).to_h
+        else
+          match.captures
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/predictor/modified_execution_paths.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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
+      # @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
+      # @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
+      end
+    end
+  end
+end

data/lib/crystalball/predictor/modified_specs.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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
+      # @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.
+      # 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)
+      end
+
+      private
+
+      attr_reader :spec_pattern
+    end
+  end
+end

data/lib/crystalball/predictor_evaluator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Crystalball
+  # Class to collect statistics about prediction quality
+  class PredictorEvaluator
+    attr_reader :predictor, :actual_failures
+
+    # @param [Crystalball::Predictor] predictor - configured predictor to fetch list of examples which might fail
+    # @param [Array<String>] actual_failures - list of actual failed examples
+    def initialize(predictor, actual_failures:)
+      @predictor = predictor
+      @actual_failures = actual_failures
+    end
+
+    def predicted_failures
+      @predicted_failures ||= actual_failures.select do |failure|
+        prediction.any? { |p| failure.include?(p) }
+      end
+    end
+
+    def unpredicted_failures
+      actual_failures - predicted_failures
+    end
+
+    def diff_size
+      predictor.diff.lines
+    end
+
+    def prediction_to_diff_ratio
+      prediction_size.to_f / diff_size
+    end
+
+    def prediction_scale
+      prediction_size.to_f / map_size
+    end
+
+    def prediction_rate
+      actual_failures.empty? ? 1.0 : predicted_failures.size.to_f / actual_failures.size
+    end
+
+    def prediction_size
+      @prediction_size ||= predictor.map.cases.keys.select { |example| prediction.any? { |p| example.include?(p) } }.size
+    end
+
+    def map_size
+      predictor.map.size
+    end
+
+    private
+
+    def prediction
+      @prediction ||= predictor.prediction
+    end
+  end
+end

data/lib/crystalball/rails.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'crystalball/rails/map_generator/action_view_strategy'
+require 'crystalball/rails/map_generator/i18n_strategy'
+
+module Crystalball
+  # Module containting Rails-specific stuff for Crystalball
+  module Rails
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'crystalball/map_generator/base_strategy'
+require 'crystalball/map_generator/helpers/path_filter'
+require 'crystalball/rails/map_generator/action_view_strategy/patch'
+
+module Crystalball
+  module Rails
+    class MapGenerator
+      # Map generator strategy to build map of views affected by an example.
+      # It patches `ActionView::Template#compile!` to get original name of compiled views.
+      class ActionViewStrategy
+        include ::Crystalball::MapGenerator::BaseStrategy
+        include ::Crystalball::MapGenerator::Helpers::PathFilter
+
+        class << self
+          # List of views affected by current example
+          #
+          # @return [Array<String>]
+          attr_reader :views
+
+          # Reset cached list of views
+          def reset_views
+            @views = []
+          end
+        end
+
+        def after_start
+          Patch.apply!
+        end
+
+        def before_finalize
+          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, _)
+          self.class.reset_views
+          yield case_map
+          case_map.push(*filter(self.class.views))
+        end
+      end
+    end
+  end
+end