selective-ruby-core 0.2.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 89c79d63a06bc547e21fb0b30b57f8c76274f03487c0a84c250e539cf844b7ed
+  data.tar.gz: dc9d4e81532f76e6649484df041d8903d65cf778d87722fa0419afe9301bad57
+SHA512:
+  metadata.gz: f4c048186c71d73e960052bf22b721ae2167fc924da6066c0d962925d66b847f111b87c6be6565a5d63364f20dcd33d85dc66215734f8f1307f3c469a1fc07f3
+  data.tar.gz: 27dac2e5ac165e6c48cf767340cccb6f8a51ea56b252599db2427b4effe3d9079a57dcbad5bebd5b8b051e3e07620d180dc2bbff23c1d0269a13184b7efd3588

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Selective
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/exe/selective

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+
+# We test selective-ruby using selective-ruby. This means that
+# SimpleCov.start must be called before our code is loaded.
+if ENV["SELECTIVE_SIMPLECOV"]
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+require "selective-ruby-core"
+
+Selective::Ruby::Core::Init.run(ARGV.dup)

data/lib/bin/build_env.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+
+# Detect the platform (only GitHub Actions in this case)
+if [ -n "$GITHUB_ACTIONS" ]; then
+  platform=github_actions
+  branch=${GITHUB_HEAD_REF:-$GITHUB_REF_NAME}
+  target_branch=$GITHUB_BASE_REF
+  actor=$GITHUB_ACTOR
+  sha=$GITHUB_SHA
+  run_id=$GITHUB_RUN_ID
+  run_attempt=$GITHUB_RUN_ATTEMPT
+  runner_id=$SELECTIVE_RUNNER_ID
+  commit_message=$(git log --format=%s -n 1 $sha)
+  committer_name=$(git show -s --format='%an' -n 1 $sha)
+  committer_email=$(git show -s --format='%ae' -n 1 $sha)
+elif [ -n "$CIRCLECI" ]; then
+  platform=circleci
+  branch=$CIRCLE_BRANCH
+  actor=${CIRCLE_USERNAME:-$CIRCLE_PR_USERNAME}
+  sha=$CIRCLE_SHA1
+  run_attempt=$CIRCLE_BUILD_NUM
+  runner_id=$CIRCLE_NODE_INDEX
+  commit_message=$(git log --format=%s -n 1 $sha)
+  committer_name=$(git show -s --format='%an' -n 1 $sha)
+  committer_email=$(git show -s --format='%ae' -n 1 $sha)
+elif [ -n "$SEMAPHORE" ]; then
+  platform=semaphore
+  branch=${SEMAPHORE_GIT_PR_BRANCH:-$SEMAPHORE_GIT_BRANCH}
+  if [ -n "$SEMAPHORE_GIT_PR_BRANCH" ]; then
+    target_branch=$SEMAPHORE_GIT_BRANCH
+  fi
+  actor=$SEMAPHORE_GIT_COMMITTER
+  sha=$SEMAPHORE_GIT_SHA
+  run_id=$SEMAPHORE_WORKFLOW_ID
+  run_attempt=1
+  runner_id=$SEMAPHORE_JOB_ID
+  pr_title=$SEMAPHORE_GIT_PR_NAME
+  commit_message=$(git log --format=%s -n 1 $sha)
+  committer_name=$(git show -s --format='%an' -n 1 $sha)
+  committer_email=$(git show -s --format='%ae' -n 1 $sha)
+elif [ -n "$MINT" ]; then
+  platform=mint
+  branch="${MINT_GIT_REF_NAME}"
+  actor="${MINT_ACTOR}"
+  sha="${MINT_GIT_COMMIT_SHA}"
+  run_id="${MINT_RUN_ID}"
+  run_attempt="${MINT_TASK_ATTEMPT_NUMBER}"
+  runner_id="${MINT_PARALLEL_INDEX}"
+  # Mint does not preserve the .git directory by default to improve the likelihood of cache hits. Instead
+  # of asking git for commit information, then, we rely on the mint/git-clone leaf to populate the necessary
+  # metadata in environment variables.
+  commit_message="${MINT_GIT_COMMIT_SUMMARY}"
+  committer_name="${MINT_GIT_COMMITTER_NAME}"
+  committer_email="${MINT_GIT_COMMITTER_EMAIL}"
+fi
+
+function escape() {
+  echo -n "$1" | sed 's/"/\\"/g'
+}
+
+# Output the JSON
+cat <<EOF
+  {
+    "api_key": "$(escape "${SELECTIVE_API_KEY}")",
+    "host": "$(escape "${SELECTIVE_HOST:-wss://app.selective.ci}")",
+    "platform": "$(escape "${SELECTIVE_PLATFORM:-$platform}")",
+    "branch": "$(escape "${SELECTIVE_BRANCH:-$branch}")",
+    "pr_title": "$(escape "${SELECTIVE_PR_TITLE:-$pr_title}")",
+    "target_branch": "$(escape "${SELECTIVE_TARGET_BRANCH:-$target_branch}")",
+    "actor": "$(escape "${SELECTIVE_ACTOR:-$actor}")",
+    "sha": "$(escape "${SELECTIVE_SHA:-$sha}")",
+    "run_id": "$(escape "${SELECTIVE_RUN_ID:-$run_id}")",
+    "run_attempt": "$(escape "${SELECTIVE_RUN_ATTEMPT:-$run_attempt}")",
+    "runner_id": "$(escape "${SELECTIVE_RUNNER_ID:-$runner_id}")",
+    "commit_message": "$(escape "${SELECTIVE_COMMIT_MESSAGE:-$commit_message}")",
+    "committer_name": "$(escape "${SELECTIVE_COMMITTER_NAME:-$committer_name}")",
+    "committer_email": "$(escape "${SELECTIVE_COMMITTER_EMAIL:-$committer_email}")"
+  }
+EOF

data/lib/bin/file_correlation_collector.sh

@@ -0,0 +1,141 @@
+#!/bin/bash
+
+# The first argument is the number of commits to process
+branch=$1
+num_commits=$2
+
+# Initialize an associative array to hold the files to check
+declare -A files_to_check
+
+# Populate the array with the script arguments, starting from the second argument
+for file in "${@:3}"
+do
+  files_to_check["$file"]=1
+done
+
+# Get a list of all commit hashes, in reverse order
+all_commits=$(git log origin/$branch --no-merges --format=%H --reverse -n $num_commits)
+
+# Initialize an associative array to store the test files
+declare -A test_files
+declare -A uncorrelated_test_files
+
+# Initialize an array to store the files changed in the previous commit
+prev_changed_files=()
+
+# For each commit...
+for commit in $all_commits
+do
+  # Get a list of all files that were changed in the current commit
+  files=$(git diff-tree --no-commit-id --name-only -r $commit)
+
+  declare -A correlated_test_files
+
+  # # For each file in the list of files changed in the previous commit...
+  for file in "${prev_changed_files[@]}"
+  do
+    # If the file is in the list of files to check...
+    if [[ ${files_to_check[$file]} ]]; then
+      # For each file...
+      for test_file in $files
+      do
+        # If the file is in the test/ directory and ends with _test.rb...
+        if [[ $test_file == spec/*_spec.rb ]]
+        then
+          # Increment the count in the associative array
+          test_files["$file|$test_file"]=$((test_files["$file|$test_file"]+1))
+          # Add the test file to the correlated_test_files array
+          correlated_test_files["$test_file"]=1
+        fi
+      done
+    fi
+  done
+
+  # For each file in the list of files changed in the current commit...
+  for file in $files
+  do
+    # If the file is in the list of files to check...
+    if [[ ${files_to_check[$file]} ]]; then
+      # For each file...
+      for test_file in $files
+      do
+        # If the file is in the test/ directory and ends with _test.rb...
+        if [[ $test_file == spec/*_spec.rb ]]
+        then
+          # Increment the count in the associative array
+          test_files["$file|$test_file"]=$((test_files["$file|$test_file"]+1))
+          # Add the test file to the correlated_test_files array
+          correlated_test_files["$test_file"]=1
+        fi
+      done
+    fi
+  done
+
+  # For each file...
+  for test_file in $files
+  do
+    # If the file is in the test/ directory and ends with _test.rb...
+    if [[ $test_file == spec/*_spec.rb ]]
+    then
+      # If the test file is not correlated to any of the files to check in the current commit...
+      if [[ -z ${correlated_test_files[$test_file]} ]]
+      then
+        # Increment the count in the associative array
+        uncorrelated_test_files["$test_file"]=$((uncorrelated_test_files["$test_file"]+1))
+      fi
+    fi
+  done
+
+  # Clear the correlated_test_files array for the next commit
+  unset correlated_test_files
+
+  # Store the list of files changed in this commit for the next iteration
+  prev_changed_files=($files)
+done
+
+# OUTPUT
+
+# Initialize an associative array to hold the JSON strings for each file
+declare -A file_jsons
+
+# Add the test_files to the file_jsons associative array
+for key in "${!test_files[@]}"
+do
+  file=${key%|*}
+  test_file=${key#*|}
+  count=${test_files[$key]}
+  # Append to the JSON string for this file
+  file_jsons["$file"]+="\"$test_file\": $count,"
+done
+
+# Initialize an empty string for the test_files JSON
+correlated_files_json=""
+
+# Add the file_jsons to the correlated_files_json string
+for file in "${!file_jsons[@]}"
+do
+  # Remove the trailing comma from the JSON string for this file
+  file_json=${file_jsons[$file]%?}
+  # Append to the correlated_files_json string
+  correlated_files_json+="\"$file\": { $file_json },"
+done
+
+# Remove the trailing comma from the correlated_files_json string
+correlated_files_json=${correlated_files_json%?}
+
+# Initialize an empty string for the uncorrelated_test_files JSON
+uncorrelated_files_json=""
+
+# Add the uncorrelated_test_files to the uncorrelated_files_json string
+for key in "${!uncorrelated_test_files[@]}"
+do
+  count=${uncorrelated_test_files[$key]}
+  # Append to the uncorrelated_files_json string
+  uncorrelated_files_json+="\"$key\": $count,"
+done
+
+# Remove the trailing comma from the uncorrelated_files_json string
+uncorrelated_files_json=${uncorrelated_files_json%?}
+
+# Output the JSON
+echo "{ \"correlated_files\": { $correlated_files_json }, \"uncorrelated_files\": { $uncorrelated_files_json } }"

data/lib/selective/ruby/core/controller.rb

@@ -0,0 +1,359 @@
+require "logger"
+require "uri"
+require "fileutils"
+
+module Selective
+  module Ruby
+    module Core
+      class Controller
+        include Helper
+        @@selective_suppress_reporting = false
+        @@report_at_finish = {}
+
+        REQUIRED_CONFIGURATION = {
+          "host" => "SELECTIVE_HOST",
+          "api_key" => "SELECTIVE_API_KEY",
+          "platform" => "SELECTIVE_PLATFORM",
+          "run_id" => "SELECTIVE_RUN_ID",
+          "run_attempt" => "SELECTIVE_RUN_ATTEMPT",
+          "branch" => "SELECTIVE_BRANCH"
+        }.freeze
+
+        def initialize(runner_class, runner_args, debug: false, log: false)
+          @debug = debug
+          @runner = runner_class.new(runner_args, method(:test_case_callback))
+          @retries = 0
+          @runner_id = safe_filename(get_runner_id)
+          @logger = init_logger(log)
+        end
+
+        def start(reconnect: false)
+          @pipe = NamedPipe.new("/tmp/#{runner_id}_2", "/tmp/#{runner_id}_1")
+          @transport_pid = spawn_transport_process(reconnect: reconnect)
+
+          handle_termination_signals(transport_pid)
+          wait_for_connectivity
+          run_main_loop
+        rescue ConnectionLostError
+          retry!
+        rescue => e
+          with_error_handling { raise e }
+        end
+
+        def exec
+          runner.exec
+        rescue => e
+          with_error_handling(include_header: false) { raise e }
+        end
+
+        def self.suppress_reporting!
+          @@selective_suppress_reporting = true
+        end
+
+        def self.restore_reporting!
+          @@selective_suppress_reporting = false
+        end
+
+        def self.suppress_reporting?
+          @@selective_suppress_reporting
+        end
+
+        def self.report_at_finish
+          @@report_at_finish
+        end
+
+        private
+
+        attr_reader :runner, :pipe, :transport_pid, :retries, :logger, :runner_id, :diff
+
+        def get_runner_id
+          runner_id = build_env["runner_id"]
+          return generate_runner_id if runner_id.nil? || runner_id.empty?
+
+          runner_id
+        end
+
+        def init_logger(enabled)
+          if enabled
+            FileUtils.mkdir_p("log")
+            Logger.new("log/#{runner_id}.log")
+          else
+            Logger.new("/dev/null")
+          end
+        end
+
+        def run_main_loop
+          loop do
+            message = pipe.read
+            response = JSON.parse(message, symbolize_names: true)
+
+            @logger.info("Received Command: #{response}")
+            break if handle_command(response) == :break
+          end
+        end
+
+        def retry!
+          @retries += 1
+
+          with_error_handling { raise "Too many retries" } if retries > 10
+
+          puts("Retrying in #{retries} seconds...") if debug?
+          sleep(retries > 4 ? 4 : retries)
+          kill_transport
+
+          pipe.reset!
+          start(reconnect: true)
+        end
+
+        def write(data)
+          pipe.write JSON.dump(data)
+        end
+
+        def generate_runner_id
+          "selgen-#{SecureRandom.hex(4)}"
+        end
+
+        def transport_url(reconnect: false)
+          base_transport_url_params[:reconnect] = true if reconnect
+          query_string = URI.encode_www_form(base_transport_url_params)
+          "#{build_env["host"]}/transport/websocket?#{query_string}"
+        end
+
+        def base_transport_url_params
+          @base_transport_url_params ||= begin
+            api_key = build_env["api_key"]
+            run_id = build_env["run_id"]
+            run_attempt = build_env["run_attempt"]
+
+            metadata = build_env.reject { |k,v| %w(host runner_id api_key run_id run_attempt).include?(k) }
+
+            {
+              "api_key" => api_key,
+              "run_id" => run_id,
+              "run_attempt" => run_attempt,
+              "runner_id" => runner_id,
+              "language" => "ruby",
+              "core_version" => Selective::Ruby::Core::VERSION,
+              "framework" => runner.framework,
+              "framework_version" => runner.framework_version,
+              "framework_wrapper_version" => runner.wrapper_version,
+            }.merge(metadata: metadata.to_json)
+          end
+        end
+
+        def build_env
+          @build_env ||= begin
+            result = `#{File.join(ROOT_GEM_PATH, "lib", "bin", "build_env.sh")}`
+            JSON.parse(result).tap do |env|
+              validate_build_env(env)
+            end
+          end
+        end
+
+        def validate_build_env(env)
+          missing = REQUIRED_CONFIGURATION.each_with_object([]) do |(key, env_var), arry|
+            arry << env_var if env[key].nil? || env[key].empty?
+          end
+
+          with_error_handling do
+            raise "Missing required environment variables: #{missing.join(", ")}" unless missing.empty?
+            raise "Invalid host: #{env['host']}" unless env['host'].match?(/^wss?:\/\//)
+          end
+        end
+
+        def spawn_transport_process(reconnect: false)
+          transport_path = File.join(ROOT_GEM_PATH, "lib", "bin", "transport")
+          get_transport_path = File.join(ROOT_GEM_PATH, "bin", "get_transport")
+
+          if !File.exist?(transport_path)
+            # The get_transport script is not released with the gem, so this
+            # code is intended for development/CI purposes.
+            if File.exist?(get_transport_path)
+              output, status = Open3.capture2e(get_transport_path)
+              if !status.success?
+                puts <<~TEXT
+                  Failed to download transport binary.
+
+                  #{output}
+                TEXT
+              end
+            else
+              with_error_handling do
+                raise "Selective transport binary not found. Please contact support or compile it manually. See: https://github.com/selectiveci/transport"
+              end
+            end
+          end
+
+          Process.spawn(transport_path, transport_url(reconnect: reconnect), runner_id).tap do |pid|
+            Process.detach(pid)
+          end
+        end
+
+        def wait_for_connectivity
+          @connectivity = false
+
+          Thread.new do
+            sleep(30)
+            unless @connectivity
+              puts "Transport process failed to start. Exiting..."
+              kill_transport
+              exit(1)
+            end
+          end
+
+          loop do
+            message = pipe.read
+
+            # The message is nil until the transport opens the pipe
+            # for writing. So, we must handle that here.
+            next sleep(0.1) if message.nil?
+
+            response = JSON.parse(message, symbolize_names: true)
+            @connectivity = true if response[:command] == "connected"
+            break
+          end
+        end
+
+        def handle_termination_signals(pid)
+          ["INT", "TERM"].each do |signal|
+            Signal.trap(signal) do
+              # :nocov:
+              kill_transport(signal: signal)
+              exit
+              # :nocov:
+            end
+          end
+        end
+
+        def kill_transport(signal: "TERM")
+          begin
+            pipe.write "exit"
+
+            # Give up to 5 seconds for graceful exit
+            # before killing it below
+            1..5.times do
+              Process.getpgid(transport_pid)
+
+              sleep(1)
+            end
+          rescue ConnectionLostError, IOError
+            # If the pipe is close, move straight to killing
+            # it forcefully.
+          end
+
+          # :nocov:
+          Process.kill(signal, transport_pid)
+          # :nocov:
+        rescue Errno::ESRCH
+          # Process already gone noop
+        end
+
+        def handle_command(data)
+          if respond_to? "handle_#{data[:command]}", true
+            send("handle_#{data[:command]}", data)
+          else
+            raise "Unknown command received: #{data[:command]}" if debug?
+          end
+        end
+
+        def handle_print_notice(data)
+          print_notice(data[:message])
+        end
+
+        def handle_reconnect(_data)
+          kill_transport
+          pipe.reset!
+          start(reconnect: true)
+        end
+
+        def handle_test_manifest(_data)
+          self.class.restore_reporting!
+          @logger.info("Sending Response: test_manifest")
+          data = {test_cases: runner.manifest["examples"] || runner.manifest["test_cases"]}
+          num_commits = build_env["num_commits"] || 1000
+          if (diff = get_diff(num_commits))
+            data[:modified_test_files] = modified_test_files(diff)
+            data[:correlated_files] = correlated_files(diff, num_commits)
+          end
+          write({type: "test_manifest", data: data})
+        end
+
+        def handle_run_test_cases(data)
+          runner.run_test_cases(data[:test_case_ids])
+        end
+
+        # Todo: Rename this command to match the method name
+        # on the runner wrapper. We should do something similar
+        # to normalize handle_print_notice and handle_print_message
+        def handle_remove_failed_test_case_result(data)
+          runner.remove_test_case_result(data[:test_case_id])
+        end
+
+        def handle_print_message(data)
+          print_warning(data[:message])
+        end
+
+        def handle_close(data)
+          exit_status = data[:exit_status]
+          self.class.restore_reporting!
+
+          with_error_handling do
+            Selective::Ruby::Core::Controller.report_at_finish[:connection_retries] = @retries
+            write({type: "report_at_finish", data: Selective::Ruby::Core::Controller.report_at_finish})
+
+            runner.finish unless exit_status.is_a?(Integer)
+          end
+
+          kill_transport
+          pipe.delete_pipes
+          exit(exit_status || runner.exit_status)
+          # This :break is here for the sake of test where
+          # we cannot exit but we need to break the loop
+          :break
+        end
+
+        def correlated_files(diff, num_commits)
+          Selective::Ruby::Core::FileCorrelator.new(diff, num_commits, build_env["target_branch"]).correlate
+        end
+
+        def test_case_callback(test_case)
+          @logger.info("Sending Response: test_case_result: #{test_case[:id]}")
+          write({type: "test_case_result", data: test_case})
+        end
+
+        def modified_test_files(diff)
+          @modified_test_files ||= begin
+            diff.filter do |f|
+              f.match?(/^#{runner.base_test_path}/)
+            end
+          end
+        end
+
+        def get_diff(num_commits)
+          target_branch = build_env["target_branch"]
+          return if target_branch.nil? || target_branch.empty?
+
+          Open3.capture2e("git fetch origin #{target_branch} --depth=#{num_commits}").then do |output, status|
+            unless status.success?
+              print_warning "Selective was unable to fetch the target branch. This may result in a sub-optimal test order. If the issue persists, please contact support. The output was:\n\n#{output}"
+              return
+            end
+          end
+
+          Open3.capture2e("git diff origin/#{target_branch} --name-only").then do |output, status|
+            if status.success?
+              output.split("\n")
+            else
+              print_warning "Selective was unable to diff with the target branch. This may result in a sub-optimal test order. If the issue persists, please contact support. The output was:\n\n#{output}"
+              nil
+            end
+          end
+        end
+
+        def debug?
+          @debug
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/file_correlator.rb

@@ -0,0 +1,41 @@
+module Selective
+  module Ruby
+    module Core
+      class FileCorrelator
+        include Helper
+
+        class FileCorrelatorError < StandardError; end
+
+        FILE_CORRELATION_COLLECTOR_PATH = File.join(ROOT_GEM_PATH, "lib", "bin", "file_correlation_collector.sh")
+
+        def initialize(diff, num_commits, target_branch)
+          @diff = diff.reject {|f| f =~ /^spec\// }
+          @num_commits = num_commits
+          @target_branch = target_branch
+        end
+
+        def correlate
+          JSON.parse(get_correlated_files, symbolize_names: true)
+        rescue FileCorrelatorError, JSON::ParserError
+          print_warning(<<~MSG)
+            Selective was unable to correlate the diff to test files. This may result in a sub-optimal test order.
+            If the issue persists, please contact support.
+          MSG
+        end
+
+        private
+
+        attr_reader :diff, :num_commits, :target_branch
+
+        def get_correlated_files
+          Open3.capture2e("#{FILE_CORRELATION_COLLECTOR_PATH} #{target_branch} #{num_commits} #{diff.join(" ")}").then do |output, status|
+
+            raise FileCorrelatorError unless status.success?
+
+            output
+          end
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/helper.rb

@@ -0,0 +1,76 @@
+module Selective
+  module Ruby
+    module Core
+      module Helper
+        def safe_filename(filename)
+          filename
+            .gsub(/[\/\\:*?"<>|\n\r]+/, '_')
+            .gsub(/^\.+|\.+$/, '')
+            .strip[0, 255]
+        end
+
+        def with_error_handling(include_header: true)
+          yield
+        rescue => e
+          raise e if debug?
+          header = <<~TEXT
+            An error occurred. Please rerun with --debug
+            and contact support at https://selective.ci/support
+          TEXT
+
+          unless $selective_banner_displayed
+            header = <<~TEXT
+              #{banner}
+
+              #{header}
+            TEXT
+          end
+
+          puts_indented <<~TEXT
+            \e[31m
+            #{header if include_header}
+            #{e.message}
+            \e[0m
+          TEXT
+
+          exit 1
+        end
+
+        def print_warning(message)
+          puts_indented <<~TEXT
+            \e[33m
+            #{message}
+            \e[0m
+          TEXT
+        end
+
+        def print_notice(message)
+          puts_indented <<~TEXT
+            #{banner unless $selective_banner_displayed}
+            #{message}
+          TEXT
+        end
+
+        def puts_indented(text)
+          puts text.gsub(/^/, "  ")
+        end
+
+        def banner
+          Helper.banner
+        end
+
+        def self.banner
+          $selective_banner_displayed = true
+          <<~BANNER
+             ____       _           _   _
+            / ___|  ___| | ___  ___| |_(_)_   _____
+            \\___ \\ / _ \\ |/ _ \\/ __| __| \\ \\ / / _ \\
+             ___) |  __/ |  __/ (__| |_| |\\ V /  __/
+            |____/ \\___|_|\\___|\\___|\\__|_| \\_/ \\___|
+            ________________________________________
+          BANNER
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/named_pipe.rb

@@ -0,0 +1,101 @@
+module Selective
+  module Ruby
+    module Core
+      class NamedPipe
+        attr_reader :read_pipe_path, :write_pipe_path
+
+        def initialize(read_pipe_path, write_pipe_path, skip_reset: false)
+          @read_pipe_path = read_pipe_path
+          @write_pipe_path = write_pipe_path
+
+          delete_pipes unless skip_reset
+          initialize_pipes
+        end
+
+        def initialize_pipes
+          create_pipes
+
+          # Open the read and write pipes in separate threads
+          Thread.new do
+            @read_pipe = File.open(read_pipe_path, "r")
+          end
+          Thread.new do
+            @write_pipe = File.open(write_pipe_path, "w")
+          end
+        end
+
+        def write(message)
+          return unless write_pipe
+
+          chunk_size = 1024  # 1KB chunks
+          offset = 0
+          begin
+            while offset < message.bytesize
+              chunk = message.byteslice(offset, chunk_size)
+
+              write_pipe.write(chunk)
+              write_pipe.flush
+
+              offset += chunk_size
+            end
+
+            write_pipe.write("\n")
+            write_pipe.flush
+          rescue Errno::EPIPE
+            raise ConnectionLostError
+          end
+        end
+
+        def read
+          return unless read_pipe
+          begin
+            message = read_pipe.gets.chomp
+          rescue NoMethodError => e
+            if e.name == :chomp
+              raise ConnectionLostError
+            else
+              raise e
+            end
+          end
+          message
+        end
+
+        def reset!
+          delete_pipes
+          initialize_pipes
+        end
+
+        def delete_pipes
+          # Close the pipes before deleting them
+          read_pipe&.close
+          write_pipe&.close
+
+          # Allow threads to close before deleting pipes
+          sleep(0.1)
+
+          delete_pipe(read_pipe_path)
+          delete_pipe(write_pipe_path)
+        rescue Errno::EPIPE
+          # Noop
+        end
+
+        private
+
+        attr_reader :read_pipe, :write_pipe
+
+        def create_pipes
+          create_pipe(read_pipe_path)
+          create_pipe(write_pipe_path)
+        end
+
+        def create_pipe(path)
+          system("mkfifo #{path}") unless File.exist?(path)
+        end
+
+        def delete_pipe(path)
+          File.delete(path) if File.exist?(path)
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Selective
+  module Ruby
+    module Core
+      VERSION = "0.2.7"
+    end
+  end
+end

data/lib/selective-ruby-core.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "json"
+require "open3"
+require "#{__dir__}/selective/ruby/core/version"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/selective-ruby-core.rb")
+loader.ignore("#{__dir__}/selective/ruby/core/version.rb")
+loader.setup
+
+module Selective
+  module Ruby
+    module Core
+      class Error < StandardError; end
+      class ConnectionLostError < StandardError; end
+
+      ROOT_GEM_PATH = Gem.loaded_specs["selective-ruby-core"].full_gem_path
+
+      @@available_runners = {}
+
+      def self.register_runner(name, runner_class)
+        @@available_runners[name] = runner_class
+      end
+
+      def self.runner_for(name)
+        @@available_runners[name] || raise("Unknown runner #{name}")
+      end
+
+      class Init
+        def initialize(args)
+          @debug = !args.delete("--debug").nil?
+          @log = !args.delete("--log").nil?
+          @runner_name, @args, @command = parse_args(args)
+          require_runner
+        end
+
+        def self.run(args)
+          new(args).send(:run)
+        end
+
+        private
+
+        attr_reader :debug, :log, :runner_name, :args, :command
+
+        def run
+          Selective::Ruby::Core::Controller.new(runner_class, args, debug: debug, log: log).send(command)
+        end
+
+        def parse_args(args)
+          # Returns runner_name, args, command
+          if args[0] == "exec" # e.g. selective exec rspec
+            [args[1], args[2..], :exec]
+          else # e.g. selective rspec
+            [args[0], args[1..], :start]
+          end
+        end
+
+        def runner_class
+          Selective::Ruby::Core.runner_for(runner_name)
+        end
+
+        def require_runner
+          require "selective-ruby-#{runner_name}"
+        rescue LoadError
+          nil
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: selective-ruby-core
+version: !ruby/object:Gem::Version
+  version: 0.2.7
+platform: ruby
+authors:
+- Benjamin Wood
+- Nate Vick
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2025-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.12
+description: Selective is an intelligent test runner for your current CI provider.
+  Get real-time test results, intelligent ordering based on code changes, shorter
+  run times, automatic flake detection, the ability to re-enqueue failed tests, and
+  more.
+email:
+- ben@hint.io
+- nate@hint.io
+executables:
+- selective
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- exe/selective
+- lib/bin/build_env.sh
+- lib/bin/file_correlation_collector.sh
+- lib/selective-ruby-core.rb
+- lib/selective/ruby/core/controller.rb
+- lib/selective/ruby/core/file_correlator.rb
+- lib/selective/ruby/core/helper.rb
+- lib/selective/ruby/core/named_pipe.rb
+- lib/selective/ruby/core/version.rb
+homepage: https://www.selective.ci
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.selective.ci
+  source_code_uri: http://github.com/selectiveci/selective-ruby-core
+  changelog_uri: https://github.com/selectiveci/selective-ruby-core/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key: 
+specification_version: 4
+summary: Selective Ruby Client Core
+test_files: []