git 5.0.4 → 5.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04104dc235012494d8e6b9718421d02f040a6216aec0991bce962b17b1e61c43
-  data.tar.gz: bbfe9f44799e29f24e5baa4095d42159af56b9a8c568a51b9358d8ba3758e90f
+  metadata.gz: c7e6fda47311cb6c004daa4c42830658e97f5c95a37f325da3dee7bee64f8222
+  data.tar.gz: 7ce4dd95073b4419f883ca79fc2985352575ac909c22739be7d3c43ae4d734b8
 SHA512:
-  metadata.gz: 0cc7b0792f17d8972999f33f7412477996a6d865bcce5fb24bf27bb9add5dc0ee83f8623e1940bf88a9deebcba1b409a2f3910ee99dbf1d6d33b2eb5dc5afa86
-  data.tar.gz: 64d890f4273c6a56389bfa5ae42bce90a4aa5d8e63a1536361662bab9cc0ba88e7e317f47bc9b1dbaa0e454b8a5bb7b065bd87aec8a33e1f4367c68feb89092f
+  metadata.gz: 3e3420fd700a1440102c3a8b186841ce3cfc3c442f7f80afb9691e1a337b35e947a8ffdf668916889218c839393e5971706667f4df492a04ead0afb27ecd1925
+  data.tar.gz: d0a7ea7e2150e56bcd0da3cd4c86645b1430eb4193f8610709bd2d07394fbb320ec3d9b7b77e2eafb42324ba58740437ac5b433c2575058d7e01a72bc23998d5

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,241 @@ 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.
+      - name: Install the German locale and message catalogs
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get 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.0.5"
 }

data/.rubocop.yml

@@ -27,6 +27,11 @@ Style/OneClassPerFile:
   Enabled: false
 
 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,26 @@
 
 # Change Log
 
+## [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

@@ -301,7 +301,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:

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/version.rb

@@ -4,7 +4,7 @@ module Git
   # The current gem version
   #
   # @return [String] the current gem version
-  VERSION = '5.0.4'
+  VERSION = '5.0.5'
 
   # 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.0.5
 platform: ruby
 authors:
 - Scott Chacon and others
@@ -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.0.5/file/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/git/5.0.5
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: