gitlab-crystalball 0.7.1

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "crystalball/rspec/standard_prediction_builder"
+
+module Crystalball
+  module RSpec
+    class Runner
+      # Class for storing local runner configuration
+      class Configuration
+        def initialize(config = {}) # rubocop:disable Metrics/MethodLength
+          @values = {
+            "execution_map_path" => "tmp/crystalball_data.yml",
+            "map_expiration_period" => 86_400,
+            "repo_path" => Dir.pwd,
+            "requires" => [],
+            "diff_from" => "HEAD",
+            "diff_to" => nil,
+            "runner_class_name" => "Crystalball::RSpec::Runner",
+            "prediction_builder_class_name" => "Crystalball::RSpec::StandardPredictionBuilder",
+            "log_level" => :info,
+            "log_file" => "log/crystalball.log"
+          }.merge(config)
+        end
+
+        def to_h
+          dynamic_values = {}
+          (private_methods - Object.private_instance_methods - %i[run_requires values raw_value]).each do |method|
+            dynamic_values[method.to_s] = send(method)
+          end
+
+          values.merge(dynamic_values)
+        end
+
+        def [](key)
+          respond_to?(key, true) ? send(key) : raw_value(key)
+        end
+
+        private
+
+        def raw_value(key)
+          ENV.fetch("CRYSTALBALL_#{key.to_s.upcase}", values[key])
+        end
+
+        def prediction_builder_class
+          @prediction_builder_class ||= begin
+            run_requires
+
+            Object.const_get(self["prediction_builder_class_name"])
+          end
+        end
+
+        def runner_class
+          @runner_class ||= begin
+            run_requires
+
+            Object.const_get(self["runner_class_name"])
+          end
+        end
+
+        def execution_map_path
+          @execution_map_path ||= Pathname.new(raw_value("execution_map_path"))
+        end
+
+        def repo_path
+          @repo_path ||= Pathname.new(raw_value("repo_path"))
+        end
+
+        def log_file
+          @log_file ||= Pathname.new(raw_value("log_file"))
+        end
+
+        attr_reader :values
+
+        def run_requires
+          Array(self["requires"]).each { |f| require f }
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/rspec/runner.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+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
+
+          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!
+          self.prediction_builder = nil
+          self.config = nil
+        end
+
+        def prepare
+          config["runner_class"].load_execution_map
+        end
+
+        def prediction_builder
+          @prediction_builder ||= config["prediction_builder_class"].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_execution_map
+          check_map
+          prediction_builder.execution_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
+          check_map
+          prune_prediction_to_limit(prediction_builder.prediction.sort_by(&:length))
+        end
+
+        def check_map
+          Crystalball.log :warn, "Maps are outdated!" if prediction_builder.expired_map?
+        end
+      end
+
+      def setup(err, out)
+        configure(err, out)
+        @configuration.load_spec_files
+
+        Filtering.remove_unnecessary_filters(@configuration, @options.options[:files_or_directories_to_run])
+
+        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!"
+
+          reconfigure_to_limit
+          @configuration.load_spec_files
+        end
+
+        @world.announce_filters
+      end
+
+      # 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
+end
+
+require "crystalball/rspec/runner/configuration"

data/lib/crystalball/rspec/standard_prediction_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Crystalball
+  module RSpec
+    # Simple version of predictor
+    class StandardPredictionBuilder < PredictionBuilder
+      private
+
+      def predictor
+        super do |p|
+          p.use Crystalball::Predictor::ModifiedExecutionPaths.new
+          p.use Crystalball::Predictor::ModifiedSpecs.new
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/source_diff/file_diff.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class SourceDiff
+    # Data object for single file in Git repo diff
+    class FileDiff
+      # @param [Git::DiffFile] git_diff - raw diff for a single file made by ruby-git gem
+      def initialize(git_diff)
+        @git_diff = git_diff
+      end
+
+      def moved?
+        !(git_diff.patch =~ /rename from.*\nrename to/).nil?
+      end
+
+      def modified?
+        !moved? && git_diff.type == "modified"
+      end
+
+      def deleted?
+        git_diff.type == "deleted"
+      end
+
+      def new?
+        git_diff.type == "new"
+      end
+
+      # @return relative path to file
+      def relative_path
+        git_diff.path
+      end
+
+      # @return new relative path to file if file was moved
+      def new_relative_path
+        return relative_path unless moved?
+
+        git_diff.patch.match(/rename from.*\nrename to (.*)/)[1]
+      end
+
+      def method_missing(method, *args, &block)
+        git_diff.public_send(method, *args, &block) || super
+      end
+
+      def respond_to_missing?(method, *)
+        git_diff.respond_to?(method, false) || super
+      end
+
+      private
+
+      attr_reader :git_diff
+    end
+  end
+end

data/lib/crystalball/source_diff/formatting_checker.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Crystalball
+  class SourceDiff
+    # Determinates if file_diff's patch contains changes for whitespaces or comments only
+    module FormattingChecker
+      class << self
+        # Returns `true` if file_diff's patch contains changes for whitespaces or comments only
+        #
+        # @param [Crystalball::SourceDiff::FileDiff] file_diff
+        # @return [Boolean]
+        def pure_formatting?(file_diff)
+          return false unless stripable_file?(file_diff.path) && file_diff.modified?
+
+          patch = file_diff.patch.to_s.lines
+
+          return true if patch.empty?
+
+          added = collect_patch(patch, "+")
+          removed = collect_patch(patch, "-")
+
+          trim_patch(added) == trim_patch(removed)
+        end
+
+        private
+
+        STRIPABLE_FILES = %w[.rb .erb].freeze # TODO: move to config
+
+        def stripable_file?(file_name)
+          STRIPABLE_FILES.include?(Pathname(file_name).extname)
+        end
+
+        def collect_patch(patch, sign)
+          patch.each.with_object([]) do |line, result|
+            next if line.start_with?("+++", "---", "@@") # Skip meta of a patch
+
+            result << line[1..-1] if line.start_with?(sign, " ")
+          end
+        end
+
+        def trim_patch(patch)
+          patch.map do |line|
+            line = line.gsub(/\s/, "")
+            line.start_with?("#") || line.empty? ? nil : line
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/crystalball/source_diff.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "crystalball/source_diff/file_diff"
+require "crystalball/source_diff/formatting_checker"
+require "forwardable"
+
+module Crystalball
+  # Wrapper class representing Git source diff for given repo
+  class SourceDiff
+    include Enumerable
+    extend Forwardable
+
+    delegate %i[stats lines from to] => :git_diff
+    alias size count
+
+    # @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
+
+    # @return [Git::Base]
+    def repository
+      @repository ||= git_diff.instance_variable_get(:@base)
+    end
+
+    private
+
+    attr_reader :git_diff
+
+    # TODO: Include untracked to changeset
+    def changeset
+      @changeset ||= git_diff.map do |diff_file|
+        file_diff = FileDiff.new(diff_file)
+        file_diff unless FormattingChecker.pure_formatting?(file_diff)
+      end.compact
+    end
+  end
+end

data/lib/crystalball/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Crystalball
+  VERSION = "0.7.1"
+end

data/lib/crystalball.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "crystalball/logging"
+require "crystalball/git_repo"
+require "crystalball/extensions/git"
+require "crystalball/rspec/prediction_builder"
+require "crystalball/rspec/runner"
+require "crystalball/prediction"
+require "crystalball/predictor"
+require "crystalball/predictor/modified_execution_paths"
+require "crystalball/predictor/modified_specs"
+require "crystalball/predictor/modified_support_specs"
+require "crystalball/predictor/associated_specs"
+require "crystalball/example_group_map"
+require "crystalball/execution_map"
+require "crystalball/map_generator"
+require "crystalball/map_generator/configuration"
+require "crystalball/map_generator/coverage_strategy"
+require "crystalball/map_generator/allocated_objects_strategy"
+require "crystalball/map_generator/described_class_strategy"
+require "crystalball/map_storage/yaml_storage"
+require "crystalball/map_compactor"
+require "crystalball/version"
+
+# Main module for the library
+module Crystalball
+  # Prints the list of specs which might fail
+  #
+  # @param [String] workdir - path to the root directory of repository (usually contains .git folder inside). Default: current directory
+  # @param [String] map_path - path to the execution map. Default: crystalball_data.yml
+  # @param [Proc] block - used to configure predictors
+  #
+  # @example
+  #   Crystalball.foresee do |predictor|
+  #     predictor.use Crystalball::Predictor::ModifiedExecutionPaths.new
+  #     predictor.use Crystalball::Predictor::ModifiedSpecs.new
+  #   end
+  def self.foresee(workdir: ".", map_path: "crystalball_data.yml", &block)
+    map = MapStorage::YAMLStorage.load(Pathname(map_path))
+    Predictor.new(map, GitRepo.open(Pathname(workdir)), from: map.commit, &block).prediction.compact
+  end
+
+  extend Logging
+end