Mesclando dois arquivos de texto não baseados em git com semântica semelhante à representação de conflitos de mesclagem do git

NOTA : Embora eu considere isso uma "resposta" um tanto razoável, agora cheguei a outra "resposta" que acho melhor. Então, por favor, veja minha outra "Resposta", abaixo.

Versão original desta "Resposta" ...

Oh! Postei muito cedo aqui. Eu não estava ciente da -Dopção de linha de comando para diff, e agora percebo que posso fazer isso ...

diff -D file.1 file.2 >file.merged

Ele irá produzir o seguinte dentro de file.merged...

common line 1 ...
common line 2 ...
common line 3 ...
#ifdef file.1
something unique from file.1
a second line of something unique from file.1
#else /* file.1 */
something unique from file.2
#endif /* file.1 */
common line 4 ...
common line 5 ...
#ifdef file.1
something unique from file.1
#else /* file.1 */
something unique from file.2
a second line of something unique from file.2
#endif /* file.1 */
common line 6 ...
common line 7 ...
... etc. ...

Posso lidar com as linhas #ifdef, #else, e #endifda mesma forma que posso lidar com gitas linhas <<<<<<<<, ========, e >>>>>>>>.

ATUALIZAÇÃO : ... e acabei de encontrar isso: https://stackoverflow.com/questions/16902001/manually-merge-two-files-using-diff

Ele mostra como também posso fazer algo semelhante com o formato diff unificado. Dê diffuma -Uopção com um argumento enorme que seja maior que o número máximo de linhas em file.1e file.2. Por exemplo ...

diff -U 99999999 file.1 file.2 | tail -n +4 >file.merged

Em seguida, ele produzirá isso:

 common line 1 ...
 common line 2 ...
 common line 3 ...
+something unique from file.2
-something unique from file.1
-a second line of something unique from file.1
 common line 4 ...
 common line 5 ...
+something unique from file.2
+a second line of something unique from file.2
-something unique from file.1
 common line 6 ...
 common line 7 ...
 ... etc. ...

As +linhas representam os dados exclusivos em file.2e as -linhas representam os dados exclusivos em file.1.

E eu posso lidar com essas +e -linhas.

Parece que você realmente não se importa com o formato de saída e, em vez disso, só quer saber como identificar quais linhas são de cada arquivo ou são comuns. Dá isso, que tal:

$ diff --old-line-format=$'-%l\n' --new-line-format=$'+%l\n' --unchanged-line-format=$'=%l\n' file.1 file.2
=common line 1 ...
=common line 2 ...
=common line 3 ...
-something unique from file.1
-a second line of something unique from file.1
+something unique from file.2
=common line 4 ...
=common line 5 ...
-something unique from file.1
+something unique from file.2
+a second line of something unique from file.2
=common line 6 ...
=common line 7 ...

Desconfie de qualquer solução em que você tenha que testar o conteúdo das linhas para um indicador da fonte para essa linha (por exemplo, se você estiver procurando <<<<<<< file.1dizer o que é exclusivo file1- e se filecontiver uma linha que seja exatamente essa string? ) em vez de um indicador que está sempre e apenas presente em uma posição única em cada linha, pois o teste de qualquer string falhará se essa string puder estar em sua entrada. Com o acima, o primeiro caractere é sempre um indicador de onde a linha veio, portanto, não pode entrar em conflito com o possível conteúdo do arquivo. Se você REALMENTE quisesse obter exatamente o formato de saída de conflitos de mesclagem do git (o que eu não recomendo), você sempre poderia canalizar o acima para um script awk simples para imprimir<<< fileou o que você quiser quando o primeiro caractere da linha for alterado e, em seguida, remova esse caractere.

Devido às limitações das soluções que postei originalmente na minha primeira "Resposta" aqui que envolve diff -D ...e diff -U ..., decidi escrever uma solução em python, usando o difflibmódulo do python.

Eu o escrevi para produzir uma saída que parece relativamente semelhante à saída "conflito de mesclagem" do git. Ele utiliza delimitadores contendo as strings <<<<<<<<, ========, e >>>>>>>>, e como sabemos, isso pode levar a ambiguidades se o texto original contiver strings como esta. No entanto, esse mesmo problema com ambiguidades pode existir na saída de "conflito de mesclagem" de git, mas como estou confortável gite disposto a aceitá-lo lá, também estou confortável com essas ambiguidades em minha própria solução.

A saída não é exatamente a mesma da gitsaída "conflito de mesclagem", mas é semelhante o suficiente para satisfazer meus desejos.

Primeiro, aqui está o programa python (limpei o código python original que postei aqui e esta é a versão limpa). Eu chamo esse programa filemerge...

#!/usr/bin/python3

### Take the diff's between two files and output
### the common and different lines in a manner
### which is very similar to the way that `git`
### depicts merge conflicts.

import sys
sys.dont_write_bytecode = True

import os

from difflib import unified_diff

prog       = None
diff_start = '<<<<<<<<'
diff_sep   = '========'
diff_end   = '>>>>>>>>'

def main():
    if len(sys.argv) < 3:
        print(f'\nusage: {prog} file1 file2\n')
        return 1

    file1, file2 = sys.argv[1:3]
    data1        = None
    data2        = None
    missing      = []

    try:
        with open(file1, 'r') as f:
            data1 = f.readlines()
    except Exception:
        missing.append(file1)

    try:
        with open(file2, 'r') as f:
            data2 = f.readlines()
    except Exception:
        missing.append(file2)
        
    if missing:
        print(f'\nnot found: {", ".join(missing)}\n')
        return 1

    n1 = len(data1)
    n2 = len(data2)
    max_lines = (n1 + 1) if n1 > n2 else (n2 + 1)
    count = 0
    state = ''
    sep_printed = False
    next_file = ''

    for line in unified_diff(data1, data2, n=max_lines):
        count += 1
        if count < 4:
            continue

        # Every line which is returned by unified_diff()
        # is at least 2 characters long. Each of these
        # lines starts with either ' ', '+', or '-', and
        # each of these lines ends with a newline.
        line = line[:-1]
        ch0  = line[0]

        if ch0 == ' ':
            if state:
                state = ''
                if not sep_printed:
                    print(f'{diff_sep}{next_file}')
                print(diff_end)
            sep_printed = False
            next_file = ''
        elif ch0 == '-':
            if state == ch0:
                pass
            elif state == '+':
                print(f'{diff_sep} file={file1}')
                sep_printed = True
                next_file = ''
            else:
                print(f'{diff_start} file={file1}')
                sep_printed = False
                next_file = f' file={file2}'
            state = ch0
        elif ch0 == '+':
            if state == ch0:
                pass
            elif state == '-':
                print(f'{diff_sep} file={file2}')
                sep_printed = True
                next_file = ''
            else:
                print(f'{diff_start} file={file2}')
                sep_printed = False
                next_file = f' file={file1}'
            state = ch0
        print(line[1:])

    if state:
        if not sep_printed:
            print(f'{diff_sep}{next_file}')
            next_file = ''
        print(diff_end)

    return 0

if __name__ == '__main__':
    prog = os.path.basename(sys.argv[0])
    sys.exit(main())

Aqui estão os arquivos de entrada com os quais eu testei. Eles são semelhantes, mas não exatamente iguais aos arquivos de entrada que postei originalmente na minha pergunta aqui ...

==== file.1====

common line 1 ...
common line 2 ...
common line 3 ...
something unique from file.1
a second line of something unique from file.1
common line 4 ...
common line 5 ...
something unique from file.1
common line 6 ...
common line 7 ...
penultimate file.1 line
common line 8 ...

==== file.2====

common line 1 ...
second line from file.2
common line 2 ...
common line 3 ...
something unique from file.2
common line 4 ...
common line 5 ...
something unique from file.2
a second line of something unique from file.2
common line 6 ...
common line 7 ...
common line 8 ...

Eu executo o comando assim...

filemerge file.1 file.2 >file.merged

E estes são os conteúdos resultantes de file.merged...

common line 1 ...
<<<<<<<< file=file.2
second line from file.2
======== file=file.1
>>>>>>>>
common line 2 ...
common line 3 ...
<<<<<<<< file=file.1
something unique from file.1
a second line of something unique from file.1
======== file=file.2
something unique from file.2
>>>>>>>>
common line 4 ...
common line 5 ...
<<<<<<<< file=file.1
something unique from file.1
======== file=file.2
something unique from file.2
a second line of something unique from file.2
>>>>>>>>
common line 6 ...
common line 7 ...
<<<<<<<< file=file.1
penultimate file.1 line
======== file=file.2
>>>>>>>>
common line 8 ...

Como mencionei, esse não é exatamente o mesmo formato da saída do "conflito de mesclagem" de git, mas é muito semelhante e está próximo o suficiente para mim.