Newsgroup: it.comp.os.linux.iniziare
Titolo: git: merge tree..

Ho un progetto cominciato nel 2008 che ad una certa data (diciamo il 
1�gennaio 2009), ho inserito in git per tenere traccia delle modifiche
sono andato nella directory (diciamo /project) e ho dato un
$ git init
$ git add .
$ git commit
Ora sono riuscito a trovare tutti i backup full e incrementali fino al 31 
dicembre 2008.
Sono andato in un'altra directory (diciamo /backup)
Ho scompattato il primo full, ho dato git init, git add ., git commit
Ho applicato tutti gli incrementali (e i full opportunamente elaborati) 
dando un git add . e un git commit ad ognuno.
Ora so per certo (per vedifiche) che l'attuale /backup === /project 
iniziale.
C'� la possibilit� di fondere i due rami e farne tutt'uno mantenendo la 
continuit� delle revisioni?
Grazie
Matteo

 continuit� delle revisioni?
man git-merge ... leggiti bene la pagina man e le opzioni ....
ciao ...
-- 
Never try to teach a pig to sing.
It wastes your time and annoys the pig.

 
Sembra che forse ci sono riuscito con git fetch/git rebase
Ora ho bisogno di un'altra cosa.
Vorrei "snellire" la .git/ perch� ho creato un po' di file (grandi) che ho 
creato, ho dato git add ma NON git commit e non riesco ad eliminare questi 
file da git in nessun modo.
C'� un sistema? ma soprattutto, visto che la .git non diminuisce e quindi il 
file � ancora sotto git, c'� la possibilit� di recuperarlo eventualmente?
queste le prove che ho fatto.
$ git init
$ touch start
$ git add .
$ git commit -m start
$ du -sk .git/
156     .git/
aggiungo un file di 5M
$ cp /tmp/test .
$ ls -l
-rw-r--r-- 1 matteo users       0 2009-08-06 13:44 start
-rw-r--r-- 1 matteo users 4937616 2009-08-06 13:45 test
$ git add test
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   test
#
$ du -sk .git/
4980    .git/
ci ripenso prima del commit
$ git rm test --cached      # lo voglio togliere da git, non dal disco
$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#       test
$ du -sk .git/
4980    .git/
oppure
$ git reset HEAD test
$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#       test
$ du -sk .git/
4980    .git/
oppure
$ git reset HEAD --hard
$ git status
# On branch master
nothing to commit (working directory clean)
$ ls
start
$ du -sk .git
4984    .git
mi ha tolto test dal disco (che non � ci� che voglio) ma non l'ha tolto da 
.git

 
� il primo che ho usato, credo, ma non andava perch� trovava conflitti (che 
non ci sono.. i test li ho fatti con una alberatura piccola e tre soli 
commit per albero) e trovava conflitti insisolti.
Forse non ho utilizzato i parametri giusti, ma da quel che ho capito git 
merge ha tentato di fare il merge di HEAD del primo ramo con HEAD del 
secondo, mentre io voglio unire l'HEAD del primo (l'albero pi� vecchio) con 
l'init del secondo (visto che in quel punto i due alberi coincidono).
comunque git rebase sembra che faccia questo lavoro se unito ad un git fetch
Matteo

e un'altra cosa (simile, ma non so se si pu� fare).
dopo un git commit mi ritrovo test in git log.
per annullare la modifica faccio
git reset <penultimo commit-id> --hard
a questo punto git log non mi mostra pi� questo commit, ma la .git non � 
variata di dimensioni.
Il commit con i file (ormai spariti dall'harddisk) � ancora presente?
Matteo

 Il commit con i file (ormai spariti dall'harddisk) � ancora presente?
git gc
dovrebbe funzionare ...


 
non ha funzionato
per� ha funzionato git prune
Matteo

 
ci sono ancora problemi (l'alberello piccolo con pochi file non era 
sufficiente per i test; all'atto pratico � pi� complicato)
Situazione:
primo ramo:
A->B->C->D->E->F	
    in cui A equivale git init&&touch git2009&&git commit -m A
    B equivale a tar xf archivio010109-full.tar
    C equivale a tar xf archivio020109-incr.tar
    ...
    F � l'ultimo commit (HEAD)
secondo ramo:
P->Q->R->S->T->U->V->Z
    in cui P equivale a git init&&touch git2008&&git commit -m P
    Q equivale a tar xf archivio010108-full.tar
    R equivale a tar xf archivio020108-incr.tar
    ...
    V equivale a tar xf archivio 311208-incr.tar
    Z equivale a pulizia prefull + tar xf archivio010109-full.tar
a questo punto, Z e B dovrebbero coincidere, quindi quello che dovrei fare, 
� riuscire a ottenere qualcosa tipo
P->Q->..->V->Z->C->D->E->F
saltando A (che � pressoch� vuoto) e B (perch� ha tutti i file di Z)
Al momento sono riucito a spostare solo A ma mi vengono fuori un po' di 
conflitti
Matteo

 
Riuscito!!!!!
il risultato � un po' diverso ma equivalente ai fini pratici.
i passi sono pi� o meno:
$ cd /path/to/primo/ramo
$ git fetch file:///path/to/secondo/ramo
i .git dei due rami sono rispettivamente di 56M e 272M
$ git checkout A # in A ci sono pochissimi file
$ cp * ../tmp
$ git checkout V # la situazione pi� simile a B
$ git rm -rf .
$ cp ../tmp/* .
$ git add .
$ git commit -m "(X) situazione identica ad A"
$ git checkout master
$ git rebase X
$ git branch -D <tuttiglialtribranch>
$ git gc --aggressive
$ git prune
$ git log
P->Q->R->S->T->U->V->X->A->B->C->D->E->F
$ du -sk .git
56M
bel risultato, no?
in qualunque momento si voglia vedere solo la situazione del 2008:
$ git checkout FETCH_HEAD
in qualunque momento si voglia vedere solo la situazione del 2009:
$ git checkout ORIG_HEAD
per tornare a vedere tutta la situazione:
$ git checkout master
Master


aiuto prezioso il mio ;-) devo andare in ferieeee !!!
ciao ...
