Taahhüt edilmemiş değişiklikler olup olmadığını programlı olarak nasıl belirlerim?

Makefile'de, taahhüt edilmemiş değişiklikler varsa (çalışma ağacında veya dizinde) belirli eylemleri gerçekleştirmek istiyorum. Bunu yapmanın en temiz ve verimli yolu nedir? Bir durumda sıfır, diğerinde sıfır olmayan bir dönüş değeri ile çıkan bir komut, amacım için uygun olacaktır.

Ben çalıştırabilir git statusve boru içinden çıktı grep, ancak daha iyi bir yolu olmalı gibi hissediyorum.

GÜNCELLEME : OP Daniel Stutzbach işaret yorumlarda bu basit bir komut olduğunu git diff-indexonun için çalıştı:

git update-index --refresh 
git diff-index --quiet HEAD --

( Nornagon bahseder yorumlarda içerikleri endeksinde aynıdır dokundu edilmiş dosyalar, ancak varsa, çalıştırmak gerekir git update-index --refreshönce git diff-index, aksi takdirde diff-indexyanlış ağaç kirli olduğunu bildirir)

Daha sonra bash komut dosyasında kullanıyorsanız " Bir komutun başarılı olup olmadığını nasıl kontrol edersiniz ? "

git diff-index --quiet HEAD -- || echo "untracked"; // do something about it

Not: Anthony Sottile tarafından yorumlandığı gibi

git diff-index HEAD ...taahhütleri olmayan bir dalda başarısız olur (yeni başlatılan bir depo gibi).
Bulduğum bir geçici çözümgit diff-index $(git write-tree) ...

Ve haridsvPuan yorumlarda olduğu git diff-filesbir üzerine yeni dosyanın bir fark olarak algılamaz.
Daha güvenli yaklaşım git add, önce dosya spec üzerinde çalışıyor ve daha sonra git diff-indexçalıştırmadan önce dizine bir şey eklenip eklenmediğini görmek için kullanılıyor git commit.

git add ${file_args} && \
git diff-index --cached --quiet HEAD || git commit -m '${commit_msg}'

Ve 6502 yorumlarda raporlar:

Ben çarptım bir sorun git diff-index, gerçekten zaman damgaları dışında hiçbiri olmadığında farklılıklar olduğunu söyleyecektir. Bir kez
koşmak git diffsorunu çözer (şaşırtıcı bir şekilde git diff, sanal alanın içeriğini değiştirir, yani burada .git/index)

Bu zaman damgası sorunları, git docker'da çalışıyorsa da oluşabilir .

Orijinal cevap:

"Programlı" hiçbir zaman porselen komutlarına güvenmemek anlamına gelir .
Daima tesisat komutlarına güvenin .

Alternatifler için " Git ile kirli bir dizini veya izlenmemiş dosyaları kontrol etme " konusuna da bakın (örneğin git status --porcelain)

Konuştuğumuz gibi yazılan yeni " require_clean_work_treeişlev " den ilham alabilirsiniz ;) (Ekim 2010 başı)

require_clean_work_tree () {
    # Update the index
    git update-index -q --ignore-submodules --refresh
    err=0

    # Disallow unstaged changes in the working tree
    if ! git diff-files --quiet --ignore-submodules --
    then
        echo >&2 "cannot $1: you have unstaged changes."
        git diff-files --name-status -r --ignore-submodules -- >&2
        err=1
    fi

    # Disallow uncommitted changes in the index
    if ! git diff-index --cached --quiet HEAD --ignore-submodules --
    then
        echo >&2 "cannot $1: your index contains uncommitted changes."
        git diff-index --cached --name-status -r --ignore-submodules HEAD -- >&2
        err=1
    fi

    if [ $err = 1 ]
    then
        echo >&2 "Please commit or stash them."
        exit 1
    fi
}

Diğer çözümler çok kapsamlı olsa da, gerçekten hızlı ve kirli bir şey istiyorsanız, böyle bir şey deneyin:

[[ -z $(git status -s) ]]

Sadece durum özetinde çıktı olup olmadığını kontrol eder.

git diff --exit-codeherhangi bir değişiklik varsa sıfırdan farklı bir değerle döner; git diff --quietçıktı olmadan aynıdır. Çalışma ağacını ve dizini kontrol etmek istediğiniz için şunu kullanın:

git diff --quiet && git diff --cached --quiet

Veya

git diff --quiet HEAD

Her ikisi de size aşamalı olarak kaydedilen taahhüt edilmemiş değişiklikler olup olmadığını söyleyecektir.

@ Nepthar'ın cevabına genişleyen:

if [[ -z $(git status -s) ]]
then
  echo "tree is clean"
else
  echo "tree is dirty, please commit changes before running this"
  exit
fi

Diğer cevapta belirtildiği gibi, bu komut kadar basit:

git diff-index --quiet HEAD --

Son iki tireyi atlarsanız, adlı bir dosyanız varsa komut başarısız olur HEAD.

Misal:

#!/bin/bash
set -e
echo -n "Checking if there are uncommited changes... "
trap 'echo -e "\033[0;31mFAILED\033[0m"' ERR
git diff-index --quiet HEAD --
trap - ERR
echo -e "\033[0;32mAll set!\033[0m"

# continue as planned...

Dikkat kelimesi: Bu komut izlenmeyen dosyaları yok sayar.

İşaretlenmemiş ve aşamalı dosyaları listelemek için bazı kullanışlı git takma adları oluşturdum:

git config --global alias.unstaged 'diff --name-only'
git config --global alias.staged 'diff --name-only --cached'

Sonra kolayca aşağıdakileri yapabilirsiniz:

[[ -n "$(git unstaged)" ]] && echo unstaged files || echo NO unstaged files
[[ -n "$(git staged)" ]] && echo staged files || echo NO staged files

Eğer bir komut bir yere oluşturarak daha okunaklı yapabilirsiniz PATHdenilen git-has:

#!/bin/bash
[[ $(git "$@" | wc -c) -ne 0 ]]

Şimdi yukarıdaki örnekler basitleştirilebilir:

git has unstaged && echo unstaged files || echo NO unstaged files
git has staged && echo staged files || echo NO staged files

Tamlık için burada izlenmeyen ve yok sayılan dosyalar için benzer takma adlar bulunur:

git config --global alias.untracked 'ls-files --exclude-standard --others'
git config --global alias.ignored 'ls-files --exclude-standard --others --ignored'

Python ve GitPython paketi ile:

import git
git.Repo(path).is_dirty(untracked_files=True)

Depo temiz değilse True döndürür

İşte en iyi, en temiz yol.

function git_dirty {
    text=$(git status)
    changed_text="Changes to be committed"
    untracked_files="Untracked files"

    dirty=false

    if [[ ${text} = *"$changed_text"* ]];then
        dirty=true
    fi

    if [[ ${text} = *"$untracked_files"* ]];then
        dirty=true
    fi

    echo $dirty
}