git 5.0.4 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04104dc235012494d8e6b9718421d02f040a6216aec0991bce962b17b1e61c43
-  data.tar.gz: bbfe9f44799e29f24e5baa4095d42159af56b9a8c568a51b9358d8ba3758e90f
+  metadata.gz: 10e1f676a8b4122760435d18757f8dbb0f67e8e0f59f2e85463c0c7c93add807
+  data.tar.gz: 47687fd4a08c52945fb1eb8aa668429e33c7e4e9ce06f6a8664dc2f83e0372bc
 SHA512:
-  metadata.gz: 0cc7b0792f17d8972999f33f7412477996a6d865bcce5fb24bf27bb9add5dc0ee83f8623e1940bf88a9deebcba1b409a2f3910ee99dbf1d6d33b2eb5dc5afa86
-  data.tar.gz: 64d890f4273c6a56389bfa5ae42bce90a4aa5d8e63a1536361662bab9cc0ba88e7e317f47bc9b1dbaa0e454b8a5bb7b065bd87aec8a33e1f4367c68feb89092f
+  metadata.gz: 3073e1e644e4d927de4e78bb6b0a8f082e6c757353a68b53c0ac2035c8ebee978e8d4a0a4c3a5fcaccece86ce5139f433af86716193ae2f8b0a0d26d6d9119c0
+  data.tar.gz: dcc552a33be697647b62e780492d454d3da93b1c9c8de218363f5118125abc59c7aa331ed15c1b69eb87e2b60b205db466b9e5da7cc59022d0a1ae9f55d0384a

data/.github/workflows/continuous_integration.yml

@@ -5,7 +5,51 @@ on:
     branches: [main, 4.x]
   workflow_dispatch:
 
+# Cancel an in-progress run when the same PR (or branch) gets a new push. For
+# pull_request events github.ref is refs/pull/<n>/merge, so runs are grouped per PR
+# and pushing a new commit -- or force-pushing during a rebase -- no longer leaves a
+# full matrix running to completion against a commit nobody will merge.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
+  # RuboCop and YARD analyze source text, so their results do not depend on the
+  # runtime executing them: RuboCop's verdict is fixed by TargetRubyVersion in
+  # .rubocop.yml, not by the host Ruby. Running them once here instead of inside the
+  # matrix removes the single largest cost in the build -- RuboCop alone accounted for
+  # over half the wall time of the JRuby and TruffleRuby jobs -- while checking exactly
+  # the same things.
+  #
+  # Ruby 3.4 hosts this job rather than the newest supported Ruby because it gates
+  # merges: a lint gate should be insulated from churn in a brand-new major, and Ruby
+  # 4.0 deprecations still surface through the matrix jobs below, which do run 4.0.
+  # 3.3+ is also a hard floor here, since yard-lint is only installed on 3.3 and later
+  # (see the gemspec) and YARD itself cannot build on JRuby or TruffleRuby.
+  lint:
+    name: Lint and Docs
+
+    # Skip this job if triggered by a release PR
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v6
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+      - name: Run RuboCop and YARD
+        run: bundle exec rake rubocop yard
+        timeout-minutes: 15
+
   build:
     name: Ruby ${{ matrix.ruby }} on ${{ matrix.operating-system }}
 
@@ -15,42 +59,34 @@ jobs:
       (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
 
     runs-on: ${{ matrix.operating-system }}
-    continue-on-error: ${{ matrix.experimental == 'Yes' }}
     env: { JAVA_OPTS: -Djdk.io.File.enableADS=true }
 
     strategy:
       fail-fast: false
       matrix:
-        # Only the minimum required versions of JRuby and TruffleRuby are tested
-        ruby: ["3.2", "3.4", "4.0", "truffleruby-24.2.1", "jruby-10.0.0.1"]
+        # Only the minimum required versions of JRuby and TruffleRuby are tested.
+        #
+        ruby: ["3.2", "4.0", "truffleruby-24.2.1", "jruby-10.0.0.1"]
         operating-system: [ubuntu-latest]
-        experimental: [No]
-        java_version: [""]
         include:
           - ruby: "3.2"
             operating-system: windows-latest
-            experimental: No
-            java_version: ""
 
     steps:
       - name: Checkout Code
         uses: actions/checkout@v6
 
-      - name: Setup Java
-        if: matrix.java_version != ''
-        uses: actions/setup-java@v5
-        with:
-          distribution: 'temurin'
-          java-version: ${{ matrix.java_version }}
-
       - name: Setup Ruby
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true # runs 'bundle install' and caches installed gems automatically
 
-      - name: Run Build
-        run: bundle exec rake default
+      # Specs only. RuboCop and YARD run once in the lint job above instead of being
+      # repeated identically on every runtime. `rake build` still runs on every
+      # platform, as a prerequisite of the Test Gem step below.
+      - name: Run Specs
+        run: bundle exec rake spec
         timeout-minutes: 15
 
       # The unit suite enforces 100% line and branch coverage (see the "Test coverage
@@ -67,3 +103,256 @@ jobs:
 
       - name: Test Gem
         run: bundle exec rake test:gem
+
+  # The branch ruleset cannot require the matrix jobs above directly. A required status
+  # check is matched by name, and `build`'s name is a template -- GitHub only expands it
+  # into "Ruby 3.2 on ubuntu-latest" and friends when it evaluates the matrix. The
+  # job-level `if:` short-circuits before that happens, so a release PR reports one check
+  # named literally "Ruby ${{ matrix.ruby }} on ${{ matrix.operating-system }}" and the
+  # five expanded names never report at all. Required checks that never report block a PR
+  # indefinitely rather than passing, which is what stranded the v5.0.5 release PR.
+  #
+  # So the ruleset requires this job instead: one stable name, no matrix, no template to
+  # expand. It also decouples the required-check list from the matrix, so adding or
+  # dropping a Ruby version no longer needs a matching ruleset edit.
+  #
+  # This job carries the same release-PR guard as every job above, so that a release PR
+  # reports it as skipped rather than as a success for specs that never ran. Skipping is
+  # safe here and was not safe for `build`: this job's name is a literal string, so the
+  # check run exists and reports a skipped conclusion whether or not the job runs, and
+  # rulesets treat skipped as passing. A matrix job's name does not exist at all until the
+  # matrix is evaluated, which is the whole reason this job exists.
+  #
+  # `always()` is load-bearing and must stay. Without a status check function a job-level
+  # `if:` implies `success()`, so a failing matrix would skip this job -- and a skipped
+  # required check counts as passing, meaning a red build would merge. `always()` forces a
+  # real verdict on every run that is not a release PR. `!cancelled()` is not a substitute:
+  # a cancelled run would then skip the gate, and a skipped conclusion is one rulesets treat
+  # as passing -- so a build that never finished would stop blocking the merge.
+  #
+  # The case below accepts `success` only. `build` and this job now carry the same release-PR
+  # guard, so this job runs exactly when `build` ran; a `skipped` result would mean the two
+  # guards have drifted apart, and failing closed on it turns that into a loud failure rather
+  # than a silent pass.
+  build-complete:
+    name: All Specs Passed
+
+    needs: [build]
+
+    # Report a verdict on every non-release PR regardless of the matrix result, and skip
+    # on release PRs, where the matrix was never meant to run.
+    if: >-
+      always() &&
+      (github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--')))
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check the result of the build job
+        run: |
+          case "${{ needs.build.result }}" in
+            success)
+              echo "build: ${{ needs.build.result }}"
+              ;;
+            *)
+              echo "::error::build: ${{ needs.build.result }}"
+              exit 1
+              ;;
+          esac
+
+  # Everything above runs in English, because GitHub-hosted runners generate no locale
+  # beyond C/C.UTF-8. That makes git's translated diagnostics invisible to CI even
+  # though they are the default experience for any contributor whose shell locale is not
+  # English -- so a spec that matches an English git message passes here and fails for
+  # them, on code they did not touch. This job is what stops such a spec from reaching
+  # main. See issue #1670.
+  #
+  # German because git's `de` translation is close enough to complete that a
+  # message-matching assumption cannot hide behind a string that was never translated.
+  # Most of the suite is insulated from this by the LC_ALL pin in Git::ExecutionContext;
+  # what this job really exercises is the code that bypasses that pin.
+  locale:
+    name: Non-English Locale
+
+    # Skip this job if triggered by a release PR
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
+
+    runs-on: ubuntu-latest
+
+    # Set at job scope rather than on the spec step so that every step -- including the
+    # check below that the locale is real -- sees exactly the environment the suite runs
+    # under. Setting these before locale-gen is harmless: they are simply inert until
+    # the locale exists.
+    env:
+      LANG: de_DE.UTF-8
+      LC_ALL: de_DE.UTF-8
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v6
+
+      # Two separate things are missing from a stock runner, and skipping either one
+      # leaves the env above inert -- git keeps answering in English and the job proves
+      # nothing:
+      #
+      #   1. The locale itself. Only C and C.UTF-8 are generated, so setlocale fails for
+      #      anything else and every process falls back to English.
+      #   2. git's German message catalog. Unlike Debian, Ubuntu strips gettext catalogs
+      #      out of packages and ships them in language packs, so the installed git has
+      #      no de translation until language-pack-de provides one.
+      #
+      # `update-locale` is deliberately not run: it edits /etc/default/locale, which is
+      # only consulted for logins that do not already set LANG and LC_ALL, and this job
+      # sets both explicitly.
+      #
+      # The two apt settings below exist because this step reaches out to the Ubuntu
+      # archive, which is the only part of this job that can fail for reasons that have
+      # nothing to do with the code under test:
+      #
+      #   * `Acquire::Retries` retries an individual download that fails outright,
+      #     rather than failing the job on one unlucky mirror.
+      #   * `timeout-minutes` bounds a mirror that accepts the connection and then
+      #     stops responding, which retries cannot help with. Without it the step
+      #     inherits the 6 hour job default: run 32087601711 sat here for 12 minutes
+      #     before it was cancelled by hand, and would otherwise have held a runner
+      #     for the rest of the day. The whole job normally finishes in 53-118
+      #     seconds, so 5 minutes is generous while still failing the same morning.
+      #
+      - name: Install the German locale and message catalogs
+        timeout-minutes: 5
+        run: |
+          sudo apt-get -o Acquire::Retries=3 update -qq
+          sudo apt-get -o Acquire::Retries=3 install -y --no-install-recommends language-pack-de
+          sudo locale-gen de_DE.UTF-8
+
+      # Ruby 3.4 to share the bundler cache the lint job already warms. Nothing about
+      # this job is Ruby-version specific -- the locale is what is under test.
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+      # Guard against a vacuous pass. Diffing git's output against the same command run
+      # under LC_ALL=C proves translation is actually active, without pinning a German
+      # string that a future git release is free to reword.
+      - name: Verify the Locale Took Effect
+        run: |
+          dir="$(mktemp -d)"
+          localized="$(cd "$dir" && git status 2>&1 || true)"
+          english="$(cd "$dir" && LC_ALL=C git status 2>&1 || true)"
+          echo "LC_ALL=$LC_ALL -> $localized"
+          echo "LC_ALL=C -> $english"
+          if [ "$localized" = "$english" ]; then
+            echo "::error::git is still emitting English: de_DE.UTF-8 did not take effect, so this job would test nothing"
+            exit 1
+          fi
+
+      - name: Run Specs
+        run: bundle exec rake spec
+        timeout-minutes: 15
+
+  # On the ubuntu jobs above, `C.UTF-8` and `en_US.UTF-8` both resolve to a UTF-8 ctype
+  # (measured on the runner in issue #1669), and on windows the pinned value makes no
+  # difference under any value at all. So the non-ASCII regex coverage those jobs run
+  # passes whatever `Git::ExecutionContext` pins, and cannot tell a correct `LC_ALL`
+  # value from a wrong one. That blind spot is what let the original defect go
+  # unreported for eighteen months: the gem pinned `en_US.UTF-8`, stock Debian, Ubuntu,
+  # and RHEL images generate no such locale, git silently fell back to a C ctype, and
+  # every non-ASCII regex in `grep`, `log`, and the `config` value regexes returned a
+  # wrong answer with exit status zero -- while CI stayed green throughout.
+  #
+  # This job makes one run discriminating. `LOCPATH` overrides where glibc looks for
+  # compiled locale data, so pointing it at an empty directory takes away every locale
+  # that needs a locale archive -- `en_US.UTF-8` among them -- while leaving `C.UTF-8`
+  # working, because glibc 2.35 and later compile that one into the library itself.
+  # The suite then runs in an environment where the value shipped before #1681 fails
+  # and the value shipped now passes: no container image, no second bundle install,
+  # no cache miss. Measured on ubuntu:24.04 (glibc 2.39, the runner's base) with
+  # `en_US.UTF-8` generated first:
+  #
+  #   normal         en_US.UTF-8 charmap=UTF-8           C.UTF-8 charmap=UTF-8
+  #   LOCPATH=empty  en_US.UTF-8 charmap=ANSI_X3.4-1968  C.UTF-8 charmap=UTF-8
+  #
+  # This has to be a property of the run rather than of a spec. Never gate a spec on
+  # whether the pinned locale loads: such a spec skips itself in exactly the
+  # environments where this defect lives, which is how the defect went unreported for
+  # eighteen months.
+  #
+  # LANG is set explicitly so only `en_US.UTF-8` is taken away and the ambient
+  # environment stays UTF-8. The runner already sets this value; pinning it here keeps
+  # the job from depending on the image's default.
+  missing-locale:
+    name: Missing en_US.UTF-8 Locale
+
+    # Skip this job if triggered by a release PR
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'pull_request' && !startsWith(github.event.pull_request.head.ref, 'release-please--'))
+
+    runs-on: ubuntu-latest
+
+    env:
+      LANG: C.UTF-8
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v6
+
+      # Exported through GITHUB_ENV rather than set at job scope because the `runner`
+      # context is not available there, and the directory has to exist before anything
+      # reads a locale -- glibc warns on every process when LOCPATH names a directory
+      # that does not exist. RUNNER_TEMP rather than the workspace so that
+      # actions/checkout cannot clean it away.
+      - name: Point LOCPATH at an Empty Directory
+        run: |
+          mkdir -p "$RUNNER_TEMP/empty-locale-dir"
+          echo "LOCPATH=$RUNNER_TEMP/empty-locale-dir" >> "$GITHUB_ENV"
+
+      # Ruby 3.4 to share the bundler cache the lint job already warms. Nothing about
+      # this job is Ruby-version specific -- the locale environment is what differs.
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+      # Guard against a vacuous pass, functionally. `locale -a` still lists en_US.utf8
+      # under LOCPATH (measured) even though setlocale then refuses it, so asking git
+      # to match is the only assertion worth making: `.` spans the two-byte U+00C4 only
+      # under a UTF-8 ctype. The metacharacter-free control has to keep matching under
+      # the removed locale as well -- it matches bytes under any ctype, so if it fails,
+      # the probe never delivered UTF-8 bytes to git and the rest proves nothing.
+      - name: Verify the Run Discriminates
+        run: |
+          dir="$(mktemp -d)"
+          cd "$dir"
+          git init -q .
+          printf '\xc3\x84PFEL sind gut\n' > w.txt
+          git add w.txt
+
+          if ! LC_ALL=C.UTF-8 git grep -q '^.PFEL' -- w.txt; then
+            echo "::error::C.UTF-8 no longer yields a UTF-8 ctype under LOCPATH, so this job would fail for the wrong reason"
+            exit 1
+          fi
+          if ! LC_ALL=en_US.UTF-8 git grep -q 'PFEL sind' -- w.txt; then
+            echo "::error::the control pattern did not match, so this probe is not delivering UTF-8 bytes to git"
+            exit 1
+          fi
+          if LC_ALL=en_US.UTF-8 git grep -q '^.PFEL' -- w.txt; then
+            echo "::error::en_US.UTF-8 still yields a UTF-8 ctype, so this job cannot detect a wrong LC_ALL pin"
+            exit 1
+          fi
+          echo "en_US.UTF-8 is unusable and C.UTF-8 works: a wrong pin fails this job"
+
+      # The whole suite rather than the non-ASCII regex spec alone: the point is that
+      # this run is indistinguishable from any other except for the missing locale, so
+      # every locale-sensitive surface added later is covered without touching this
+      # file. It also keeps the coverage gate satisfied, which a single spec file
+      # cannot do.
+      - name: Run Specs
+        run: bundle exec rake spec
+        timeout-minutes: 15

data/.github/workflows/enforce_conventional_commits.yml

@@ -10,6 +10,12 @@ on:
       - main
       - 4.x
 
+# Cancel an in-progress run when the same PR gets a new push; only the commit messages
+# as they stand after the latest push are worth linting.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   commit-lint:
     name: Verify Conventional Commits

data/.github/workflows/warm_bundler_caches.yml

@@ -0,0 +1,82 @@
+name: Warm Bundler Caches
+
+# GitHub Actions scopes every cache to the ref that wrote it, and only caches
+# written at *default-branch* scope are readable from other refs. The CI workflow runs
+# on `pull_request`, where github.ref is refs/pull/<n>/merge, so the caches it writes
+# are visible to that one PR and nothing else. The result is that nearly every PR paid
+# a cold `bundle install` on nearly every job. See issue #1674 for the measurements.
+#
+# This workflow exists solely to write those caches from refs/heads/main so that a
+# PR's *first* run can read them. It does no checkout-and-test work beyond what
+# `bundler-cache: true` needs: no specs, no RuboCop, no YARD.
+#
+# The matrix below must stay in sync with continuous_integration.yml: setup-ruby's
+# cache key embeds the runner OS, the resolved Ruby version, and the Gemfile.lock hash,
+# so a pair that is not warmed here still starts cold in CI. That includes the lint
+# job's Ruby 3.4 and the Windows 3.2 job, neither of which appears in CI's main matrix
+# list. The head rubies from experimental_continuous_integration.yml are deliberately
+# absent: that workflow already runs on `push: [main]` and warms its own caches.
+#
+# Only `main` is listed below. A run's readable caches are its own ref, its base ref,
+# and the default branch, so warming 4.x would need this file backported to the 4.x
+# branch with that branch's own matrix -- the copy on main is never what runs for a
+# push to 4.x.
+on:
+  push:
+    branches: [main]
+
+  workflow_dispatch:
+
+# Deliberately NOT cancel-in-progress. Two merges landing close together would
+# otherwise cancel the first one's warming mid-save, which is the opposite of the
+# point; queueing them costs a couple of runner-minutes and always leaves a warm cache
+# behind. This group is also distinct from CI's because github.workflow differs.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+jobs:
+  warm:
+    name: Warm Ruby ${{ matrix.ruby }} on ${{ matrix.operating-system }}
+
+    runs-on: ${{ matrix.operating-system }}
+    timeout-minutes: 15
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - ruby: "3.2"
+            operating-system: ubuntu-latest
+
+          - # Hosts the lint and locale jobs in continuous_integration.yml
+            ruby: "3.4"
+            operating-system: ubuntu-latest
+
+          - ruby: "4.0"
+            operating-system: ubuntu-latest
+
+          - ruby: "truffleruby-24.2.1"
+            operating-system: ubuntu-latest
+
+          - ruby: "jruby-10.0.0.1"
+            operating-system: ubuntu-latest
+
+          - ruby: "3.2"
+            operating-system: windows-latest
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v6
+
+      # No bundler-* inputs here on purpose. setup-ruby folds its `bundler`, `with`,
+      # `without`, and `only` inputs into the cache key, so any option set here and not
+      # in continuous_integration.yml would warm a key CI never looks up.
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "5.0.4"
+  ".": "5.1.0"
 }

data/.rubocop.yml

@@ -26,7 +26,19 @@ Layout/LineLength:
 Style/OneClassPerFile:
   Enabled: false
 
+# The repository is stored with LF line endings, but this cop defaults to `native`,
+# which expects CRLF on Windows and so reports every file in the project as an
+# offense there. Pinning it to `lf` makes the lint verdict identical on every
+# platform, which is the same reason CI runs RuboCop on one runtime only.
+Layout/EndOfLine:
+  EnforcedStyle: lf
+
 AllCops:
-  # Pin this project to Ruby 3.1 in case the shared config above is upgraded to 3.2
-  # or later.
+  # Must match the floor of required_ruby_version in the gemspec: TargetRubyVersion
+  # decides which syntax RuboCop permits and suggests, so a value above the floor
+  # would let in code that does not parse on the oldest supported Ruby.
+  #
+  # Pinned explicitly rather than inferred because main_branch_shared_rubocop_config
+  # sets 3.1, which is older than this gem supports, and a value inherited through
+  # inherit_gem takes precedence over inference from the gemspec.
   TargetRubyVersion: 3.2

data/CHANGELOG.md

@@ -5,6 +5,50 @@
 
 # Change Log
 
+## [5.1.0](https://github.com/ruby-git/ruby-git/compare/v5.0.5...v5.1.0) (2026-08-18)
+
+
+### Features
+
+* **grep:** Expose perl_regexp on the Git::Repository#grep facade ([759436f](https://github.com/ruby-git/ruby-git/commit/759436f7b59ac5028e38a2158a9a354720640415))
+* **log:** Expose perl_regexp on the log path ([df8ea33](https://github.com/ruby-git/ruby-git/commit/df8ea33bb7d019d1a52fbb99370d9ffd67bf279f))
+
+
+### Other Changes
+
+* Add fiddle as a Windows development dependency ([1847989](https://github.com/ruby-git/ruby-git/commit/18479892529bd1f992596cbc055a9a42be326680))
+* Bound the locale job's apt step so a stalled mirror fails fast ([3a5d83b](https://github.com/ruby-git/ruby-git/commit/3a5d83b7685091a4abbde2c84c0136214fa66e5d))
+* Cover the perl_regexp escape hatch for non-ASCII regex matching ([55e2ded](https://github.com/ruby-git/ruby-git/commit/55e2ded4563a39a0389dbbd52f8425da9a1e3aea))
+* Document the Git for Windows byte-matching regex limitation ([9aaedbd](https://github.com/ruby-git/ruby-git/commit/9aaedbd94488bcfeef05cc56dfce61ce69f529fc))
+* Document the windows symlink privilege requirement ([696dff3](https://github.com/ruby-git/ruby-git/commit/696dff3cbf09647bbfa51279f7e35fc8a85eaab4))
+* Express development dependency conditions as named predicates ([acca20a](https://github.com/ruby-git/ruby-git/commit/acca20a43a6fb79f6b36de900ac8aa8c2488d87f))
+* Fix a broken section link in the pre-review checklist ([719f595](https://github.com/ruby-git/ruby-git/commit/719f595af69c1afcf6b025d1a2bb920963738f80))
+* Make integration fixtures independent of git and platform settings ([c2a1592](https://github.com/ruby-git/ruby-git/commit/c2a159287ec007793c125929029303707669c8ad))
+* Pin rubocop to lf line endings ([7f40413](https://github.com/ruby-git/ruby-git/commit/7f40413c3eded1af7a3dede02e1d94d7dc9c829b))
+* Pin test repository config from a single source ([6e227b7](https://github.com/ruby-git/ruby-git/commit/6e227b70f59f4bbaf2bbc1d30a4b1b86ffbe6afc))
+* Scope the symlink rescue to the symlink call ([c2bed8f](https://github.com/ruby-git/ruby-git/commit/c2bed8fefdd8bdf2efa84432c318b2b39ba223d2))
+* Skip the symlink specs when the host cannot create symlinks ([8e9b667](https://github.com/ruby-git/ruby-git/commit/8e9b667daeb6a179a02df7c946a495c7b7e6fce5))
+
+## [5.0.5](https://github.com/ruby-git/ruby-git/compare/v5.0.4...v5.0.5) (2026-08-09)
+
+
+### Bug Fixes
+
+* Detect Darwin under JRuby when pinning LC_ALL ([89bf625](https://github.com/ruby-git/ruby-git/commit/89bf62579999bec27a9b0f1aab16d37e7d5af2b8)), closes [#1669](https://github.com/ruby-git/ruby-git/issues/1669)
+* Pin LC_ALL to a locale that exists on the host platform ([5a4e0d6](https://github.com/ruby-git/ruby-git/commit/5a4e0d657b0e0828de0b38f283ae60dfbe2d4cc6)), closes [#1669](https://github.com/ruby-git/ruby-git/issues/1669)
+
+
+### Other Changes
+
+* Correct two imprecise claims in the build-complete comment ([c4391cd](https://github.com/ruby-git/ruby-git/commit/c4391cdf441a8379dee4cda59f800da41bf8e8b2)), closes [#1675](https://github.com/ruby-git/ruby-git/issues/1675)
+* Gate merges on a matrix-free job instead of the per-matrix checks ([47f2d17](https://github.com/ruby-git/ruby-git/commit/47f2d17d16d1ea201bf9cc8f74aedffa7619eb0a)), closes [#1675](https://github.com/ruby-git/ruby-git/issues/1675)
+* Remove vestigial matrix dimensions ([3a89886](https://github.com/ruby-git/ruby-git/commit/3a8988650a7d8f0a81c093c470fb9f524142c9b9)), closes [#1676](https://github.com/ruby-git/ruby-git/issues/1676)
+* Run RuboCop and YARD once instead of on every matrix job ([0726964](https://github.com/ruby-git/ruby-git/commit/072696491662867cfbc0424febcf36542548f051))
+* Run the suite once with en_US.UTF-8 unavailable ([6e012c5](https://github.com/ruby-git/ruby-git/commit/6e012c54d52c8b0c25bf629f07e310b6fcbac229)), closes [#1669](https://github.com/ruby-git/ruby-git/issues/1669)
+* Run the test suite under a non-English locale ([c65d402](https://github.com/ruby-git/ruby-git/commit/c65d4022f358a4e4e676dbf2492427851205cdd6)), closes [#1670](https://github.com/ruby-git/ruby-git/issues/1670)
+* Skip the All Specs Passed gate on release PRs ([6dfeee0](https://github.com/ruby-git/ruby-git/commit/6dfeee0ed508932393106c8887d9b7c9ef9dbbca)), closes [#1675](https://github.com/ruby-git/ruby-git/issues/1675)
+* Warm bundler caches at default-branch scope on push to main ([2821477](https://github.com/ruby-git/ruby-git/commit/282147796f6b859fb9c7f8b5a614cab399cc9539)), closes [#1674](https://github.com/ruby-git/ruby-git/issues/1674)
+
 ## [5.0.4](https://github.com/ruby-git/ruby-git/compare/v5.0.3...v5.0.4) (2026-08-07)
 
 

data/CONTRIBUTING.md

@@ -10,6 +10,7 @@
 - [How to report an issue or request a feature](#how-to-report-an-issue-or-request-a-feature)
 - [Local development setup](#local-development-setup)
   - [Prerequisites](#prerequisites)
+    - [A note for Windows contributors](#a-note-for-windows-contributors)
   - [Bootstrap the project](#bootstrap-the-project)
   - [Verify the toolchain](#verify-the-toolchain)
   - [Contributor validation policy](#contributor-validation-policy)
@@ -97,6 +98,18 @@ prerequisite is missing.
 | git | `>= 2.28.0` (matches `git.gemspec` `requirements`) | Older git versions are not supported and the test suite will not pass against them. |
 | Node.js / npm | Optional | Required only to install the local Conventional Commit `commit-msg` hook (Husky + commitlint). If npm is missing, `bin/setup` will warn and continue — CI will still validate commit messages. |
 
+#### A note for Windows contributors
+
+A few unit specs create real symlinks, which on Windows requires
+`SeCreateSymbolicLinkPrivilege`. A non-elevated process only holds that privilege
+when Developer Mode is enabled (Settings → System → For developers). Without it
+those specs skip rather than fail, so `bundle exec rake` still passes — but the
+behavior they cover goes unverified locally.
+
+The same privilege decides whether Git for Windows materializes the committed
+`.claude/skills` symlink, so enabling Developer Mode fixes both at once. See
+[Agent configuration](#agent-configuration).
+
 ### Bootstrap the project
 
 From the project root, run:
@@ -181,7 +194,7 @@ Before moving a pull request out of draft or requesting a review, confirm:
 - [ ] `bundle exec rake` passes locally on your branch (see
   [Local development setup](#local-development-setup)).
 - [ ] New or changed code has accompanying tests under `spec/`
-  (see [Unit tests](#unit-tests)).
+  (see [Unit tests vs Integration tests](#unit-tests-vs-integration-tests)).
 - [ ] Every commit message follows [Conventional Commits](#commit-message-guidelines).
 - [ ] User-facing changes are documented in `README.md` and/or YARD as appropriate.
 
@@ -301,7 +314,7 @@ The `git` gem is organized into three architectural layers:
 | --- | --- | --- |
 | **Facade** (`Git::Repository` and `Git`) | Public API | Normalizes Ruby arguments, sets safe defaults, calls one or more `Git::Commands::*` classes, and may parse output into public Ruby objects |
 | **Command** (`Git::Commands::*`) | Neutral git CLI interface | Declares CLI arguments via the [Arguments DSL](lib/git/commands/arguments.rb), builds the git argv and executes git via `#call`, and returns `Git::CommandLine::Result` |
-| **Execution** (`Git::ExecutionContext::*`) | Execution context and subprocess defaults | Carries execution settings such as working directory, environment, timeout, binary path, and logging; runs the git CLI with default global options (such as `-c color.ui=false`) and subprocess environment variables (such as `LC_ALL=en_US.UTF-8`) |
+| **Execution** (`Git::ExecutionContext::*`) | Execution context and subprocess defaults | Carries execution settings such as working directory, environment, timeout, binary path, and logging; runs the git CLI with default global options (such as `-c color.ui=false`) and subprocess environment variables (such as a platform-conditional `LC_ALL` — `en_US.UTF-8` on macOS, `C.UTF-8` elsewhere) |
 
 Command classes (`Git::Commands::*`) are **faithful, neutral representations of the
 git CLI**. Each command class does the following:
@@ -967,9 +980,21 @@ below either threshold.
 
 This is enforceable without being onerous because unit coverage in this project is
 deterministic: `lib/` has no Ruby-version, Ruby-engine, or platform conditionals, and
-no unit spec is conditionally skipped. Every supported MRI runtime measures exactly
-the same lines and branches, so a coverage failure is always something the pull
-request introduced.
+the handful of unit specs that are conditionally skipped are redundant for coverage —
+every `lib/` line and branch they reach is also reached by a spec that always runs.
+Every supported MRI runtime therefore measures exactly the same lines and branches, so
+a coverage failure is always something the pull request introduced.
+
+A new conditional skip in `spec/unit/` must preserve that property. Verify it on a
+host where the guard actually skips: run the full unit suite there and confirm it
+still reports 100% line and branch coverage. A conditionally skipped unit spec that
+is the only thing covering a line would turn this gate into a platform-dependent
+failure, which is exactly what the policy exists to prevent.
+
+Write the guard the same way the rest of the suite does: a reusable predicate in
+`spec/spec_helper.rb` (`unless_git`, `unless_command`, `unless_pcre`,
+`unless_ci_build`) used as `skip:` metadata, or — for a one-off capability that the
+`before` block is already exercising — a `rescue` in that block that calls `skip`.
 
 What the policy does and does not cover:
 

data/README.md

@@ -30,6 +30,8 @@ Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-%23FE5196?log
 - [Errors Raised by This Gem](#errors-raised-by-this-gem)
 - [Specifying and Handling Timeouts](#specifying-and-handling-timeouts)
 - [Deprecations](#deprecations)
+- [Platform Limitations](#platform-limitations)
+  - [Regex Metacharacters on Git for Windows](#regex-metacharacters-on-git-for-windows)
 - [Project Policies](#project-policies)
   - [Ruby Version Support Policy](#ruby-version-support-policy)
   - [Git Version Support Policy](#git-version-support-policy)
@@ -302,6 +304,71 @@ needed for the upgrade.
 For the full list of deprecated methods and their replacements, see
 [UPGRADING.md](UPGRADING.md).
 
+## Platform Limitations
+
+### Regex Metacharacters on Git for Windows
+
+On Git for Windows, git's regex engine matches **bytes** rather than characters. A
+metacharacter such as `.`, or a POSIX character class such as `[[:alpha:]]`, therefore
+never matches a whole multi-byte character. The same call matches on Linux and macOS.
+
+The failure is silent — nothing raises, and the result is indistinguishable from a
+pattern that genuinely does not occur:
+
+```ruby
+# File content, commit message, and config value are all 'ÄPFEL sind gut'.
+# 'Ä' is two bytes in UTF-8 (C3 84), so '.' has to match both to match the character.
+
+repo.grep('^.PFEL')                              # => {} on Windows, matches elsewhere
+repo.log.grep('^.PFEL').execute.size             # =>  0 on Windows, 1 elsewhere
+repo.config_get_all('test.desc', '^.PFEL')       # => [] on Windows, matches elsewhere
+```
+
+This is a property of the regex engine git bundles on that platform, not something the
+gem sets. It is unaffected by the locale: the behavior is identical under `en_US.UTF-8`,
+`C.UTF-8`, `C`, and with no `LC_ALL` set at all. Literal (metacharacter-free) patterns
+and case-insensitive matching are unaffected on every platform.
+
+**Workaround.** Perl-compatible regular expressions do match characters on Git for
+Windows, so the surfaces that can reach a PCRE engine accept an opt-in selector:
+
+```ruby
+repo.grep('^.PFEL', nil, perl_regexp: true)      # matches on every platform
+repo.log.perl_regexp.grep('^.PFEL').execute      # matches on every platform
+repo.full_log_commits(grep: '^.PFEL', perl_regexp: true)
+```
+
+Two caveats:
+
+- **PCRE is a different dialect** than git's default POSIX basic/extended regular
+  expressions. Selecting it is a deliberate choice by the caller, so the gem does not
+  substitute it automatically based on the host.
+- **PCRE must be compiled in.** Git for Windows and the mainstream Linux and macOS
+  packages ship it, but git built without `USE_LIBPCRE` fails with `cannot use
+  Perl-compatible regexes...`.
+
+**There is no workaround for `git config` value patterns.** They are POSIX extended
+regular expressions with no PCRE mode, so `config_get`, `config_get_all`,
+`config_get_regexp`, `config_replace_all`, `config_unset`, and `config_unset_all` cannot
+match a metacharacter against a non-ASCII character on Git for Windows. Match on ASCII
+text or an exact value instead.
+
+`config_replace_all` deserves particular care, because there the failure is not merely an
+empty result. When the value pattern selects nothing, `git config --replace-all` *adds*
+the new value as an additional entry rather than replacing one, and exits zero:
+
+```ruby
+# Existing value of test.desc is 'ÄPFEL sind gut'
+repo.config_replace_all('test.desc', 'NEW', '^.PFEL')
+
+repo.config_get_all('test.desc').map(&:value)
+# => ["NEW"]                     elsewhere — replaced, as intended
+# => ["ÄPFEL sind gut", "NEW"]   on Windows — original kept, duplicate added
+```
+
+So a replace can silently leave the original value in place and add a second entry beside
+it. Confirm with `config_get_all` when the key must end up single-valued.
+
 ## Project Policies
 
 These documents set expectations for behavior, contribution workflows, AI-assisted

data/git.gemspec

@@ -46,31 +46,59 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'process_executer', '~> 4.0'
   spec.add_dependency 'rchardet', '~> 1.9'
 
+  # Not every development dependency is installed on every runtime. Each predicate
+  # below names one reason for holding a gem back, which keeps the dependency list
+  # itself a flat, readable list. Deriving one predicate from another also keeps
+  # coupled gems from drifting apart when a condition changes.
+  #
+  # These are local variables rather than methods deliberately. The Gemfile uses
+  # `gemspec`, so Bundler evaluates this file on every `bundle exec`, and a top-level
+  # `def` -- including one written inside this block, since a block is not a definition
+  # scope -- would define a private method on Object in every one of those processes.
+
+  # JRuby (which reports RUBY_PLATFORM as 'java') and TruffleRuby build no C extensions
+  # and do not run the docs build.
+  mri = !(RUBY_PLATFORM == 'java' || RUBY_ENGINE == 'truffleruby')
+
+  # irb stopped being a default gem in Ruby 3.4. JRuby and TruffleRuby ship their own.
+  install_irb = mri
+
+  # Ruby 4.0.0 dropped fiddle from the default gems. On Windows, irb loads
+  # reline/io/windows.rb, which requires fiddle/import for the Win32 console API, so
+  # bin/console cannot start without it; every other platform takes reline's ANSI IO
+  # gate and never loads that file. Derived from install_irb because fiddle exists only
+  # to serve irb and, being a C extension, could not install where irb is not.
+  install_fiddle = install_irb && Gem.win_platform?
+
+  # The docs toolchain is supported on MRI only. redcarpet, YARD's Markdown renderer,
+  # is also a C extension and so could not install on JRuby regardless.
+  install_docs = mri
+
+  # yard-lint requires Ruby >= 3.3.
+  install_yard_lint = install_docs && Gem.ruby_version >= Gem::Version.new('3.3.0')
+
+  # i18n 1.15+ uses Fiber.[] (Ruby 3.2 Fiber storage), which TruffleRuby < 34.0.0 does
+  # not implement, so those runtimes hold at the last release that works there.
+  pin_old_i18n = RUBY_ENGINE == 'truffleruby' &&
+                 Gem::Version.new(RUBY_ENGINE_VERSION) < Gem::Version.new('34.0.0')
+
   spec.add_development_dependency 'create_github_release', '~> 2.1'
+  spec.add_development_dependency 'fiddle', '~> 1.1' if install_fiddle
   spec.add_development_dependency 'fuubar', '~> 2.5'
+  spec.add_development_dependency 'i18n', '< 1.15' if pin_old_i18n
+  spec.add_development_dependency 'irb', '~> 1.16' if install_irb
   spec.add_development_dependency 'main_branch_shared_rubocop_config', '~> 0.1'
   spec.add_development_dependency 'parallel_tests', '~> 5.6'
   spec.add_development_dependency 'rake', '~> 13.3'
+  spec.add_development_dependency 'redcarpet', '~> 3.6' if install_docs
   spec.add_development_dependency 'rspec', '~> 3.13'
   spec.add_development_dependency 'rubocop', '~> 1.82'
   spec.add_development_dependency 'simplecov', '~> 1.0'
   spec.add_development_dependency 'simplecov-lcov', '~> 0.9'
   spec.add_development_dependency 'simplecov-rspec', '~> 1.1'
-
-  if RUBY_ENGINE == 'truffleruby' && Gem::Version.new(RUBY_ENGINE_VERSION) < Gem::Version.new('34.0.0')
-    # i18n 1.15+ uses Fiber.[] (Ruby 3.2 Fiber storage) which TruffleRuby < 34.0.0 does not implement
-    spec.add_development_dependency 'i18n', '< 1.15'
-  end
-
-  unless RUBY_PLATFORM == 'java' || RUBY_ENGINE == 'truffleruby'
-    spec.add_development_dependency 'irb', '~> 1.16'
-    spec.add_development_dependency 'redcarpet', '~> 3.6'
-    spec.add_development_dependency 'yard', '~> 0.9', '>= 0.9.28'
-    spec.add_development_dependency 'yard_example_test', '~> 0.2', '>= 0.2.1'
-
-    # yard-lint requires Ruby >= 3.3, so it is only installed on Ruby 3.3+.
-    spec.add_development_dependency 'yard-lint', '~> 1.8' if Gem.ruby_version >= Gem::Version.new('3.3.0')
-  end
+  spec.add_development_dependency 'yard', '~> 0.9', '>= 0.9.28' if install_docs
+  spec.add_development_dependency 'yard_example_test', '~> 0.2', '>= 0.2.1' if install_docs
+  spec.add_development_dependency 'yard-lint', '~> 1.8' if install_yard_lint
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/lib/git/configuring.rb

@@ -88,6 +88,14 @@ module Git
     #
     # @raise [Git::FailedError] if git exits with an unexpected non-zero status
     #
+    # @note On Git for Windows, git's default regex engine matches *bytes* rather than
+    #   characters, so a metacharacter such as `.` or a POSIX class such as
+    #   `[[:alpha:]]` in `value_regex` never matches a whole multi-byte character. The
+    #   failure is silent: nothing raises, and the outcome is indistinguishable from a
+    #   `value_regex` that genuinely matches nothing. `git config` value patterns are
+    #   POSIX extended regular expressions with no PCRE mode, so unlike
+    #   {Git::Repository#grep} there is no alternate regex engine to select here.
+    #
     def config_get(name, value_regex = nil, **options)
       Private.assert_valid_opts!(CONFIG_GET_ALLOWED_OPTS, **options)
       assert_valid_scope!(**options)
@@ -139,6 +147,14 @@ module Git
     #
     # @raise [Git::FailedError] if git exits with an unexpected non-zero status
     #
+    # @note On Git for Windows, git's default regex engine matches *bytes* rather than
+    #   characters, so a metacharacter such as `.` or a POSIX class such as
+    #   `[[:alpha:]]` in `value_regex` never matches a whole multi-byte character. The
+    #   failure is silent: nothing raises, and the outcome is indistinguishable from a
+    #   `value_regex` that genuinely matches nothing. `git config` value patterns are
+    #   POSIX extended regular expressions with no PCRE mode, so unlike
+    #   {Git::Repository#grep} there is no alternate regex engine to select here.
+    #
     def config_get_all(name, value_regex = nil, **options)
       Private.assert_valid_opts!(CONFIG_GET_ALL_ALLOWED_OPTS, **options)
       assert_valid_scope!(**options)
@@ -238,6 +254,14 @@ module Git
     #
     # @raise [Git::FailedError] if git exits with an unexpected non-zero status
     #
+    # @note On Git for Windows, git's default regex engine matches *bytes* rather than
+    #   characters, so a metacharacter such as `.` or a POSIX class such as
+    #   `[[:alpha:]]` in `value_regex` never matches a whole multi-byte character. The
+    #   failure is silent: nothing raises, and the outcome is indistinguishable from a
+    #   `value_regex` that genuinely matches nothing. `git config` value patterns are
+    #   POSIX extended regular expressions with no PCRE mode, so unlike
+    #   {Git::Repository#grep} there is no alternate regex engine to select here.
+    #
     def config_get_regexp(name_regex, value_regex = nil, **options)
       Private.assert_valid_opts!(CONFIG_GET_REGEXP_ALLOWED_OPTS, **options)
       assert_valid_scope!(**options)
@@ -529,6 +553,22 @@ module Git
     #
     #   @raise [Git::FailedError] if git exits with a non-zero exit status
     #
+    # @note On Git for Windows, git's default regex engine matches *bytes* rather than
+    #   characters, so a metacharacter such as `.` or a POSIX class such as
+    #   `[[:alpha:]]` in `value_regex` never matches a whole multi-byte character. The
+    #   failure is silent: nothing raises, and the outcome is indistinguishable from a
+    #   `value_regex` that genuinely matches nothing. `git config` value patterns are
+    #   POSIX extended regular expressions with no PCRE mode, so unlike
+    #   {Git::Repository#grep} there is no alternate regex engine to select here.
+    #
+    # @note A `value_regex` that selects nothing does not make this method a no-op.
+    #   `git config --replace-all` *adds* `value` as an additional entry when no
+    #   existing value matches, and exits zero. On Git for Windows, a `value_regex`
+    #   whose metacharacters span non-ASCII text therefore leaves the value it was
+    #   meant to replace in place and silently creates a duplicate entry beside it.
+    #   Confirm the result with {#config_get_all}, or match on ASCII text, when the
+    #   key must end up single-valued.
+    #
     def config_replace_all(name, value, value_regex = nil, **)
       Private.assert_valid_opts!(CONFIG_REPLACE_ALL_ALLOWED_OPTS, **)
       assert_valid_scope!(**)
@@ -621,6 +661,14 @@ module Git
     #
     #   @raise [Git::FailedError] if git exits with a non-zero exit status
     #
+    # @note On Git for Windows, git's default regex engine matches *bytes* rather than
+    #   characters, so a metacharacter such as `.` or a POSIX class such as
+    #   `[[:alpha:]]` in `value_regex` never matches a whole multi-byte character. The
+    #   failure is silent: nothing raises, and the outcome is indistinguishable from a
+    #   `value_regex` that genuinely matches nothing. `git config` value patterns are
+    #   POSIX extended regular expressions with no PCRE mode, so unlike
+    #   {Git::Repository#grep} there is no alternate regex engine to select here.
+    #
     def config_unset(name, value_regex = nil, **)
       Private.assert_valid_opts!(CONFIG_UNSET_ALLOWED_OPTS, **)
       assert_valid_scope!(**)
@@ -666,6 +714,14 @@ module Git
     #
     #   @raise [Git::FailedError] if git exits with a non-zero exit status
     #
+    # @note On Git for Windows, git's default regex engine matches *bytes* rather than
+    #   characters, so a metacharacter such as `.` or a POSIX class such as
+    #   `[[:alpha:]]` in `value_regex` never matches a whole multi-byte character. The
+    #   failure is silent: nothing raises, and the outcome is indistinguishable from a
+    #   `value_regex` that genuinely matches nothing. `git config` value patterns are
+    #   POSIX extended regular expressions with no PCRE mode, so unlike
+    #   {Git::Repository#grep} there is no alternate regex engine to select here.
+    #
     def config_unset_all(name, value_regex = nil, **)
       Private.assert_valid_opts!(CONFIG_UNSET_ALL_ALLOWED_OPTS, **)
       assert_valid_scope!(**)

data/lib/git/execution_context.rb

@@ -453,12 +453,68 @@ module Git
         'GIT_INDEX_FILE' => git_index_file,
         'GIT_SSH' => git_ssh,
         'GIT_EDITOR' => 'true',
-        'LC_ALL' => 'en_US.UTF-8'
+        # Pin the locale so git's behavior does not depend on the user's environment.
+        # Added for issue #753, where a German user's `git branch` output
+        # ("* (HEAD losgelöst bei origin/25.1)") broke branch parsing.
+        #
+        # The pin has two halves, and the load-bearing one is not the obvious one:
+        #
+        # - Messages: keeps git's human-readable text in English. This is now only
+        #   defense-in-depth — lib/ reads `--format=%(refname:short)` rather than
+        #   git's prose, and matches no English git message.
+        # - Ctype: makes git's regex engine match *characters* rather than *bytes*.
+        #   This is the half that matters. Under a C ctype, `grep`, `log`, and the
+        #   `config` value regexes silently return wrong answers — with exit status
+        #   zero — for any pattern whose metacharacters span non-ASCII text.
+        #
+        # So do not "simplify" this to `C`: that yields English messages and a broken
+        # ctype, which is the worst of both. A pinned locale the host does not have
+        # degrades to that same C ctype, which is why each branch below has to name a
+        # locale that actually exists on the platform it applies to:
+        #
+        # - Non-Darwin: `C.UTF-8`. Stock Debian, Ubuntu, and RHEL images generate no
+        #   `en_US.UTF-8`, so pinning it there produced exactly the silent breakage
+        #   above. (musl ignores the locale name for ctype, so Alpine is UTF-8 either
+        #   way.)
+        # - Darwin: `en_US.UTF-8`, which every macOS release ships. `C.UTF-8` did not
+        #   arrive until macOS 15, so macOS 11–14 — including Intel Macs that are
+        #   hardware-capped below 15 — would break under it. Delete this branch once
+        #   macOS 14 and earlier are out of support.
+        #
+        # Windows takes the non-Darwin branch, where the value makes no difference:
+        # Git for Windows folds case and runs PCRE in UTF mode under every value, and
+        # matches bytes for `.` and POSIX classes under every value — measured on git
+        # 2.55.0 against `en_US.UTF-8`, `C.UTF-8`, `C`, and no pin at all.
+        #
+        # RHEL 7 (glibc 2.17) has neither locale and gets a C ctype whatever is pinned.
+        # It is EOL, and there is deliberately no public override for this value.
+        'LC_ALL' => darwin_platform? ? 'en_US.UTF-8' : 'C.UTF-8'
       }.merge(additional_overrides)
     end
 
     private
 
+    # Whether this process is running on macOS
+    #
+    # Checks `RUBY_DESCRIPTION` as well as `RUBY_PLATFORM` because JRuby reports
+    # `RUBY_PLATFORM` as `"java"` on every host and records the real platform only in
+    # `RUBY_DESCRIPTION` (as, for example, `"... [arm64-darwin]"`). Testing
+    # `RUBY_PLATFORM` alone would put JRuby on macOS onto the non-Darwin branch of the
+    # `LC_ALL` pin, which is the one platform pairing that branch must never be given —
+    # see {#env_overrides}.
+    #
+    # Test the platform plainly rather than sniffing the Darwin version: `RUBY_PLATFORM`
+    # records the version Ruby was *built* against, so a Ruby built on macOS 14 still
+    # reports `darwin23` when run on macOS 15.
+    #
+    # @return [Boolean] true if this process is running on macOS
+    #
+    # @api private
+    #
+    def darwin_platform?
+      RUBY_PLATFORM.include?('darwin') || RUBY_DESCRIPTION.include?('darwin')
+    end
+
     # Returns the Array of git global option strings for this context
     #
     # Prepends `--git-dir` and `--work-tree` when the corresponding attributes

data/lib/git/log.rb

@@ -142,6 +142,25 @@ module Git
     #
     def grep(regex)         = set_option(:grep, regex)
 
+    # Interprets {#grep} and {#author} patterns as Perl-compatible regular expressions
+    #
+    # Selects PCRE instead of git's default POSIX basic regular expressions for
+    # every pattern in the query. Requires a git built with PCRE support.
+    #
+    # @example Match a metacharacter against a non-ASCII character on Git for Windows
+    #   repo.log.perl_regexp.grep('^.PFEL').execute
+    #
+    # @return [Git::Log] the current query builder
+    #
+    # @note On Git for Windows, git's default regex engine matches *bytes* rather
+    #   than characters, so a metacharacter such as `.` or a POSIX class such as
+    #   `[[:alpha:]]` never matches a whole multi-byte character. The match fails
+    #   silently: git exits zero and the result is empty. PCRE does match characters
+    #   on that platform, but it is a different dialect than git's default, so
+    #   selecting it is a deliberate choice by the caller.
+    #
+    def perl_regexp         = set_option(:perl_regexp, true)
+
     # Limits commits to those that touch the given path or paths
     #
     # @param path [String, Pathname, Array<String, Pathname>] path limiter input

data/lib/git/repository/logging.rb

@@ -18,7 +18,7 @@ module Git
       # @return [Array<Symbol>] the supported option keys
       #
       FULL_LOG_COMMITS_ALLOWED_OPTS = %i[
-        count all cherry since until grep author between object path_limiter skip merges
+        count all cherry since until grep author between object path_limiter skip merges perl_regexp
       ].freeze
       private_constant :FULL_LOG_COMMITS_ALLOWED_OPTS
 
@@ -68,6 +68,13 @@ module Git
       #
       # @option opts [Boolean, nil] :merges (nil) include only merge commits
       #
+      # @option opts [Boolean, nil] :perl_regexp (nil) interpret the `:grep` and
+      #   `:author` patterns as Perl-compatible regular expressions (PCRE) instead of
+      #   git's default POSIX basic regular expressions
+      #
+      #   Requires a git built with PCRE support; git otherwise fails with
+      #   "cannot use Perl-compatible regexes...".
+      #
       # @return [Array<Hash>] the parsed raw log output for each commit
       #
       # @raise [ArgumentError] if unsupported options are provided
@@ -76,6 +83,14 @@ module Git
       #
       # @raise [Git::FailedError] if git exits with a non-zero exit status
       #
+      # @note On Git for Windows, git's default regex engine matches *bytes* rather
+      #   than characters, so a metacharacter such as `.` or a POSIX class such as
+      #   `[[:alpha:]]` never matches a whole multi-byte character in a `:grep` or
+      #   `:author` pattern. The match fails silently: git exits zero and the result
+      #   is empty. Pass `perl_regexp: true` to select PCRE, which does match
+      #   characters. PCRE is a different dialect than git's default, so this is a
+      #   deliberate choice by the caller rather than a transparent substitution.
+      #
       # @see https://git-scm.com/docs/git-log git-log
       #
       def full_log_commits(opts = {})
@@ -113,6 +128,14 @@ module Git
       module Private
         module_function
 
+        # Log option keys forwarded to {Git::Commands::Log#call} under the same name
+        #
+        # The remaining options are renamed or reshaped by {#log_base_call_options}.
+        #
+        # @return [Array<Symbol>] the pass-through option keys
+        #
+        PASSTHROUGH_LOG_OPTS = %i[all cherry since until grep author perl_regexp].freeze
+
         # Validates the :count log option
         #
         # @param opts [Hash] the log options
@@ -195,6 +218,9 @@ module Git
         # @option opts [String, nil] :author (nil) only include commits whose author
         #   matches this pattern
         #
+        # @option opts [Boolean, nil] :perl_regexp (nil) interpret the `:grep` and
+        #   `:author` patterns as Perl-compatible regular expressions
+        #
         # @option opts [Integer, nil] :count (nil) maximum number of commits to return
         #
         # @option opts [String, Pathname, Array<String, Pathname>, nil] :path_limiter (nil)
@@ -207,16 +233,14 @@ module Git
         # @return [Hash] keyword options for {Git::Commands::Log#call}
         #
         def log_base_call_options(opts, extra = {})
-          {
-            all: opts[:all],
-            cherry: opts[:cherry],
-            since: opts[:since],
-            until: opts[:until],
-            grep: opts[:grep],
-            author: opts[:author],
-            max_count: opts[:count],
-            path: opts[:path_limiter] ? Array(opts[:path_limiter]) : nil
-          }.merge(extra).compact
+          opts
+            .slice(*PASSTHROUGH_LOG_OPTS)
+            .merge(
+              max_count: opts[:count],
+              path: opts[:path_limiter] ? Array(opts[:path_limiter]) : nil
+            )
+            .merge(extra)
+            .compact
         end
 
         # Executes git log and parses the raw output

data/lib/git/repository/object_operations.rb

@@ -454,7 +454,7 @@ module Git
       end
 
       # Option keys accepted by {#grep}
-      GREP_ALLOWED_OPTS = %i[ignore_case i invert_match v extended_regexp E object].freeze
+      GREP_ALLOWED_OPTS = %i[ignore_case i invert_match v extended_regexp E perl_regexp P object].freeze
       private_constant :GREP_ALLOWED_OPTS
 
       # Search tracked file contents in a git tree for a pattern
@@ -475,6 +475,9 @@ module Git
       # @example Case-insensitive search
       #   repo.grep('todo', nil, ignore_case: true)
       #
+      # @example Match a metacharacter against a non-ASCII character on Git for Windows
+      #   repo.grep('^.PFEL', nil, perl_regexp: true)
+      #
       # @param pattern [String] the pattern to search for
       #
       # @param path_limiter [String, Pathname, Array<String, Pathname>, nil]
@@ -499,6 +502,14 @@ module Git
       #
       #   Alias: :E
       #
+      # @option opts [Boolean, nil] :perl_regexp (nil) use Perl-compatible regular
+      #   expressions (PCRE) for the pattern
+      #
+      #   Requires a git built with PCRE support; git otherwise fails with
+      #   "cannot use Perl-compatible regexes...".
+      #
+      #   Alias: :P
+      #
       # @return [Hash<String, Array<Array(Integer, String)>>] a hash mapping
       #   each `"treeish:filename"` key to an array of `[line_number, text]`
       #   pairs; returns an empty hash when no lines match
@@ -508,6 +519,16 @@ module Git
       # @raise [Git::FailedError] if git exits with a non-zero status and
       #   stderr is non-empty (e.g. bad object reference)
       #
+      # @note On Git for Windows, git's default regex engine matches *bytes* rather
+      #   than characters, so a metacharacter such as `.` or a POSIX class such as
+      #   `[[:alpha:]]` never matches a whole multi-byte character. The failure is
+      #   silent: nothing raises, and the empty hash returned is indistinguishable
+      #   from a pattern that genuinely does not occur in the tree. Pass
+      #   `perl_regexp: true` to select PCRE, which does match characters. PCRE is a
+      #   different dialect than git's default POSIX basic/extended regular
+      #   expressions, so this is a deliberate choice by the caller rather than a
+      #   transparent substitution, and it requires a git built with PCRE support.
+      #
       # @see https://git-scm.com/docs/git-grep git-grep documentation
       #
       def grep(pattern, path_limiter = nil, opts = {})

data/lib/git/version.rb

@@ -4,7 +4,7 @@ module Git
   # The current gem version
   #
   # @return [String] the current gem version
-  VERSION = '5.0.4'
+  VERSION = '5.1.0'
 
   # Represents a git version with major, minor, and patch components
   #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git
 version: !ruby/object:Gem::Version
-  version: 5.0.4
+  version: 5.1.0
 platform: ruby
 authors:
 - Scott Chacon and others
@@ -93,6 +93,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: main_branch_shared_rubocop_config
   requirement: !ruby/object:Gem::Requirement
@@ -135,6 +149,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.3'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -205,34 +233,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: irb
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.16'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.16'
-- !ruby/object:Gem::Dependency
-  name: redcarpet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -347,6 +347,7 @@ files:
 - ".github/workflows/enforce_conventional_commits.yml"
 - ".github/workflows/experimental_continuous_integration.yml"
 - ".github/workflows/release.yml"
+- ".github/workflows/warm_bundler_caches.yml"
 - ".gitignore"
 - ".husky/commit-msg"
 - ".husky/pre-commit"
@@ -630,8 +631,8 @@ licenses:
 metadata:
   homepage_uri: http://github.com/ruby-git/ruby-git
   source_code_uri: http://github.com/ruby-git/ruby-git
-  changelog_uri: https://rubydoc.info/gems/git/5.0.4/file/CHANGELOG.md
-  documentation_uri: https://rubydoc.info/gems/git/5.0.4
+  changelog_uri: https://rubydoc.info/gems/git/5.1.0/file/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/git/5.1.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: