Cosa fa la copia di hg?

Question

Abbiamo recentemente effettuato il hg copy di una directory nel nostro repository. Abbiamo pensato che lo facesse qualcosa come cp -a e hg add e magari in qualche modo segnala che questo file è stato copiato da un altro file all'interno del repository (quindi hg annotate mostra il committer originale). Ma ora sembra che hg copy faccia più o meno roba diversa da quella. Non sono riuscito a trovare davvero lo su come funziona esattamente la copia. Quindi:

• Che cosa fa esattamente hg copy fare e ciò che un trattamento speciale fa questo causa in futuro?
• Se si scopre di fare "la cosa sbagliata (tm)" nel nostro caso, come faccio a rimuovere il file da come una copia di un altro file?

(Questa domanda è stato chiesto sulla mailinglist Mercurial, si consiglia di follow the original thread troppo.)

Answer 1

• Che cosa fa esattamente hg copy fare e cosa trattamento speciale fa questo causa in futuro?

aggiunge nuovi file e li contrassegna come copie dei vecchi file. Perché sono copie, una modifica apportata nel file originale verrà unita in copia. Il tempo scorre da sinistra a destra:

(init) --- (edit a.txt) ---- (a.txt edit is copied to b.txt) 
     \     /
     (hg copy a.txt b.txt) 

• Se si scopre di fare 'la cosa sbagliata (tm)' per il nostro caso, come faccio rimuovere il contrassegno del file come beeing una copia di un altro file ?

Questo meccanismo attiva solo quando si unisce. Se b.txt non è presente nella revisione di antenato comune (init nel grafico sopra), Mercurial eseguirà una ricerca all'indietro per verificare se b.txt viene copiato da qualche altra parte.

continuiamo il grafico qui sopra in forma abbreviata:

(i) -- (edit a) -- (a edit copied to b) -- (edit a) -- (merge) 
    \   /        /
    (copy a b) --/------- (edit b) ------------------/ 

La domanda è come l'unione finale è fatto. Il punto di antenato comune è ora il nodo copy a b e qui sono presenti sia a sia . Questo significa che non ci sarà alcuna ricerca di copie! Quindi la seconda modifica a a non sarà da unire in b.

di controllare due volte, ho provato:

$ hg init 
$ echo a > a 
$ hg add a 
$ hg commit -m init 
$ hg copy a b 
$ hg commit -m "copy a b" 

Questa era la copia, b ora contiene solo a.

$ hg update 0 
0 files updated, 0 files merged, 1 files removed, 0 files unresolved 
$ echo aa >> a 
$ hg commit -m "edit a" 
created a new head 
$ hg merge 
merging a and b to b 
0 files updated, 1 files merged, 0 files removed, 0 files unresolved 
(branch merge, don't forget to commit) 
$ hg commit -m "a edit copied to b" 

questa era la prima unione e la modifica di a è stato copiato in b:

$ cat b 
a 
aa 

Ora apportare modifiche in parallelo:

$ echo aaa >> a 
$ hg commit -m "edit a again" 
$ hg update 3 
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 
$ echo bbb >> b 
$ hg commit -m "edit b" 
created new head 
$ hg merge 
1 files updated, 0 files merged, 0 files removed, 0 files unresolved 
(branch merge, don't forget to commit) 

non ci sono ulteriori copie fatto :

$ cat a 
a 
aa 
aaa 
$ cat b 
a 
aa 
bbb 

Per quanto riguarda la disattivazione di questo ... non è possibile disabilitare in modo esplicito la rilevazione della copia . Ma come spero di aver illustrato sopra, non ti "infastidirà" di te dopo la prima fusione.

Se la prima unione è un problema, è possibile utilizzare hg resolve --tool internal:local per reimpostare i file nel loro stato prima che fosse avviato l'unione. Quindi, con

$ hg resolve --tool internal:local b 

avremmo potuto portato b di nuovo appena contenente una linea con a.