mergify-ci-core 2026.10.8-aarch64-linux

data/lib/mergify/ci/core/native.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Mergify
+  module CI
+    module Core
+      # The Rust extension over mergify-ci-session: the session shared with the
+      # pytest and TypeScript clients.
+      #
+      # Loading is best-effort by design. A precompiled gem carries one
+      # extension per Ruby under `<ruby>/`, the source gem compiles one
+      # alongside this file, and a platform we publish neither for gets
+      # neither. Detection is one input to telemetry, not the point of the gem,
+      # so an absent extension degrades what we can report rather than breaking
+      # the suite under test -- the same fail-open posture the napi binding
+      # takes when a platform has no prebuilt binary. `load_error` keeps the
+      # reason, for callers that want to say so.
+      module Native
+        class << self
+          # The LoadError that prevented the extension loading, or nil.
+          attr_accessor :load_error
+
+          def available?
+            load_error.nil?
+          end
+
+          # Which of the two failed requires actually explains the absence.
+          #
+          # A precompiled gem ships lib/mergify/ci/core/<ruby>/mergify_ci.<dlext>,
+          # so when one is packed for this Ruby that require is the real attempt:
+          # it fails with something like "version `GLIBC_2.29' not found", and the
+          # fallback that follows only ever adds "cannot load such file", which
+          # sends the reader looking for the wrong thing. With no extension for
+          # this Ruby -- the source gem, or a platform we publish no gem for --
+          # it is the other way round.
+          # Require a file next to this one, returning the LoadError instead of
+          # raising it. Two attempts read better as values than as nested rescues.
+          def attempt_require(path)
+            require_relative path
+            nil
+          rescue LoadError => e
+            e
+          end
+
+          def load_failure_reason(versioned, fallback)
+            packed = Dir.glob(File.join(__dir__, RUBY_VERSION.to_f.to_s, 'mergify_ci.*')).any?
+            packed ? versioned : fallback
+          end
+        end
+      end
+    end
+  end
+end
+
+# Precompiled gems ship lib/mergify/ci/core/<ruby>/mergify_ci.<dlext>; the
+# source gem and any local `rake compile` put one beside this file instead.
+versioned_error = Mergify::CI::Core::Native.attempt_require("#{RUBY_VERSION.to_f}/mergify_ci")
+fallback_error = versioned_error && Mergify::CI::Core::Native.attempt_require('mergify_ci')
+
+if fallback_error
+  Mergify::CI::Core::Native.load_error =
+    Mergify::CI::Core::Native.load_failure_reason(versioned_error, fallback_error)
+end
+
+unless Mergify::CI::Core::Native.available?
+  # Stand in for the extension so callers can just ask, and get the same answer
+  # they would get from a machine that is not in CI. Branching on availability
+  # at every call site would only spread the same nil back through the caller.
+  module Mergify
+    module CI
+      module Core
+        module Native
+          # A session that detects nothing, as on a machine that is not in CI.
+          class Session
+            def self.start(*)
+              new
+            end
+
+            # Nothing detected, so nothing to report to.
+            def reports?
+              false
+            end
+
+            def repository_name
+              nil
+            end
+
+            # Nothing detected: no run to name.
+            def run_id
+              nil
+            end
+
+            # Nothing to send a verdict with: it neither folds nor reports.
+            def record_test(_example_id, _status, _run_time); end
+
+            # Nothing to ask with: every example runs.
+            def select(_example_ids)
+              { 'outcome' => 'full' }
+            end
+
+            def executed_count
+              0
+            end
+
+            def report_verdict(_failed_outside_examples); end
+
+            def captured_verdict
+              nil
+            end
+
+            # Nothing to send a trace with either.
+            def record_case(_example); end
+
+            def record_retry(_example_id, _status, _duration_ms); end
+
+            def report_trace(_failed); end
+
+            # Nothing reported: nothing to say.
+            def summary(_partial)
+              []
+            end
+
+            def captured_trace
+              nil
+            end
+
+            # Nothing to rerun with.
+            def prepare_reruns(_example_ids)
+              nil
+            end
+
+            def state_former_names(_former_names); end
+
+            def flaky_detection_runs?
+              false
+            end
+
+            def flaky_detection_fails_the_run?
+              false
+            end
+
+            def record_attempt(_test, _outcome, _duration_ms); end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mergify/ci/core/test_names.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Mergify
+  module CI
+    module Core
+      # How the Ruby clients name a test their framework declares inside
+      # groups, an RSpec `describe` or a Minitest spec one, so both give the
+      # same test the same name: `<file> > <groups> > <title>`, the shape the
+      # TypeScript clients use too, the file relative to the directory the run
+      # started in. Nothing in it counts tests, so adding one names no other
+      # one anew.
+      module TestNames
+        module_function
+
+        SEPARATOR = ' > '
+
+        # What opens and closes a block, around the code `block_text` keeps.
+        DELIMITERS = [/\A\{(.*)\}\z/m, /\Ado\b(.*)\bend\z/m].freeze
+
+        # The name of the test `title` declared in `file`, in `groups`,
+        # outermost first.
+        def spec_name(file, groups, title, root)
+          [relative(file, root), *groups, title].join(SEPARATOR)
+        end
+
+        # `file` relative to `root`, or as it is when it is not under it
+        # (another drive, on Windows). Both are expanded, so a root given
+        # without a drive gets the one the file does.
+        def relative(file, root)
+          Pathname.new(File.expand_path(file)).relative_path_from(Pathname.new(File.expand_path(root))).to_s
+        rescue ArgumentError
+          file
+        end
+
+        # The title of a test written without text of its own: the code of its
+        # block, on one line, without its braces or its `do` and `end`. Nil
+        # when there is none to read: an empty block, or one whose file is
+        # gone or that an `eval` defined.
+        def block_text(block)
+          code = block_code(block)
+          return unless code
+
+          inner = DELIMITERS.lazy.filter_map { |delimited| code[delimited, 1] }.first
+          text = inner&.split&.join(' ')
+          text unless text.nil? || text.empty?
+        end
+
+        # The source of `block` (a proc, or a method one defined), as its file
+        # holds it.
+        def block_code(block)
+          file, first_line, first_column, last_line, last_column = code_location(block)
+          return unless file && File.file?(file)
+
+          lines = File.readlines(file)[(first_line - 1)..(last_line - 1)]
+          between(lines, first_column, last_column) if lines&.size == last_line - first_line + 1
+        end
+
+        # `lines` from `first_column` of the first to `last_column` of the last.
+        def between(lines, first_column, last_column)
+          lines[-1] = lines[-1].byteslice(0, last_column)
+          lines[0] = lines[0].byteslice(first_column..)
+          lines.join
+        end
+
+        # Where Ruby compiled `block` from: its file, then the line and column
+        # it starts at and the ones it ends at, the columns in bytes. Nothing
+        # for code an `eval` compiled, which has no absolute path whatever file
+        # it claims, and whose columns are the evaluated string's.
+        def code_location(block)
+          code = RubyVM::InstructionSequence.of(block)
+          location = code&.to_a&.dig(4, :code_location)
+          [code.absolute_path, *location] if code&.absolute_path && location
+        end
+      end
+    end
+  end
+end

data/lib/mergify/ci/core/utils.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Mergify
+  module CI
+    module Core
+      # What every Ruby client reads of its own switches the same way.
+      module Utils
+        module_function
+
+        TRUTHY_STRINGS = %w[y yes t true on 1].freeze
+
+        # Returns true when the named environment variable holds a truthy value.
+        def env_truthy?(key)
+          TRUTHY_STRINGS.include?(ENV.fetch(key, '').downcase)
+        end
+      end
+    end
+  end
+end

data/lib/mergify/ci/core/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Mergify
+  module CI
+    module Core
+      # Placeholder: the release workflow stamps the real version from the git
+      # tag at build time, the same one it stamps into every Ruby client built
+      # on this gem, which each pins exactly.
+      VERSION = '2026.10.8'
+    end
+  end
+end

data/lib/mergify/ci/core.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'core/version'
+require_relative 'core/utils'
+require_relative 'core/test_names'
+require_relative 'core/native'

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: mergify-ci-core
+version: !ruby/object:Gem::Version
+  version: 2026.10.8
+platform: aarch64-linux
+authors:
+- Mergify
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-10-23 00:00:00.000000000 Z
+dependencies: []
+description: 'The compiled session rspec-mergify and minitest-mergify run on: CI detection,
+  the trace, the verdict, quarantine, Test Selection and flaky detection.'
+email:
+- support@mergify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- THIRD_PARTY_LICENSES
+- lib/mergify/ci/core.rb
+- lib/mergify/ci/core/3.1/mergify_ci.so
+- lib/mergify/ci/core/3.2/mergify_ci.so
+- lib/mergify/ci/core/3.3/mergify_ci.so
+- lib/mergify/ci/core/3.4/mergify_ci.so
+- lib/mergify/ci/core/4.0/mergify_ci.so
+- lib/mergify/ci/core/native.rb
+- lib/mergify/ci/core/test_names.rb
+- lib/mergify/ci/core/utils.rb
+- lib/mergify/ci/core/version.rb
+homepage: https://docs.mergify.com/test-engine/
+licenses:
+- LicenseRef-Mergify-Proprietary
+metadata:
+  homepage_uri: https://docs.mergify.com/test-engine/
+  bug_tracker_uri: https://github.com/Mergifyio/mergify-cli/issues
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: The native core of Mergify's Ruby test clients
+test_files: []