Come fare in modo che la patch ignori gli hunk già applicati

Ho un file di patch molto grande che sto cercando di applicare al mio codice. Il problema è che alcune delle modifiche nella mia patch esistono già nel codice. C'è un modo per rendere la patch ignorare con garbo le modifiche che sono già state applicate?

L' -Nopzione non fa quello che voglio. Se incontra un hunk già applicato, genererà un file di rifiuto e non applicherà più hunk a quel file. Voglio che ignori quel pezzo e continui ad applicare il resto della patch. L'unica volta che voglio che generi un file .rej è se un hunk non può essere applicato e non sembra essere già applicato.

C'è un modo per fare questo?

Per questo avrai bisogno di patchutils installati.

Questo script suddivide una grande patch in cache separate più piccole, ognuna contenente solo un pezzo per un file. È quindi possibile applicare queste patch con patch --forward.

#!/bin/sh -eu

PATCH=$1
OUTDIR=$2

test -f "$PATCH" && test -d "$OUTDIR"

TDIR=$(mktemp -d)
trap 'rm -rf $TDIR' 0

INDEX=0
TEMPHUNK=$TDIR/current_hunk

lsdiff $1 | while read FNAME
do
    HUNK=1
    while :
    do
        filterdiff --annotate --hunks=$HUNK -i "$FNAME" "$PATCH" > "$TEMPHUNK"
        HUNK=$((HUNK+1))
        test -s "$TEMPHUNK" && \
            {
                mv "$TEMPHUNK" "$OUTDIR/$INDEX.diff"
                INDEX=$((INDEX+1))
            } || break
    done
done

Modifica : salva lo script in hunks.she chiamalo:

./hunks.sh path/to/big.diff path/to/output/directory

Alla fine l'ho risolto usando una soluzione simile a quella di artyom.

Passaggio 1: esplodi la patch in molte patch separate, una per ogni pezzo.

Ho usato questo script per fare questo:

#!/usr/bin/python2

import sys

header = []
writing_header = False
patchnum = 0

patch = open(sys.argv[1], "r")
out = open("/dev/null", "w")

for line in patch.readlines():
    if line.startswith("diff"):
        header = []
        writing_header = True
    if line.startswith("@@"):
        out.close()
        out = open(str(patchnum) + ".diff", "w")
        patchnum += 1
        writing_header = False
        out.writelines(header)
    if writing_header:
        header.append(line)
    else:
        out.write(line)

out.close()

Esempio di utilizzo:

$ cd directory_containing_patch
$ mkdir foo
$ cd foo
$ explode.py ../huge_patch.diff

Questo popolerà la directory corrente con file chiamati 0.diff 1.diff et cetera.

Passaggio 2: applicare ogni patch, eliminando le patch già applicate.

Ho usato questo script per fare questo:

#!/bin/bash

if [[ $# -ne 1 || ! -d "${1}/" ]]; then
    echo "Usage: $0 dirname"
    exit 1
fi

find "$1" -name \*.diff | while read f; do
    OUTPUT=$(patch -s -p1 -r- -i"$f")
    if [ $? -eq 0 ]; then
        rm "$f"
    else
        if echo "$OUTPUT" | grep -q "Reversed (or previously applied) patch detected!"; then
            rm "$f"
        fi
    fi
done

Esempio di utilizzo:

$ cd directory_containing_code
$ apply_patches.bash directory_containing_patch/foo

Ciò eliminerà qualsiasi delle patch precedentemente generate che si applicano in modo pulito o che sono già state applicate. Tutte le patch rimaste foosono scarti che devono essere esaminati e uniti manualmente.