flakey_spec_catcher 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 27339d7daba0c74bb7d57aec6a18685f1aa6034f11158a99e055e971eaebebe4
+  data.tar.gz: cc738a7d26cc97a63dec0becca3cc9a13244c4cae9906a5645174d8277357f84
+SHA512:
+  metadata.gz: cad188a9621417d13d104d0b26fe379e875daa2c4c571e64d6429acb04bd20898e8e727724e2916506e33d6a5bca8f9ca27175f3b154eebb5e3c096c92aaa7ce
+  data.tar.gz: 17dcab2f7900196b7bc388ab6e37e86fbbd394b4cffd5d8a29fa7f751b61b55ce58523f59420c3f5ac9c3c2c706a7ceed6fd003aebb17a320551c578233cabff

data/bin/flakey_spec_catcher

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'flakey_spec_catcher'
+
+app = FlakeySpecCatcher::Runner.new
+app.show_settings
+app.rerun_preview
+exit app.run_specs

data/lib/flakey_spec_catcher.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  autoload :VERSION, 'flakey_spec_catcher/version'
+  autoload :Runner, 'flakey_spec_catcher/runner'
+end

data/lib/flakey_spec_catcher/capsule_manager.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  # CapsuleManager class
+  #
+  # Contains a file by file summary of all git changes.
+  #
+  # A CapsuleManager object contains all ChangeCapsule objects. It delivers
+  # summaries of all changes and runs methods on the contained ChangeCapsule
+  # objects.
+  class CapsuleManager
+    attr_reader :change_capsules
+
+    def initialize
+      @change_capsules = []
+    end
+
+    def add_capsule(capsule)
+      @change_capsules.push(capsule)
+    end
+
+    def changed_examples
+      @change_capsules.map(&:changed_examples).flatten.uniq
+    end
+
+    def changed_files
+      @change_capsules.map(&:file_name).uniq
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def condense_reruns
+      # Don't re-run if the parent context of a change will be run
+      reruns = []
+      all_contexts = @change_capsules.map(&:change_contexts).flatten
+                                     .sort_by { |c| c.line_number.to_i }
+
+      all_contexts.each do |context|
+        next if reruns.include?(context.file_name)
+
+        found_parent_match = false
+        all_contexts.each do |other|
+          next if context == other
+
+          found_parent_match = true if context.parent_matches_context(other)
+        end
+
+        next if found_parent_match
+
+        reruns.push(context.rerun_info) unless reruns.include?(context.rerun_info)
+      end
+      reruns
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/flakey_spec_catcher/change_capsule.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  # ChangeCapsule class
+  #
+  # Summarizes a git change for a single file.
+  #
+  # A ChangeCapsule object will represent the changes made to a single file. It
+  # accomplishes this using ChangeContext and ChangeSummary objects.
+  class ChangeCapsule
+    attr_reader :file_name, :change_summary, :change_contexts
+    SCOPE_SPECIFIERS = %w[it context describe scenario].freeze
+    SHARED_EXAMPLES = %w[include_examples it_behaves_like it_should_behave_like matching].freeze
+
+    def initialize(file_name, change_summary, change_contexts = [])
+      @file_name = file_name
+      @change_summary = change_summary
+      @change_contexts = []
+      handle_initial_change_contexts(change_contexts)
+    end
+
+    def changed_examples
+      @change_contexts.map(&:rerun_info)
+    end
+
+    def fill_contexts
+      change_context_stack = []
+      ignore_scope_closure = 0
+      lines_in_file = File.read(@file_name).split("\n")
+      lines_in_file.each_with_index do |line, index|
+        if line =~ spec_scope
+          handle_change_context(line, index, change_context_stack)
+        elsif line =~ /\s*do(\s+|$)/
+          ignore_scope_closure += 1
+        end
+
+        fill_context(line, index, change_context_stack)
+
+        # Note - some things use do-like loops and we need to be able to ignore those
+        if line =~ pop_scope
+          if ignore_scope_closure.positive?
+            ignore_scope_closure -= 1
+          else
+            change_context_stack.pop
+          end
+        end
+      end
+    end
+
+    private
+
+    def handle_initial_change_contexts(change_contexts)
+      change_contexts.each do |context|
+        add_change_context(context)
+      end
+    end
+
+    def add_change_context(context)
+      if context.nil?
+        change_context = FlakeySpecCatcher::ChangeContext.new(description: nil,
+                                                              line_number: nil,
+                                                              parent_description: nil,
+                                                              parent_line_number: nil,
+                                                              file_name: @file_name)
+        @change_contexts.push(change_context)
+      else
+        @change_contexts.push(context) unless @change_contexts.any? { |c| c == context }
+      end
+    end
+
+    def spec_scope
+      # Not sure if we need to check for description in quotes
+      # spec_scope = /^\s*(#{SCOPE_SPECIFIERS.join("|")})\s*('.*'|".*").*do\s*$/
+
+      /\s*(#{SCOPE_SPECIFIERS.join("|")}).*\s+do\s*$/
+    end
+
+    def pop_scope
+      /\s+end(\s+|$)/
+    end
+
+    def fill_context(line, index, change_context_stack)
+      return unless line_is_inside_a_block_of_changed_code?(index)
+      return if line_is_a_comment_or_whitespace?(line)
+
+      add_change_context(change_context_stack[-1])
+    end
+
+    def line_is_inside_a_block_of_changed_code?(index)
+      changed_line_start = @change_summary.working_commit_line_number
+      changed_line_count = @change_summary.working_commit_lines_altered
+      changed_line_end = changed_line_start + changed_line_count
+      changed_line_start == (index + 1) ||
+        (changed_line_start...changed_line_end).cover?(index + 1)
+    end
+
+    def line_is_a_comment_or_whitespace?(line)
+      line =~ /^((\s*)?|(\s*#.*))$/
+    end
+
+    def handle_change_context(line, line_number, change_context_stack)
+      if !change_context_stack.empty?
+        parent_desc = change_context_stack[-1].description
+        parent_line = change_context_stack[-1].line_number
+      else
+        parent_desc = nil
+        parent_line = nil
+      end
+      change_context = FlakeySpecCatcher::ChangeContext.new(
+        description: line, line_number: (line_number + 1), parent_description: parent_desc,
+        parent_line_number: parent_line, file_name: @file_name
+      )
+
+      change_context_stack.push(change_context) unless
+        change_context_stack.any? { |c| c == change_context }
+    end
+  end
+end

data/lib/flakey_spec_catcher/change_context.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  # ChangeContext class
+  #
+  # Identifies the conditions in which a code change occurs.
+  #
+  # At a high level, a ChangeContext captures (A) the line number, and (B) the
+  # block of code in which a change exists. This identifies both the code
+  # change's context and its parent context.
+  #
+  # FSC uses parent contexts to eliminate re-running tests too many times.
+  # For example, if changes are detected in both a 'describe' block and a child
+  # test case inside of that 'describe' block, FSC will re-run the contents of
+  # the 'describe' block only.
+  class ChangeContext
+    attr_reader :description, :line_number
+    attr_reader :parent_description, :parent_line_number
+    attr_reader :file_name
+
+    def initialize(description:, line_number:, parent_description:,
+      parent_line_number:, file_name:)
+      @description = description
+      @line_number = line_number
+      @parent_description = parent_description
+      @parent_line_number = parent_line_number
+      @file_name = file_name
+      update_descriptions
+    end
+
+    def update_descriptions
+      if @description.nil? || @description.empty?
+        @description = @file_name
+        @line_number = nil
+        @parent_description = nil
+        @parent_line_number = nil
+      elsif @parent_description.nil? || @parent_description.empty?
+        @parent_description = @file_name
+        @parent_line_number = nil
+      end
+    end
+
+    def ==(other)
+      @description == other.description &&
+        @line_number == other.line_number &&
+        @file_name == other.file_name
+    end
+
+    def rerun_info
+      if @line_number.nil?
+        @file_name
+      else
+        "#{@file_name}:#{@line_number}"
+      end
+    end
+
+    def parent_matches_context(other)
+      @parent_description == other.description &&
+        @parent_line_number == other.line_number &&
+        @file_name == other.file_name
+    end
+  end
+end

data/lib/flakey_spec_catcher/change_summary.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  # ChangeSummary class
+  #
+  # Takes in a git diff block summary and converts it to an object.
+  #
+  # This class converts a block of changes (retrieved through use of git diff)
+  # into an object that will allow the created ChangeCapsule objects to more
+  # easily find and identify changes.
+  class ChangeSummary
+    attr_reader :master_commit_line_number, :master_commit_lines_altered
+    attr_reader :working_commit_line_number, :working_commit_lines_altered
+    attr_reader :change_type
+
+    def initialize(change_summary)
+      @master_commit_line_number, @master_commit_lines_altered =
+        change_summary.split[0].delete('-').split(',').map(&:to_i)
+      @master_commit_lines_altered ||= 0
+      @working_commit_line_number, @working_commit_lines_altered =
+        change_summary.split[1].delete('+').split(',').map(&:to_i)
+      @working_commit_lines_altered ||= 0
+      initialize_change_type
+    end
+
+    private
+
+    def initialize_change_type
+      @change_type = if @working_commit_lines_altered >= @master_commit_lines_altered
+        'ADD'
+      else
+        'REMOVE'
+      end
+    end
+  end
+end

data/lib/flakey_spec_catcher/git_controller.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative './change_capsule'
+require_relative './change_summary'
+require_relative './change_context'
+require_relative './capsule_manager'
+
+module FlakeySpecCatcher
+  # GitController class
+  #
+  # Runs a 'git diff' between the local working commit and a base commit that
+  # represents what is at the top of the source control manager.
+  #
+  # The end goal of the GitController is to specify which tests have changed in
+  # a form that can be easily sent to RSpec. Because you can specify a test to
+  # run via `rspec <path_to_spec_file>:<file number>` the GitController will
+  # summarize changes in that form.
+  class GitController
+    attr_reader :branch, :remote, :working_commit_sha, :base_commit_sha, :git_comparison
+    attr_reader :capsule_manager
+
+    def initialize(test_mode: false, capsule_manager: FlakeySpecCatcher::CapsuleManager.new)
+      @branch = `git branch | grep '*'`.delete('*').gsub(/\s+/, '')
+      @remote = `git remote`.gsub(/\s+/, '')
+      @capsule_manager = capsule_manager
+      initialize_git_comparison(test_mode)
+      parse_changes
+      identify_change_contexts
+    end
+
+    def changed_examples
+      @capsule_manager.change_capsules.map(&:changed_examples).flatten.uniq
+    end
+
+    private
+
+    def initialize_git_comparison(test_mode)
+      if !test_mode
+        @working_commit_sha = `git rev-parse @`.gsub(/\s+/, '')
+        @base_commit_sha = `git rev-parse #{@remote}/#{@branch}`.gsub(/\s+/, '')
+      else
+        @working_commit_sha = `git rev-parse HEAD`.gsub(/\s+/, '')
+        @base_commit_sha = `git rev-parse HEAD~1`.gsub(/\s+/, '')
+      end
+      @git_comparison = "#{@base_commit_sha}..#{@working_commit_sha}"
+    end
+
+    def parse_changes
+      # For each file, get the change block
+      diff_files.each do |filename|
+        next unless filename =~ /_spec.rb/
+
+        # Get diff pairs [ /path/to/file,  "@@ -19 +19,4 @@" ]
+        diff = `git diff --unified=0 #{@git_comparison} #{filename}`
+        diff_pairs = diff.split("\n").select { |line| line =~ /^@@/ || line =~ /^diff --git/ }
+
+        diff_pairs.each do |line|
+          next unless (diff_summary = /-\d+,?(\d+)?\s\+\d+,?(\d+)?/.match(line))
+
+          change_summary = ChangeSummary.new(diff_summary.to_s)
+          capsule = ChangeCapsule.new(filename, change_summary)
+          @capsule_manager.add_capsule(capsule)
+        end
+      end
+    end
+
+    def identify_change_contexts
+      @capsule_manager.change_capsules.each(&:fill_contexts)
+    end
+
+    def diff_files
+      `git diff --name-only #{@git_comparison}`.gsub("\n", ',').split(',')
+    end
+  end
+end

data/lib/flakey_spec_catcher/rerun_capsule.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  # RerunCapsule class
+  #
+  # Contains one file or test case to re-run, as well as its associated RSpec
+  # usage.
+  class RerunCapsule
+    include Comparable
+    attr_reader :usage, :testcase
+
+    def initialize(usage: nil, testcase: '')
+      @usage = initialize_usage(usage)
+      @testcase = initialize_testcase(testcase)
+    end
+
+    def empty?
+      if testcase.empty?
+        true
+      else
+        false
+      end
+    end
+
+    def default_usage?
+      @usage.nil?
+    end
+
+    def <=>(other)
+      @testcase <=> other.testcase
+    end
+
+    private
+
+    def initialize_usage(usage)
+      if usage.nil? || usage.empty?
+        nil
+      else
+        usage
+      end
+    end
+
+    def initialize_testcase(testcase)
+      if testcase.nil? || testcase.empty?
+        ''
+      else
+        testcase
+      end
+    end
+  end
+end

data/lib/flakey_spec_catcher/rerun_manager.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative './rerun_capsule'
+
+module FlakeySpecCatcher
+  # RerunManager class
+  #
+  # Pairs file changes with user-specified re-run commands. Those pairs are
+  # defined via environment variables.
+  class RerunManager
+    attr_reader :rerun_capsules
+
+    def initialize(git_controller: FlakeySpecCatcher::GitController.new,
+      user_config: FlakeySpecCatcher::UserConfig.new)
+
+      @git_controller = git_controller
+      @user_config = user_config
+      @rerun_capsules = []
+      pair_reruns_with_usages
+    end
+
+    def tests_for_rerun
+      tests = if @user_config.rerun_file_only
+        @git_controller.capsule_manager.changed_files
+      else
+        @git_controller.capsule_manager.condense_reruns
+      end
+      filter_reruns_by_ignore_files(tests)
+    end
+
+    def pair_reruns_with_usages
+      reruns = tests_for_rerun
+      configured_usage_patterns = @user_config.rspec_usage_patterns
+
+      if configured_usage_patterns.count.zero?
+        add_capsules_with_default_usage(reruns)
+        return
+      end
+
+      reruns.each do |rerun|
+        match_found = false
+        configured_usage_patterns.each do |usage_pattern_pair|
+          next if match_found
+
+          pattern, usage = usage_pattern_pair
+          if rerun =~ /#{pattern}/
+            add_rerun_capsule(testcase: rerun, usage: usage)
+            match_found = true
+          end
+        end
+        add_rerun_capsule(testcase: rerun) unless match_found
+      end
+    end
+
+    private
+
+    def filter_reruns_by_ignore_files(reruns)
+      return reruns if @user_config.ignore_files.count.zero?
+
+      filtered_reruns = []
+      ignore_files = "(#{@user_config.ignore_files.join('|')})"
+      ignore_files_regex = /#{ignore_files}/
+
+      reruns.each do |file|
+        next if file =~ ignore_files_regex
+
+        filtered_reruns.push(file)
+      end
+      filtered_reruns
+    end
+
+    def add_capsules_with_default_usage(reruns)
+      reruns.each do |rerun|
+        @rerun_capsules.push(FlakeySpecCatcher::RerunCapsule.new(testcase: rerun))
+      end
+    end
+
+    def add_rerun_capsule(testcase: '', usage: nil)
+      @rerun_capsules.push(FlakeySpecCatcher::RerunCapsule.new(testcase: testcase, usage: usage))
+    end
+  end
+end

data/lib/flakey_spec_catcher/rspec_result.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  # RspecResult class
+  #
+  # Organizes results for a changed test (spec).
+  #
+  # Each changed test will have one RspecResult created for it and for each
+  # re-run of that spec, the results will be pushed to the RspecResult object.
+  # This class will then organize and output the results accordingly.
+  class RspecResult
+    attr_reader :file_name, :total_examples_run, :total_failures, :failure_summary
+
+    def initialize(file_name)
+      @file_name = file_name
+      @total_examples_run = 0
+      @total_failures = 0
+      @failure_summary = []
+    end
+
+    def info
+      ratio = "#{@total_examples_run - @total_failures}/#{@total_examples_run}"
+      puts "\nFile Name: #{@file_name} passed #{ratio} examples"
+
+      return unless @total_failures.positive?
+
+      puts '  Failure Summary:'
+      @failure_summary.each do |example, _occurrences|
+        example.info
+      end
+    end
+
+    def add_run(results)
+      parse_totals(results)
+
+      # Parse the failed examples and add them into the failure_summary
+      if @failure_summary.empty?
+        # Add the initial runs
+        @failure_summary = parse_failed_examples(results)
+      else
+        populate_failure_summary(parse_failed_examples(results))
+      end
+    end
+
+    private
+
+    def parse_failed_examples(results)
+      failures = []
+      # Currently we're only going to return the name of the example that failed
+      # Example:
+      # 1) Flakey spec Passes some of the time
+      # Failure/Error: expect(1).to eq(rand(3))
+      #
+      #   expected: 0
+      #        got: 1
+      #
+      #   (compared using ==)
+      #  ./spec/flakey_example_spec.rb:6:in `block (2 levels) in <top (required)>'
+
+      # Would return 'Flakey spec Passes some of the time'
+
+      # Get the line that contains the failed example - Denoted by '1)' in the examples
+      #  and strip the example ennumerators
+      example_lines = results.scan(/^\s*\d\).*$/)
+      failed_examples = example_lines.map { |example| example.strip.sub!(/\d\)\s*/, '') }
+
+      # Use the first line of the failed_examples to get the actual failures
+      failed_examples.each do |example|
+        # Go from the spec example description until '#)' or 'Finished in'
+        result = results[/#{Regexp.escape(example)}(.*?)(Finished in| \d\))/m, 1]
+        failures << RSpecFailure.new(example, result.strip)
+      end
+
+      # Return the array of RSpecFailures
+      failures
+    end
+
+    def parse_totals(results)
+      # Get summary line to determine number of run results.
+      # Will appear as "3 examples, 0 failures"
+      summary = results.split("\n").find { |line| line =~ /example.*failure/ }
+      pass_count, fail_count = summary.split(' ').select { |x| x[/\d/] }
+      @total_examples_run += pass_count.to_i
+      @total_failures += fail_count.to_i
+    end
+
+    def populate_failure_summary(failures)
+      # For each failure, if that example is in @failure_summary, add the results to it
+      failures.each do |failure|
+        match_found = false
+        @failure_summary.each do |example|
+          # If example is already in the summary, add the expect/actual to the example's failures
+          if example.example_name == failure.example_name
+            example.add_case(failure.failure_details.join(''))
+            match_found = true
+          end
+        end
+        # If example is not in the summary, add the whole object to the array of examples
+        @failure_summary << failure unless match_found
+      end
+    end
+  end
+
+  # Simple class to contain failed example data
+  class RSpecFailure
+    attr_reader :example_name, :failure_details
+
+    def initialize(example_name, results)
+      @example_name = example_name
+      @failure_count = 1
+      @failure_details = [results]
+    end
+
+    def add_case(results)
+      @failure_count += 1
+      @failure_details << results
+    end
+
+    def info
+      puts "\n    '#{@example_name}' failed #{@failure_count} time(s)"
+      @failure_details.each { |failure| puts "\n       #{failure}" }
+    end
+  end
+end

data/lib/flakey_spec_catcher/runner.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative './rspec_result'
+require_relative './git_controller'
+require_relative './capsule_manager'
+require_relative './user_config'
+require_relative './rerun_manager'
+
+module FlakeySpecCatcher
+  class Runner
+    attr_reader :user_config, :rerun_manager, :git_controller
+    attr_reader :rspec_results
+
+    def initialize(test_mode: false,
+      git_controller: FlakeySpecCatcher::GitController.new(test_mode: test_mode),
+      user_config: FlakeySpecCatcher::UserConfig.new,
+      rerun_manager: FlakeySpecCatcher::RerunManager.new(git_controller: git_controller,
+                                                         user_config: user_config))
+
+      @rspec_results = []
+      @git_controller = git_controller
+      @user_config = user_config
+      @rerun_manager = rerun_manager
+    end
+
+    # Debug Methods
+    def show_settings
+      puts 'Flakey Spec Catcher Settings:'
+      puts "  Current Branch: #{@git_controller.branch}"
+      puts "  Remote: #{@git_controller.remote}"
+      puts "  Current Sha: #{@git_controller.working_commit_sha}"
+      puts "  Base Sha: #{@git_controller.base_commit_sha}"
+      puts "  Repeat factor: #{@user_config.repeat_factor}"
+      puts "  Changed Specs Detected: #{@git_controller.changed_examples}"
+    end
+
+    def rerun_preview
+      puts "\n********************************************"
+      puts "Re-run Preview\n"
+      @rerun_manager.rerun_capsules.sort.each do |capsule|
+        rerun_msg = "  Running #{capsule.testcase} #{@user_config.repeat_factor} times "
+        rerun_msg += "using `#{capsule.usage}`" unless capsule.default_usage?
+        puts rerun_msg
+      end
+      puts "\n********************************************"
+    end
+    # end Debug methods
+
+    def run_specs
+      status = 0
+      @user_config.repeat_factor.times do
+        @rerun_manager.rerun_capsules.sort.each do |capsule|
+          iteration_status = 0
+          if capsule.default_usage?
+            iteration_status = invoke_rspec_runner(capsule.testcase)
+          else
+            `#{capsule.usage} #{capsule.testcase}`
+            iteration_status = $?.exitstatus # rubocop:disable Style/SpecialGlobalVars
+          end
+          status = [status, iteration_status].max
+        end
+      end
+
+      # Always return 0 if silent_mode is enabled
+      if @user_config.silent_mode
+        0
+      else
+        status
+      end
+    end
+
+    private
+
+    def invoke_rspec_runner(test)
+      return_status = RSpec::Core::Runner.run([test])
+      RSpec.clear_examples
+      return_status
+    end
+
+    def print_rspec_results
+      @rspec_results.map(&:get_info)
+
+      # Determine the exit code based on the parsed results
+      if @rspec_results.any? { |r| r.total_failures.positive? }
+        puts "\n********************************************"
+        puts 'Flakiness Detected! Exiting with status code 1'
+        puts "********************************************\n"
+        return 1
+      else
+        puts "\n***********************************************"
+        puts 'No Flakiness Detected! Exiting with status code 0'
+        puts "***********************************************\n"
+        return 0
+      end
+    end
+  end
+end

data/lib/flakey_spec_catcher/user_config.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  # UserConfig class
+  #
+  # Captures user-defined settings to configure RSpec re-run settings.
+  class UserConfig
+    attr_reader :repeat_factor, :ignore_files, :ignore_branches, :silent_mode
+    attr_reader :rerun_file_only, :rspec_usage_patterns
+    USER_CONFIG_ENV_VARS = %w[FSC_REPEAT_FACTOR FSC_IGNORE_FILES FSC_IGNORE_BRANCHES
+                              FSC_SILENT_MODE FSC_RERUN_FILE_ONLY FSC_USAGE_PATTERNS].freeze
+
+    def initialize
+      @repeat_factor = initialize_repeat_factor(ENV['FSC_REPEAT_FACTOR'])
+      @ignore_files = env_var_string_to_array(ENV['FSC_IGNORE_FILES'])
+      @ignore_branches = env_var_string_to_array(ENV['FSC_IGNORE_BRANCHES'])
+      @silent_mode = env_var_string_to_bool(ENV['FSC_SILENT_MODE'])
+      @rerun_file_only = env_var_string_to_bool(ENV['FSC_RERUN_FILE_ONLY'])
+      @rspec_usage_patterns = env_var_string_to_pairs(ENV['FSC_USAGE_PATTERNS'])
+      parse_commit_message
+    end
+
+    private
+
+    def initialize_repeat_factor(env_var)
+      env_var.to_i.positive? ? env_var.to_i : 20
+    end
+
+    def env_var_string_to_array(env_var)
+      if env_var.nil? || env_var.empty?
+        []
+      else
+        env_var.split(',').map(&:strip)
+      end
+    end
+
+    def env_var_string_to_bool(env_var)
+      if env_var.to_s.casecmp('true').zero?
+        true
+      else
+        false
+      end
+    end
+
+    def env_var_string_to_pairs(env_var)
+      if env_var.nil? || env_var.empty?
+        []
+      else
+        env_var.scan(/{.*?}/).map do |pair|
+          pair.tr('{}', '').split('=>').map(&:strip)
+        end
+      end
+    end
+
+    def format_regex_scan_results(matches)
+      # Scanning the commit message will result in an array of matches
+      #  based on the specified regex. If the pattern uses groups like ours does
+      #  then an array of arrays will be returned.
+      # See: https://apidock.com/ruby/String/scan
+
+      # For each array of matches, flatten the individual match group sub-array
+      #  then remove the formatter quotes we require the values to be wrapped in
+      matches.map { |m| m.join('').tr("'", '') }
+    end
+
+    def parse_commit_message
+      commit_message = `git show -q`
+      USER_CONFIG_ENV_VARS.each do |env_var|
+        matches = commit_message.scan(/#{env_var}\s*=\s*('.*?')/)
+        next unless matches.count.positive?
+
+        # In the case of multiple overrides being specified for the same config
+        #  variable, we'll only use the first
+        env_value = format_regex_scan_results(matches).first
+        override_user_config(env_var, env_value)
+      end
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def override_user_config(env_var, env_value)
+      case env_var
+      when 'FSC_REPEAT_FACTOR'
+        @repeat_factor = initialize_repeat_factor(env_value)
+      when 'FSC_IGNORE_FILES'
+        @ignore_files = env_var_string_to_array(env_value)
+      when 'FSC_IGNORE_BRANCHES'
+        @ignore_branches = env_var_string_to_array(env_value)
+      when 'FSC_SILENT_MODE'
+        @silent_mode = env_var_string_to_bool(env_value)
+      when 'FSC_RERUN_FILE_ONLY'
+        @rerun_file_only = env_var_string_to_bool(env_value)
+      when 'FSC_USAGE_PATTERNS'
+        @rspec_usage_patterns = env_var_string_to_pairs(env_value)
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+  end
+end

data/lib/flakey_spec_catcher/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FlakeySpecCatcher
+  VERSION = '0.3.0'
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: flakey_spec_catcher
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Brian Watson
+- Mikey Hargiss
+- Ben Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: climate_control
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+description: 
+email:
+- bwatson@instructure.com
+- mhargiss@instructure.com
+- bnelson@instructure.com
+executables:
+- flakey_spec_catcher
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/flakey_spec_catcher
+- lib/flakey_spec_catcher.rb
+- lib/flakey_spec_catcher/capsule_manager.rb
+- lib/flakey_spec_catcher/change_capsule.rb
+- lib/flakey_spec_catcher/change_context.rb
+- lib/flakey_spec_catcher/change_summary.rb
+- lib/flakey_spec_catcher/git_controller.rb
+- lib/flakey_spec_catcher/rerun_capsule.rb
+- lib/flakey_spec_catcher/rerun_manager.rb
+- lib/flakey_spec_catcher/rspec_result.rb
+- lib/flakey_spec_catcher/runner.rb
+- lib/flakey_spec_catcher/user_config.rb
+- lib/flakey_spec_catcher/version.rb
+homepage: 
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Run new or changed specs many times to prevent unreliable specs
+test_files: []