ci_runner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 25a11b4505aff5153e388723711643c4aae5f3a7b64b53b3265e0bd7198ec381
+  data.tar.gz: 858492f60b87472cf41da22c5808a2371659d56712ef77dad98590cb98063ecf
+SHA512:
+  metadata.gz: 51158e9a4b9cd2188f5161320dc140e076009f7c4550206b957ffac03e9b5859533dc99defc644f05aa126713f8d52cf1d2260a4691ba74cba746f779ec3c945
+  data.tar.gz: 5db9352b2360cec4f5f8b23ce4cf378fcef79c3cc1e8b2f1cb4543fb307a2fc8db1116fea023b766d262d768582dd9f44bb1c48434c2c6171e697962398f0543

data/ci_runner.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "lib/ci_runner/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ci_runner"
+  spec.version = CIRunner::VERSION
+  spec.authors = ["Edouard Chin"]
+  spec.email = ["chin.edouard@gmail.com"]
+
+  spec.summary = "Re-run failing tests from CI on your local machine without copy/pasting."
+  spec.description = <<~EOM
+    Tired of copying the test suites names from a failed CI?
+
+    This gem will automate this tedious workflow. CI Runner will download the log from your CI
+    provider, parse it, detect failures and rerun exactly the same failing tests on your machine.
+
+    CI Runner can also detect the Ruby version used on your CI as well as which Gemfile and reuse
+    those when starting the run locally.
+  EOM
+  spec.homepage = "https://github.com/Edouard-chin/ci_runner"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Edouard-chin/ci_runner"
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir["{lib,exe}/**/*", "ci_runner.gemspec"].select { |f| File.file?(f) }
+
+  spec.bindir = "exe"
+  spec.executables = ["ci_runner"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency("cli-ui", "~> 1.5")
+  spec.add_dependency("rake", "~> 13.0")
+  spec.add_dependency("thor", "~> 1.2")
+
+  spec.add_development_dependency("rspec", "~> 3.11")
+  spec.add_development_dependency("rubocop-shopify", "~> 2.8")
+  spec.add_development_dependency("webmock", "~> 3.14")
+end

data/exe/ci_runner

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+require "ci_runner"
+
+CIRunner::CLI.start(ARGV)

data/lib/ci_runner/cli.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module CIRunner
+  class CLI < Thor
+    default_command :rerun
+
+    # @return [Boolean]
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "rerun", "Run failing tests from a CI."
+    long_desc <<~EOM
+      Main command of CI Runner. This command is meant to rerun tests that failed on a CI,
+      on your locale machine, without having you copy/paste output from the CI logs onto your terminal.
+
+      The +rerun+ command will do everything from grabbing the CI checks that failed on a GitHub commit,
+      ask which one you'd like to rerun, download and parse the CI log output and run on your
+      machine exactly the same tests from the failing CI.
+
+      CI Runner is meant to replicate what failed on CI exactly the same way. Therefore, the SEED,
+      the Ruby version as well as the Gemfile from the CI run will be used when running the test suite.
+
+      All option on the +rerun+ command are optional. CI Runner will try to infer them from your repository,
+      and if it can't it will let you know.
+
+      Please note that CI Runner will **not** ensure that the Git HEAD of your local repository matches
+      the commit that failed upstream.
+    EOM
+    option :commit, type: :string, desc: "The Git commit that was pushed to GitHub and has a failing CI. The HEAD commit of your local repository will be used by default." # rubocop:disable Layout/LineLength
+    option :repository, type: :string, desc: "The repository on which the CI failed. The repository will be infered from your git remote by default.", banner: "catanacorp/catana" # rubocop:disable Layout/LineLength
+    option :run_name, type: :string, desc: "The CI check you which to rerun in case multiple checks failed for a commit. CI Runner will prompt you by default." # rubocop:disable Layout/LineLength
+    def rerun
+      ::CLI::UI::StdoutRouter.enable
+
+      runner = nil
+
+      ::CLI::UI.frame("Preparing CI Runner") do
+        Configuration::User.instance.validate_token!
+
+        commit = options[:commit] || GitHelper.head_commit
+        repository = options[:repository] || GitHelper.repository_from_remote
+        ci_checks = fetch_ci_checks(repository, commit)
+
+        run_name = options[:run_name] || ask_for_name(ci_checks)
+        check_run = TestRunFinder.find(ci_checks, run_name)
+
+        ci_log = fetch_ci_log(repository, commit, check_run)
+        runner = TestRunFinder.detect_runner(ci_log)
+        runner.parse!
+
+        if runner.failures.count == 0
+          # Error
+        end
+      rescue GithubClient::Error, Error => e
+        ::CLI::UI.puts("\n{{red:#{e.message}}}", frame_color: :red)
+
+        exit(false)
+      end
+
+      ::CLI::UI::Frame.open("Your test run is about to start") do
+        runner.report
+        runner.start!
+      end
+    end
+
+    desc "github_token TOKEN", "Save a GitHub token in your config."
+    long_desc <<~EOM
+      Save a personal access GitHub token in the ~/.ci_runner/config.yml file.
+      The GitHub token is required to fetch CI checks and download logs from repositories.
+
+      You can get a token from GitHub by following this link: https://github.com/settings/tokens/new?description=CI+Runner&scopes=repo # rubocop:disable Layout/LineLength
+    EOM
+    def github_token(token)
+      ::CLI::UI::StdoutRouter.enable
+
+      ::CLI::UI.frame("Saving GitHub Token") do
+        user = GithubClient.new(token).me
+        Configuration::User.instance.save_github_token(token)
+
+        ::CLI::UI.puts(<<~EOM)
+          Hello {{warning:#{user["login"]}}}! {{success:Your token is valid!}}
+
+          {{info:The token has been saved in this file: #{Configuration::User.instance.config_file}}}
+        EOM
+      rescue GithubClient::Error => e
+        ::CLI::UI.puts("{{red:\nYour token doesn't seem to be valid. The response from GitHub was: #{e.message}}}")
+
+        exit(false)
+      end
+    end
+
+    private
+
+    # Retrieve all the GitHub CI checks for a given commit. Will be used to interactively prompt
+    # the user which one to rerun.
+    #
+    # @param repository [String] The full repository name including the owner (rails/rails).
+    # @param commit [String] A Git commit that has been pushed to GitHub and for which CI failed.
+    #
+    # @return [Hash] See the GitHub documentation.
+    #
+    # @raise [SystemExit] Early exit the process if the CI checks can't be retrieved.
+    #
+    # @see https://docs.github.com/en/rest/checks/runs#list-check-runs-for-a-git-reference
+    def fetch_ci_checks(repository, commit)
+      TestRunFinder.fetch_ci_checks(repository, commit) do |error|
+        puts(<<~EOM)
+          Couldn't fetch the CI checks. The response from GitHub was:
+
+          #{error.message}
+        EOM
+
+        exit(false)
+      end
+    end
+
+    # Download and cache the log for the GitHub check. Downloading the log allows CI Runner to parse it and detect
+    # which test failed in order to run uniquely those on the user machine.
+    #
+    # @param repository [String] The full repository name including the owner (rails/rails).
+    # @param commit [String]     A Git commit that has been pushed to GitHub and for which CI failed.
+    # @param check_run [Hash]    The GitHub Check that failed. See #fetch_ci_checks.
+    #
+    # @return [String] The content of the CI log.
+    #
+    # @raise [SystemExit] Early exit the process if the CI checks can't be retrieved.
+    #
+    # @see https://docs.github.com/en/rest/actions/workflow-jobs#download-job-logs-for-a-workflow-run
+    def fetch_ci_log(repository, commit, check_run)
+      log = LogDownloader.new(commit, repository, check_run).fetch do |error|
+        puts(<<~EOM)
+          Couldn't fetch the CI log. The response from GitHub was:
+
+          #{error.message}
+        EOM
+
+        exit(false)
+      end
+
+      log.read
+    end
+
+    # Interatively ask the user which CI check to rerun in the case a commit has multiple failing checks.
+    # This method only runs if the user has not passed the '--run-name' flag to ci_runner.
+    # Will automatically select a check in the case where there is only one failing check.
+    #
+    # @param ci_checks [Hash] (See #fetch_ci_checks)
+    #
+    # @return [Hash] A single Check Run, the one that the user selected.
+    #
+    # @raise [CIRunner::Error] In case all the CI checks on this commit were successfull. In such case
+    #   there is no need to proceed as there should be no failing tests to rerun.
+    def ask_for_name(ci_checks)
+      check_runs = ci_checks["check_runs"]
+      failed_runs = check_runs.reject { |check_run| check_run["conclusion"] == "success" }
+
+      if failed_runs.count == 0
+        raise(Error, "No CI checks failed on this commit.")
+      elsif failed_runs.count == 1
+        check_run = failed_runs.first["name"]
+
+        ::CLI::UI.puts(<<~EOM)
+          {{warning:Automatically selected the CI check #{check_run} because it's the only one failing.}}
+        EOM
+
+        check_run
+      else
+        ::CLI::UI.ask(
+          "Multiple CI checks failed for this commit. Please choose the one you wish to re-run.",
+          options: failed_runs.map { |check_run| check_run["name"] },
+        )
+      end
+    end
+  end
+end

data/lib/ci_runner/configuration/project.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "yaml"
+require "singleton"
+
+module CIRunner
+  module Configuration
+    # A class to interact with a project's Configuration.
+    #
+    # CI Runner tries its best to come out of the box functional. It comes bundled with a set
+    # of regexes that detects variety of output. For instance if your project uses RSpec or Minitest
+    # AND you haven't modified their reporters, CI Runner should just work with no extra setup.
+    #
+    # However, if your application or Gem has custom reporters, CI Runner set of regexes won't work, as the output
+    # expected will change because of those custom reporters.
+    # CI Runner allows to change those regexes thanks to a configuration file you can store on each of your project.
+    #
+    # Note that all *_regex configuration value can be either a String or a Serialized Regexp object.
+    #
+    # @example Using a String
+    #   ---
+    #   ruby_regex: "Ruby v(\\d\\.\\d\\.\\d)" ==> Note that each backslash has to be escaped!
+    #
+    # @example Using a serialized Regexp
+    #   ---
+    #   ruby_regex: !ruby/regexp "/Ruby v(\\d\\.\\d\\.\\d)/m" ==> Convenient if you need to have flags on the regex.
+    #
+    # @see https://yaml.org/YAML_for_ruby.html#regexps
+    class Project
+      include Singleton
+
+      CONFIG_PATH = ".github/ci_runner.yml"
+
+      # Singleton class. Shouldn't/Can't be called directly. Call Project.instance instead.
+      #
+      # @return [void]
+      def initialize
+        load!
+      end
+
+      # Load the configuration file from the project into memory.
+      #
+      # @return [void]
+      def load!
+        @yaml_config = config_file.exist? ? YAML.safe_load(config_file.read, permitted_classes: [Regexp]) : {}
+      end
+
+      # This regex is used to detect the Ruby version that was used on a CI. It's quite common to have a CI
+      # testing a gem on different version of Ruby.
+      # If detected, CI Runner will use that same Ruby version from your machine (if it exists) to run the test suite.
+      #
+      # **Important**. Your regex has to contain ONE capturing match, being the Ruby version itself.
+      #
+      # @return [nil, Regexp] Depending if the project has set this. CI Runner default will be used when not set.
+      #
+      # @example Storing this configuration
+      #   `cat myproject/.github/ci_runner.yml`
+      #
+      #   ---
+      #   ruby_regex: "Ruby (.*)"
+      def ruby_detection_regex
+        to_regexp(@yaml_config.dig("ruby_regex"))
+      end
+
+      # This regex is used to detect the Gemfile version that was used on a CI. It's quite common to have a CI
+      # testing a gem with different set of dependencies thanks to multiple Gemfiles.
+      # If detected, CI Runner will use the same Gemfile from your machine (if it exists) to run the test suite.
+      #
+      # **Important**. Your regex has to contain ONE capturing match, being the Gemfile path.
+      #
+      # @return [nil, Regexp] Depending if the project has set this. CI Runner default will be used when not set.
+      #
+      # @example Storing this configuration
+      #   `cat myproject/.github/ci_runner.yml`
+      #
+      #   ---
+      #   gemfile_regex: "Using GEMFILE: (.*)"
+      def gemfile_detection_regex
+        to_regexp(@yaml_config.dig("gemfile_regex"))
+      end
+
+      # This regex is used to detect the SEED on a CI. CI Runner aims to rerun failing tests on your machine
+      # exactly the same as how it ran on CI, therefore in the same order. The SEED is what determine the order.
+      #
+      # **Important**. Your regex has to contain ONE capturing match, being the SEED value.
+      #
+      # @return [nil, Regexp] Depending if the project has set this. CI Runner default will be used when not set.
+      #
+      # @example Storing this configuration
+      #   `cat myproject/.github/ci_runner.yml`
+      #
+      #   ---
+      #   seed_regex: "Running with test options: --seed(.*)"
+      def seed_detection_regex
+        to_regexp(@yaml_config.dig("seed_regex"))
+      end
+
+      # This regex is used to tell CI Runner when to start buffering. The failures will then be matched
+      # agains this buffer rather than the whole log output. An example to better understand:
+      #
+      # @return [nil, Regexp] Depending if the project has set this. CI Runner default will be used when not set.
+      #
+      # @example
+      #   An RSpec output looks like this:
+      #
+      #      1.2) Failure/Error: @client.delete_repository(@repo.full_name)
+      #
+      #           NoMethodError:
+      #             undefined method `full_name' for nil:NilClass
+      #           # ./spec/octokit/client/repositories_spec.rb:71:in `block (3 levels) in <top (required)>'
+      #           # ./.bundle/gems/ruby/3.0.0/gems/webmock-3.14.0/lib/webmock/rspec.rb:37:in `block (2 levels) in'
+      #
+      #   Finished in 26.53 seconds (files took 1.26 seconds to load)
+      #   854 examples, 1 failure
+      #
+      #   Failed examples:
+      #
+      #   rspec ./spec/octokit/client/repository_spec.rb:75 # Octokit::Client::Repositories.edit_repository is_template
+      #
+      #   =====================
+      #
+      #   If you have this configuration set to "Failed examples:". CI Runner will start collecting test failures
+      #   only after the "Failed examples" line appear.
+      #
+      # @example Storing this configuration
+      #   `cat myproject/.github/ci_runner.yml`
+      #
+      #   ---
+      #   buffer_starts_regex: "Failed examples:"
+      def buffer_starts_regex
+        to_regexp(@yaml_config.dig("buffer_starts_regex"))
+      end
+
+      # This is to be used in conjuction with the +buffer_starts_regex+. It accepts a boolean value.
+      #
+      # This configuration tells CI Runner to process the buffer and find failures each time a new line matching
+      # +buffer_starts_regex+ appears.
+      #
+      # To detect the file path of each failing test, we have to go through  the stacktrace of each failing tests.
+      #
+      # When you set the `process_on_new_match` value to true (the default), your regex +test_failure_detection_regex+
+      # will be matched agains each erroring test.
+      #
+      # @return [nil, Regexp] Depending if the project has set this. True by default.
+      #
+      # @example A Minitest failure output looks like this:
+      #
+      #   Finished in 0.015397s, 2013.4301 runs/s, 58649.2703 assertions/s.
+      #
+      #   Error:
+      #
+      #   TestReloading#test_reload_recovers_from_name_errors__w__on_unload_callbacks_:
+      #   Tasks: TOP => default => test
+      #   NameError: uninitialized constant X
+      #   (See full trace by running task with --trace)
+      #
+      #     parent.const_get(cname, false)
+      #           ^^^^^^^^^^
+      #     /Users/runner/work/zeitwerk/zeitwerk/lib/zeitwerk/loader/helpers.rb:118:in
+      #     /Users/runner/work/zeitwerk/zeitwerk/lib/zeitwerk/loader/helpers.rb:118:
+      #     /Users/runner/work/zeitwerk/zeitwerk/test/lib/zeitwerk/test_reloading.rb:223:in `block (2 levels) in
+      #
+      #   Error:
+      #
+      #   OtherTest#test_something_else
+      #   Tasks: TOP => default => test
+      #   NameError: Boom
+      #   (See full trace by running task with --trace)
+      #
+      #     bla.foo
+      #         ^^^
+      #   /Users/runner/work/zeitwerk/zeitwerk/test/lib/zeitwerk/other_test.rb:18:in
+      #
+      # @example Storing this configuration
+      #   `cat myproject/.github/ci_runner.yml`
+      #
+      #   ---
+      #   process_on_new_match: false
+      def process_on_new_match?
+        value = @yaml_config.dig("process_on_new_match")
+
+        value.nil? ? true : value
+      end
+
+      # Main detection regex used to detect test failures.
+      #
+      # **Important** This regexp 3 named capture groups. The order doesn't matter.
+      #
+      # - "file_path"
+      # - "test_name"
+      # - "class"
+      #
+      # Your regex should look something like: /(?<file_path>...)(?<test_name>...)(?<class>...)/
+      #
+      # @return [nil, Regexp] Depending if the project has set this. CI Runner default will be used when not set.
+      #
+      # @raise [Error] If the provided doesn't have the 3 capturing group mentioned.
+      #
+      # @example Storing this configuration
+      #   `cat myproject/.github/ci_runner.yml`
+      #
+      #   ---
+      #   failure_regex: "your_regex"
+      def test_failure_detection_regex
+        regexp = to_regexp(@yaml_config.dig("failures_regex"))
+        return unless regexp
+
+        expected_captures = ["file_path", "test_name", "class"]
+        difference = expected_captures - regexp.names
+
+        if difference.any?
+          raise(Error, <<~EOM)
+            The {{warning:failures_regex}} configuration of your project doesn't include expected named captures.
+            CI Runner expects the following Regexp named captures: #{expected_captures.inspect}.
+
+            Your Regex should look something like {{info:/(?<file_path>...)(?<test_name>...)(?<class>...)/}}
+          EOM
+        end
+
+        regexp
+      end
+
+      # @return [Pathname] The path of the configuration file.
+      #
+      # @example
+      #   puts Project.instance.config_file # => project/.github/ci_runner.yml
+      def config_file
+        Pathname(File.expand_path(CONFIG_PATH, Dir.pwd))
+      end
+
+      private
+
+      # @param value [String, Regexp, nil]
+      #
+      # @return [Regexp, nil]
+      def to_regexp(value)
+        value ? Regexp.new(value) : value
+      end
+    end
+  end
+end

data/lib/ci_runner/configuration/user.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "yaml"
+require "singleton"
+
+module CIRunner
+  module Configuration
+    # Class to interact with the user's configuration. The configuration is used
+    # to store the GitHub token amonst other things.
+    #
+    # @param Use this configuration
+    #   User.instance.github_token
+    class User
+      include Singleton
+
+      USER_CONFIG_PATH = ".ci_runner/config.yml"
+
+      # Singleton class. This should/can't be called directly.
+      #
+      # @return [void]
+      def initialize
+        load!
+      end
+
+      # Load the configuration of the user. If it doesn't exist, write an empty one.
+      #
+      # @return [void]
+      def load!
+        save!({}) unless config_file.exist?
+
+        @yaml_config = YAML.load_file(config_file)
+      end
+
+      # Retrieve the stored GitHub access token of the user.
+      #
+      # @return [String, nil] Depending if the user ran the `ci_runner github_token TOKEN` command.
+      def github_token
+        @yaml_config.dig("github", "token")
+      end
+
+      # Write the GitHub token to the user configuration file
+      #
+      # @param token [String] A valid GitHub access token.
+      #
+      # @return [void]
+      def save_github_token(token)
+        @yaml_config["github"] = { "token" => token }
+
+        save!(@yaml_config)
+      end
+
+      # @return [Pathname] The path of the configuration file.
+      #
+      # @example
+      #   puts config_file # ~/.ci_runner/config.yml
+      def config_file
+        Pathname(File.expand_path(USER_CONFIG_PATH, Dir.home))
+      end
+
+      # Ensure the user ran the `ci_runner github_token TOKEN` command prior to using CI Runner.
+      #
+      # Note: Technically, it's possible to access the GitHub API to retrieve checks and download logs on
+      # public repositories, but on private repositories the error GitHub sends back is a 404 which can
+      # be confusing, so I'd rather just make sure the token exists either way.
+      #
+      # @raise [Error] If the user tries to run `ci_runner rerun` before it saved a token in its config file.
+      #
+      # @return [void]
+      def validate_token!
+        return if github_token
+
+        raise(Error, <<~EOM)
+          A GitHub token needs to be saved into your configuration before being able to use CI Runner.
+
+          Have a look at the {{command:ci_runner help github_token}} command.
+        EOM
+      end
+
+      private
+
+      # Dump into yaml and store the new configuration to the +config_file+.
+      #
+      # @param config [Hash] A hash that will be dumped to YAML.
+      #
+      # @raise [Error] In the case where the user's home directory is not writeable (hello nix).
+      def save!(config = {})
+        raise(Error, "Your home directory is not writeable") unless Pathname(Dir.home).writable?
+
+        dir = config_file.dirname
+        dir.mkdir unless dir.exist?
+
+        File.write(config_file, YAML.dump(config))
+      end
+    end
+  end
+end

data/lib/ci_runner/git_helper.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module CIRunner
+  # A helper for the `ci_runner rerun` command to infer options automatically.
+  # The goal being to have the user only type `ci_runner rerun` and have things work magically.
+  #
+  # The command line options passed by a user have precedence.
+  module GitHelper
+    extend self
+
+    # Get the HEAD commit of the repository. This assumes the user runs the `ci-runner` command from
+    # a repository.
+    #
+    # @return [String] The HEAD commit of the user's local repository.
+    #
+    # @raise [Error] In case the `git` subprocess returns an error.
+    def head_commit
+      stdout, _, status = Open3.capture3("git rev-parse HEAD")
+
+      if status.success?
+        stdout.rstrip
+      else
+        raise(Error, <<~EOM)
+          Couldn't determine the commit. The commit is required to download the right CI logs.
+
+          Please pass the `--commit` flag (ci_runner --commit <commit>)
+        EOM
+      end
+    end
+
+    # Get the full repository name (including the owner, i.e. rails/rails) thanks to the Git remote.
+    # This allows the user to not have to type `ci-runner rerun --repostitory catanacorp/catana` each time.
+    #
+    # @return [String] The full repository name
+    #
+    # @raise [Error] In case the `git` subprocess returns an error.
+    def repository_from_remote
+      stdout, _, status = Open3.capture3("git remote -v")
+
+      if status.success?
+        process_remotes(stdout)
+      else
+        raise(Error, <<~EOM)
+          Couldn't determine the name of the repository.
+
+          Please pass the `--repository` flag (ci_runner --repository <owner/repository_name>)
+        EOM
+      end
+    end
+
+    private
+
+    # Try to get the right repository depending on the remotes. It's quite common to have two remotes when your
+    # work on a forked project. The remote from the source project is regularly called: "remote".
+    #
+    # CI Runner will prioritize remotes with the following order:
+    #
+    # - remote
+    # - origin
+    # - anything else
+    #
+    # @param stdout [String] The output from the `git remote -v` command.
+    #
+    # @return [String] The full repository name.
+    #
+    # @raise [Error] In case there is no GitHub remote. CI Runner currently works with GitHub.
+    #
+    # @example When the remote is preferred
+    #   `git remote -v
+    #    remote  git@github.com:rails/rails.git (fetch)
+    #    remote  git@github.com:rails/rails.git (push)
+    #    origin  git@github.com:Edouard-chin/rails.git (fetch)
+    #    origin  git@github.com:Edouard-chin/rails.git (push)
+    #
+    #    rails/rails will be returned.
+    def process_remotes(stdout)
+      stdout.match(/remote#{remote_regex}/) do |match_data|
+        return "#{match_data[1]}/#{match_data[2]}"
+      end
+
+      stdout.match(/origin#{remote_regex}/) do |match_data|
+        return "#{match_data[1]}/#{match_data[2]}"
+      end
+
+      stdout.match(/#{remote_regex}/) do |match_data|
+        return "#{match_data[1]}/#{match_data[2]}"
+      end
+
+      raise(Error, <<~EOM)
+        Couldn't determine the repository name based on the git remote.
+
+        Please pass the `--repository` flag (ci_runner --repository <owner/repository_name>)
+      EOM
+    end
+
+    # return [Regexp] The regex to detect the full repository name.
+    def remote_regex
+      %r{\s+(?:git@|https://)github.com(?::|/)([a-zA-Z0-9\-_\.]+)/([a-zA-Z0-9\-_\.]+?)(?:\.git)?\s+\((?:fetch|push)\)}
+    end
+  end
+end