mirror of
https://github.com/git-learning-game/oh-my-git.git
synced 2024-12-22 20:32:38 +01:00
reset levels directory without it translations
This commit is contained in:
Luca Canali
parent
07d33339cc
commit
e80596219a
208 changed files with 193 additions and 3511 deletions
|
|
@ -1,43 +0,0 @@
|
|||
title = Strada di mattoni gialli
|
||||
cards = checkout commit-auto reset-hard bisect-start bisect-good bisect-bad
|
||||
|
||||
[description]
|
||||
|
||||
(Perpiacere rimpicciolisci un pochino usando la rotella del mouse! :D)
|
||||
|
||||
Oh no! Hai perso la tua chiave da qualche parte durante il giorno!
|
||||
|
||||
Sicuro, certo potresti guardare in ogni singolo commit nella speranza di trovarlo - ma c'è un modo migliore: la tua macchina del tempo ha un modo integrato per trovare velocemente il punto nel tempo dove le cose sono andate male!
|
||||
|
||||
Per prima cosa, gioca la carta "bisec start". Quindi, vai ad un commit in cui non hai la chiave e gioca la carta "bisect bad". Allo stesso modo vai velocemente in un commit dove hai la chiave *in tascca* e gioca la carta "bisect goofìd".
|
||||
|
||||
Dopo aver trovato l'ultimo commit valido reimposta la branch principale su di esso. Cosa è successo alla chiave dopo che l'hai persa?
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Hai ancora la tua chiave." > you
|
||||
|
||||
for i in {1..30}; do
|
||||
if test $i -eq 12; then
|
||||
echo "La tua tasca è vuota." > you
|
||||
echo "E' per terra." > key
|
||||
fi
|
||||
if test $i -eq 13; then
|
||||
echo "Tiene una chiave nel becco." > bird
|
||||
rm key
|
||||
fi
|
||||
if test $i -eq 14; then
|
||||
rm bird
|
||||
fi
|
||||
git add .
|
||||
git commit --allow-empty -m "$i"
|
||||
done
|
||||
|
||||
[win]
|
||||
|
||||
# Trova l'ultimo commit buono
|
||||
test "$(git log --pretty=%s main | head -1)" -eq 11
|
||||
|
||||
[congrats]
|
||||
|
||||
Molto bene! :) L'unico problema è che adesso devi tornare a casa camminando, dinuovo...
|
||||
|
|
@ -1 +0,0 @@
|
|||
bisect
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
title = Creare ramificazioni
|
||||
cards = checkout commit-auto branch branch-delete reset-hard
|
||||
|
||||
[description]
|
||||
|
||||
Vieni invitato a due feste! In una di queste, suona il tuo gruppo preferito e l'altra è la festa del tuo miglio amico. Dove andrai? Non preoccuparti - come agente del viaggio nel tempo, puoi andare ad entrambe le feste!
|
||||
|
||||
Per rendere più facile dire quale sia la linea temporale, puoi creare portali temporali! (Chiamiamoli "rami-branchs")
|
||||
|
||||
[cli]
|
||||
|
||||
Anche viaggiare tra differenti rami temporali è davvero facile usando la linea di comando! Hai un ramo chiamato "birthday", puoi digitare `git checkout birthday` per arrivarci.
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Incarta il regalo di compleanno e prendi il biglietto del concerto." > you
|
||||
git add .
|
||||
git commit -m "Preparazione serale"
|
||||
echo "Vai alla festa di compleanno!" >> you
|
||||
git add .
|
||||
git commit -m "Vai al compleanno"
|
||||
|
||||
git checkout HEAD~1
|
||||
echo "Vai al concerto!" > you
|
||||
git add .
|
||||
git commit -m "Vai al concerto"
|
||||
|
||||
git checkout HEAD~1
|
||||
|
||||
git branch -D main
|
||||
|
||||
[win]
|
||||
|
||||
# Crea un ramo chiamato 'birthday' questo punta alla linea temporale del compleanno
|
||||
git show birthday | grep 'birthday'
|
||||
|
||||
# Crea un ramo chiamato 'concert' questo punta alla linea temporale del compleanno
|
||||
git show concert | grep 'concert'
|
||||
|
||||
[congrats]
|
||||
|
||||
Adesso tu puoi viaggiare tra quie rami facilmente (usando `git checkout`) - Prova!
|
||||
|
||||
Il tuo amico è felice che tu sia andato alla sua festa di compleanno e anche tu sei contento del biglietto del concerto firmato. Yay!
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
title = Cancellare rami
|
||||
cards = checkout commit-auto reset-hard branch-delete
|
||||
|
||||
[description]
|
||||
|
||||
La vita è piena di pericolim, vero? Anche quando cammini a scuola2, sembra che ci siano molti rischi!
|
||||
|
||||
Questo Lunedì è particolarmente brutto.Sei arrivato a scuola ma ci sono delle line temporali che tu non vuoi tenere in giro
|
||||
|
||||
[setup]
|
||||
|
||||
echo Esci di casa e ti incammini verso la scuola. > you
|
||||
git add .
|
||||
git commit -m "Buon giorno!"
|
||||
|
||||
echo Cammini nel lato destro della strada. >> you
|
||||
git commit -am "Lato destro"
|
||||
|
||||
echo Salti in un tombino nel marciapiede e arrivi in orario a scuola. >> you
|
||||
git commit -am "Salto"
|
||||
|
||||
git checkout HEAD^ -b friend
|
||||
echo "All'improvviso cadi in una pozzanghera puzzolente e vieni mangiato da degli alligatori." >> you
|
||||
git commit -am "Un nuovo amico"
|
||||
|
||||
git checkout HEAD~2 -b music
|
||||
echo Cammini nel lato sinistro della strada. >> you
|
||||
git commit -am "Lato sinistro"
|
||||
|
||||
echo Siccome sei in ritardo, inizi a corre ma qualcuno lanci un pianoforte dalla finestra e ti schiacci. >> you
|
||||
git commit -am "Bei suoni"
|
||||
|
||||
git checkout HEAD^ -b ice-cream
|
||||
echo Non sei preoccupato e cammini lentamente. Prendi anche un gelato per strada. Arrivi troppo tardi a scuola, il tuo insegnante è arrabbiato e vieni espulso da scuola. >> you
|
||||
git commit -am "Yum"
|
||||
|
||||
git branch -M main leap
|
||||
git checkout leap^^
|
||||
|
||||
[win]
|
||||
|
||||
# Trova i rami cattivi e cancellali. Tieni solo il migliore.
|
||||
test "$(git show-ref --heads | cut -f2 -d' ')" = "$(echo refs/heads/leap)"
|
||||
|
||||
[congrats]
|
||||
|
||||
Ripensandoci preferisci la linea temporale del gelato? :)
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
title = Muoversi attraverso il tempo
|
||||
cards = checkout commit-auto
|
||||
|
||||
[description]
|
||||
|
||||
La scatole gialle sono un punto fisso nel tempo, possiamo chiamarli "commits"! Puoi viaggiare tra loro usando la carta "checkout"! (Provala!)
|
||||
|
||||
Puoi scoprire cosa è successo qui? Quindi, durante ultimo commit, modifica i files per risolvere il problema ed invia un nuovo commit!
|
||||
|
||||
[cli]
|
||||
|
||||
Guarda uno specifico commit, digita `git checkout` uno spazio e premi il tasto destro sopra il commit che vuoi!
|
||||
|
||||
Questo inserirà l'identificatore unico del commit!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Questo salvadanaio appartiene alla sorella maggiore.
|
||||
Contiene 10 monete." > piggy_bank
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
echo "Una giovane donna con capelli, ricci, marroni." > little_sister
|
||||
git add .
|
||||
git commit -m "La sorella piccola è arrivata"
|
||||
|
||||
echo "Ha 10 monete." >> little_sister
|
||||
echo "Questo salvadanaio appartiene alla sorella maggiore.
|
||||
E' vuoto." > piggy_bank
|
||||
git add .
|
||||
git commit -m "La sorella piccola ha fatto qualcosa"
|
||||
|
||||
git checkout HEAD^^
|
||||
git branch -df main
|
||||
|
||||
[win]
|
||||
|
||||
# Ripristina il salvadanaio della sorella.
|
||||
{ git show HEAD:piggy_bank | grep "10 monete"; } && { git show HEAD:little_sister | grep -v "10 monete"; } && { git rev-parse HEAD^^^; }
|
||||
|
||||
[congrats]
|
||||
|
||||
Stupendo! Adesso hai preso famiglirità con la macchina del tempo, vediamo situazioni più complicate...
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
title = Crea universi paralleli
|
||||
cards = checkout commit-auto
|
||||
|
||||
[description]
|
||||
|
||||
Sai che creare line temporali parallele è perfettamente legale e sicuro? Vero!
|
||||
|
||||
Puoi scoprire qundo le cose sono andate male in questo zoo? Poi torna all'ultimo momento buono e crea un universo parallelo dove sono tutti felicy!
|
||||
|
||||
[cli]
|
||||
|
||||
L'animale blue rappresenta un concetto conosciuto come "HEAD pointer" in Git: Ti mostra qual'è il commit attuale.
|
||||
|
||||
Ecco un simpatico trucchetto andare al commit precedente:
|
||||
|
||||
git checkout HEAD^
|
||||
|
||||
Puoi anche andare indietro di 2 commit digitando, pre esempio:
|
||||
|
||||
git checkout HEAD~2
|
||||
|
||||
[setup]
|
||||
|
||||
mkdir cage
|
||||
echo "Sembra molto affamato." > cage/lion
|
||||
|
||||
echo "Un ragazzino..
|
||||
Ama veramente i gatti!" > child
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
echo "Tiene in mano un leccalecca." >> child
|
||||
git commit -am "Il ragazzo compra qualcosa"
|
||||
|
||||
mv child cage
|
||||
git add .
|
||||
git commit -m "Il bambino si arrampica da qualche parte"
|
||||
|
||||
git rm cage/child
|
||||
echo "E' felice. :)" > cage/lion
|
||||
git add .
|
||||
git commit -m "Oh no"
|
||||
|
||||
echo "Sta dormendo." > cage/lion
|
||||
git add .
|
||||
git commit -m "Ora del pisolino!"
|
||||
|
||||
git checkout --detach
|
||||
git branch -d main
|
||||
|
||||
[win]
|
||||
|
||||
# Assicurati che il ragazzino sia felice.
|
||||
git ls-tree --name-only -r HEAD | grep child
|
||||
|
||||
# Assicurati che il leone abbia qualcosa da mangiare.
|
||||
git show HEAD:cage/lion | grep -v "molto affamato"
|
||||
|
||||
[congrats]
|
||||
|
||||
Whew, ottimo lavoro! Questo sembra un risultato molto migliore.
|
||||
|
||||
Sentiti libero di aggiungere altre line temporali parallele o allungarle.
|
||||
|
||||
Se sei pronto, la prossima missione ci sta aspettando...
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
title = I rami crescono con tè!
|
||||
cards = checkout commit-auto branch branch-delete reset-hard
|
||||
|
||||
[description]
|
||||
|
||||
Nota che ci sono due opzioni per "viaggire fino alla fine della linea temporale":
|
||||
|
||||
Primo, puoi direttamente viaggiare al commit, come abbiamo fatto prima.
|
||||
|
||||
e secondo, puoi viaggiare fino all'etichetta del ramo. In questo caso, quando crei un nuovo commit, il ramo cresce con te e punta ancora alla fine della linea temporale!
|
||||
|
||||
[cli]
|
||||
Per viaggire in un ramo, digita `git checkout name_of_the_branch`.
|
||||
|
||||
e per viaggiare all'ultimo commit, digita `git checkout --detach name_of_the_branch`.
|
||||
|
||||
[setup]
|
||||
|
||||
echo "In carti il regalo di complanno e prendi il biglietto del concerto." > you
|
||||
git add .
|
||||
git commit -m "Preparazioni della sera"
|
||||
echo "Vai alla festa di compleanno!" >> you
|
||||
git add .
|
||||
git commit -m "Vai alla festa di compleanno"
|
||||
git branch birthday
|
||||
|
||||
git checkout HEAD~1
|
||||
echo "Vai al concerto!" > you
|
||||
git add .
|
||||
git commit -m "Vai al concerto"
|
||||
git branch concert
|
||||
|
||||
git checkout HEAD~1
|
||||
|
||||
git branch -D main
|
||||
|
||||
[win]
|
||||
|
||||
# Viaggi direttamente all'ultimo commit giallo della line temporale del compleanno, fai un cambiamento per te e crea un commit
|
||||
for commit in $(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep 'commit$' | cut -f1 -d' '); do
|
||||
if test $(git rev-parse $commit^) = $(git rev-parse birthday); then
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
return 1
|
||||
|
||||
# Viaggi fino al ramo, blue, del concerto, fai un cambiamento ed un commit.
|
||||
git show concert^ | grep "Vai al concerto"
|
||||
|
|
@ -1,89 +0,0 @@
|
|||
title = Muovere i rami
|
||||
cards = checkout commit-auto merge reset-hard
|
||||
|
||||
[description]
|
||||
|
||||
Uno dei tuoi colleghi ha fatto un casino qui e ha messo le branches nelle line temporali sbagliate!
|
||||
|
||||
Potresti cancellare e ricreare queste branches - ma puoi anche muoverle direttamente in un differente commit usando:
|
||||
|
||||
git checkout
|
||||
|
||||
nel nome della branch e poi usare
|
||||
|
||||
git reset --hard
|
||||
|
||||
nel commit dove vuoi che la branch vada.
|
||||
|
||||
La ciambella è nella branch giusto ma la linea temporale è incompleta - fai *mangiare* la ciambella a quella branch!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Tu non hai una baguette.
|
||||
|
||||
Non hai un caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
git checkout -b coffee
|
||||
echo "Tu hai una baguette.
|
||||
|
||||
Non hai un caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Compri una ciambella"
|
||||
|
||||
echo "Mangi una baguette.
|
||||
|
||||
Non hai un caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Mangi una baguette"
|
||||
|
||||
git checkout -b baguette main
|
||||
echo "Non hai una ciambella.
|
||||
|
||||
Hai un caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Compri un pò di caffe"
|
||||
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Hai bevuto caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Bevi il caffe"
|
||||
|
||||
git checkout -b donut main
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Compri una ciambella"
|
||||
|
||||
git checkout --detach main
|
||||
|
||||
[win]
|
||||
|
||||
# Mangi una baguette nella branch delle baguette?
|
||||
git show baguette:you | grep "Mangi.*baguette"
|
||||
|
||||
# Bevi un caffe nella branch del caffe?
|
||||
git show coffee:you | grep "Bevi.*coffe"
|
||||
|
||||
# Mangi una ciambella nella branch delle ciambelle?
|
||||
git show donut:you | grep "Mangi.*ciambella"
|
||||
|
||||
[actions]
|
||||
|
||||
test "$(git rev-parse HEAD^)" = "$(git rev-parse donut)" && hint "Ricordati di controllare l'etichetta branch blue quando vuoi che cresca con la linea temporale."
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
checkout-commit
|
||||
fork
|
||||
branch-create
|
||||
grow
|
||||
branch-remove
|
||||
reorder
|
||||
|
|
@ -1,86 +0,0 @@
|
|||
title = Rebasing
|
||||
cards = checkout commit-auto reset-hard rebase
|
||||
|
||||
[description]
|
||||
|
||||
Okay - Salta vuori che risparmiare tempo al mattino utilizzando universi paralleli è contro il regolamento dell'International Time Travel Association. Dovrai svolgere i tuoi compiti in sequenza dopotutto.
|
||||
|
||||
Vedi la carta "rebase"? Quando la trascini su di un commit, copierà dopo di esso tutti gli eventi della linea temporale su cui ti trovi! In questo modo crei una linea temporale chiara e pulita dove visiti tutti e tre i negozzi.
|
||||
|
||||
Nuovamente, vogliamo rendere questa la nostra realtà di base - il ramo "main" dovrebbe puntare a quella linea temporale!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
git checkout -b baguette main
|
||||
echo "Hai una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Compri una baguette"
|
||||
|
||||
echo "Mangi una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Mangi la baguette"
|
||||
|
||||
git checkout -b coffee main
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Hai del caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Compri un pò di caffe"
|
||||
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Hai bevuto caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Bevi il caffe"
|
||||
|
||||
git checkout -b donut main
|
||||
echo "Non hai una baguette
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Hai una ciamebella." > you
|
||||
git add .
|
||||
git commit -m "Compri una ciambella"
|
||||
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Mangi una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Mangi la ciambella"
|
||||
|
||||
git checkout --detach main
|
||||
|
||||
|
||||
[win]
|
||||
|
||||
# Ordina le tre ramificazioni in una e muovi il riferimento al ramo principale
|
||||
{ git show main:you | grep "Mangi.*baguette"; } && { git show main:you | grep "bevuto.*caffe"; } && { git show main:you | grep "Mangi.*ciambella"; } && { test "$(git log main --oneline | wc -l)" -eq 7; }
|
||||
|
||||
[congrats]
|
||||
|
||||
Nota come gli altri commit e linee temporali siano ancora li - se qualcosa va storto, puoi ancora tornare in dietro.
|
||||
|
||||
E' davvero difficile *distruggere* le cose con la tua macchina del tempo.
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
title = Riordinare gli eventi
|
||||
cards = checkout commit-auto reset-hard rebase-interactive cherry-pick
|
||||
|
||||
[description]
|
||||
|
||||
Oops, guarda c'è qualcosa di incasinato qui. Puoi rimettere gli eventi nel corretto ordine?
|
||||
|
||||
Ci sono due modi per farlo: Puoi trascinare la carta "interactive rebase" sul commit precedente a quello che vuoi cambiare, poi riordinare le linee nel file che si apre e salvarlo.
|
||||
Oppure puoi reimpostare il tag principale al primo commit, quindi selezionare i singoli commit (cherry-pick) nell'ordine desiderato. Hai carte per entrambe i modi!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Ti sei appena svegliato.
|
||||
|
||||
Non indossi biancheria intima.
|
||||
|
||||
Non indossi pantaloni.
|
||||
|
||||
Non indossi la maglia.
|
||||
|
||||
Non indossi le scarpe." > you
|
||||
git add .
|
||||
|
||||
git commit -m "L'inizio"
|
||||
|
||||
echo "Ti sei appena svegliato.
|
||||
|
||||
Non indossi biancheria intima.
|
||||
|
||||
Non indossi pantaloni.
|
||||
|
||||
Non indossi la maglia.
|
||||
|
||||
Indossi le scarpe." > you
|
||||
git commit -am "Metti le scarpe"
|
||||
|
||||
echo "Ti sei appena svegliato.
|
||||
|
||||
Non indossi biancheria intima.
|
||||
|
||||
Indossi pantaloni.
|
||||
|
||||
Non indossi la maglia.
|
||||
|
||||
Indossi le scarpe." > you
|
||||
git commit -am "Metti i pantaloni"
|
||||
|
||||
echo "Ti sei appena svegliato.
|
||||
|
||||
Indossi la biancheria intima.
|
||||
|
||||
Indossi pantaloni.
|
||||
|
||||
Non indossi la maglia.
|
||||
|
||||
Indossi le scarpe." > you
|
||||
git commit -am "Metti biancheria intima"
|
||||
|
||||
echo "Ti sei appena svegliato.
|
||||
|
||||
Indossi biancheria intima.
|
||||
|
||||
Indossi pantaloni.
|
||||
|
||||
Indossi la maglia.
|
||||
|
||||
Indossi le scarpe." > you
|
||||
git commit -am "Ti metti la maglia"
|
||||
|
||||
[win]
|
||||
|
||||
# Riordina i commit per vestirti nel modo corretto
|
||||
{ git log main --oneline | perl -0777 -ne'exit(1) if not /scarpe[\s\S]*pantaloni[\s\S]*biancheria/'; } && { test "$(git log main --oneline | wc -l)" -eq 5; }
|
||||
|
||||
[congrats]
|
||||
|
||||
Sentiti libero di resettare il livello e provare l'altra strategia! Qual'è quella che preferisci?
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
rebase
|
||||
reorder
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
title = Arredatore di interni
|
||||
cards = file-new file-delete
|
||||
|
||||
[description]
|
||||
|
||||
Ora che la tua stanza sembra in ordine, puoi iniziare a disfare le tue cose. Hai portato con te due mobili nuovi e con un sorriso luminoso,
|
||||
vedi che i loro colori corrispondono al colore del tuo letto!
|
||||
|
||||
Costruisci i tuoi due mobili usando la carta touch.
|
||||
Quindi dai il nome ai tuoi mobili - puoi sciegliere quello che tu vuoi.
|
||||
|
||||
Assicurati che i colori siano uguali! Puoi trovare il colore del letto nella descrizione.
|
||||
Non dimenticare di aggiungere un colore e una descrizione anche ai tuoi nuovi mobile.
|
||||
|
||||
[setup]
|
||||
echo Un accogliente letto giallo. > bed
|
||||
|
||||
[win]
|
||||
|
||||
# Aggiungi altri due mobili
|
||||
NUM_FILES="$(ls | wc -l)"
|
||||
test "$NUM_FILES" -ge 3
|
||||
|
||||
# Assicurati che i colori corrispondano a quelle del tuo letto
|
||||
NUM_FILES="$(ls | wc -l)"
|
||||
YELLOW_FILES="$(grep -li giallo * | wc -l)"
|
||||
test "$NUM_FILES" -ge 2 && test "$YELLOW_FILES" = "$NUM_FILES"
|
||||
|
||||
[congrats]
|
||||
|
||||
Non ti senti già più a casa?
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
title = Coinquilini inaspettati
|
||||
cards = file-delete
|
||||
|
||||
[description]
|
||||
|
||||
Il primo giorno alla Scuola del viaggio nel tempo sta per finire e tu ricevi le chiavi della tua stanza.
|
||||
Eccitatissimo apri la porta giusto per vedere... ragnatele! Ragnatele ovunque!
|
||||
|
||||
Cava tutte le ragnatele che puoi trovare con la carta remove!
|
||||
|
||||
[cli]
|
||||
|
||||
Nella line di comando, puoi facilmente eliminare tutti i file che finiscono in "web" usando il comando:
|
||||
|
||||
rm *web
|
||||
|
||||
[setup]
|
||||
|
||||
echo Una piccola ragnatela è accanto alla tua finestra. > tiny_web
|
||||
echo Una grande ragnatela attaccata sopra al tuo letto. > big_web
|
||||
echo Un letto accogliente. > bed
|
||||
echo Una ragnatela spessa è alla destra della tua porta. > thick_web
|
||||
|
||||
[win]
|
||||
|
||||
# Rimuovi tutte le ragnatele.
|
||||
! ls | grep thick_web &&
|
||||
! ls | grep big_web &&
|
||||
! ls | grep tiny_web
|
||||
|
||||
# Ma assicurati di mantenere il tuo letto!
|
||||
ls | grep bed
|
||||
|
||||
[congrats]
|
||||
|
||||
Guarda la tua stanza adesso è davvero ordinata ed accogliente! Il momento per disfare le valige!
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
files-delete
|
||||
files-add
|
||||
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
compare
|
||||
new
|
||||
change
|
||||
reset
|
||||
steps
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
title = Updating files in the index
|
||||
cards = add commit checkout
|
||||
|
||||
[description]
|
||||
|
||||
So you start working, and make changes to your files! Git lets you choose which of these changes you want to put in the next commit. This is like updating the index version of that file to the new version.
|
||||
|
||||
This allows you to have smaller commits, that describe better what you changed!
|
||||
|
||||
The command for this is the same - `git add`!
|
||||
|
||||
[setup]
|
||||
|
||||
echo a > a
|
||||
echo b > b
|
||||
echo c > c
|
||||
git add .
|
||||
git commit -m "Initial commit"
|
||||
|
||||
[win]
|
||||
|
||||
# Make changes to all files!
|
||||
test "$(cat a)" != "a" &&
|
||||
test "$(cat b)" != "b" &&
|
||||
test "$(cat c)" != "c"
|
||||
|
||||
# Add only the changes of a and c, and make a commit! Finally, make a commit which captures the changes in b!
|
||||
|
||||
test "$(git show main:a)" != "a" &&
|
||||
test "$(git show main:b)" != "b" &&
|
||||
test "$(git show main:c)" != "c" &&
|
||||
test "$(git show main^:a)" != "a" &&
|
||||
test "$(git show main^:b)" == "b" &&
|
||||
test "$(git show main^:c)" != "c"
|
||||
|
||||
[congrats]
|
||||
|
||||
Well done! Try tavelling between the commits using `git checkout`, so you can look at their contents again!
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
title = Aggiornare i file nell'indice
|
||||
cards = add commit
|
||||
|
||||
[description]
|
||||
|
||||
Quando cambiamo i files l'indice non cambia da solo. Dobbiamo usare `git add` per aggiornare l'indice alla nuova versione del file..
|
||||
|
||||
Proviamoci!
|
||||
|
||||
Le icone nel file manager ti mostrano quando il file attuale (bianco) e la versione nell'indice (blu) differiscono o sono uguali!
|
||||
|
||||
[win]
|
||||
|
||||
Bene! L'indice è anche chiamato "staging area" (area di staging) - E contiene esattamente ciò che finisce nel prossimo commit quando usi `git commit`!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "La candela brucia con una fiamma blu." > candle
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
[win]
|
||||
|
||||
# Fai una modifica alla candela
|
||||
test "$(git diff --name-only)" = "candle" || file -f .git/candle-changed && touch .git/candle-changed
|
||||
|
||||
# Aggiungi la candella.
|
||||
test "$(git diff --cached --name-only)" = "candle" || file -f .git/candle-added && touch .git/candle-added
|
||||
|
||||
# Fai un commit.
|
||||
test "$(git diff --name-only HEAD HEAD^)" = "candle"
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
title = Checking out files from the index
|
||||
cards = add reset-file checkout-file commit
|
||||
|
||||
[description]
|
||||
|
||||
So you've made changes to your files, but you decide that you don't want to keep them! You can use `git checkout` for that!
|
||||
|
||||
What happens if you have already update the index, like in file c? You have to reset the index first!
|
||||
|
||||
[setup]
|
||||
|
||||
echo a > a
|
||||
echo b > b
|
||||
echo c > c
|
||||
git add .
|
||||
git commit -m "Initial commit"
|
||||
echo x > a
|
||||
echo x > b
|
||||
echo x > c
|
||||
git add c
|
||||
|
||||
[win]
|
||||
|
||||
# Remove all changes in your local files!
|
||||
test "$(git diff --name-only | wc -l)" -eq 0
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
title = Passo dopo passo
|
||||
cards = checkout commit-auto
|
||||
|
||||
[description]
|
||||
|
||||
Benvenuto! nella lezione di oggi impareremo come creare commits con più precisione!
|
||||
|
||||
Dai un'occhiata a queste due linee temporali. Hanno lo stesso risultato, ma in una delle due è molto più semplice capire cosa è successo.
|
||||
|
||||
[win]
|
||||
|
||||
# Esatto! Avere ogni cambiamento nel proprio commit rende più facile capire cosa sta succedendo!
|
||||
git branch --show-current | grep step-by-step
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Una piccola ma pesante palla di vetro." > ball
|
||||
echo "Un sottile libro che sta in piedi." > book
|
||||
echo "Una candela brucia con una fiamma blu." > candle
|
||||
echo "Un sensore di fumo. E' assolutamente silenzioso." > smoke_detector
|
||||
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
git branch -M all-at-once
|
||||
|
||||
echo "La palla adesso tocca il libro." > ball
|
||||
echo "Il libro è caduto." > book
|
||||
echo "La candella è stata spenta." > candle
|
||||
|
||||
git commit -am "La fine"
|
||||
|
||||
git checkout HEAD^
|
||||
|
||||
git checkout -b step-by-step
|
||||
|
||||
echo "La palla adesso tocca il libro." > ball
|
||||
git commit -am "La palla rotola verso il libro"
|
||||
|
||||
echo "Il libro è caduto." > book
|
||||
git commit -am "Il libro è caduto"
|
||||
|
||||
echo "La candela è stata spenta." > candle
|
||||
git commit -am "Il libro ha spento la candela"
|
||||
|
||||
git checkout HEAD~3
|
||||
|
||||
[win]
|
||||
|
||||
# Prendi la sequenza temporale più chiara e fai suonare il sensore di fumo!
|
||||
git show step-by-step:smoke_detector | tail -n 1 | grep -v "assolutamente silenzioso"
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
title = Aggiungere nuovi file all'indice
|
||||
cards = add commit
|
||||
|
||||
[description]
|
||||
|
||||
Finora, quando abbiamo eseguito un commit abbiamo sempre registrato lo stato di tutti gli oggetti, vero?
|
||||
|
||||
Ma Git ti permette di scegliere i cambiamenti che si vogliono mettere in un commit!
|
||||
|
||||
Per sapere come funziona, dobbiamo conoscere l'"indice"! Nell'indice, possiamo preparare ciò che sarà nel prossimo commit. In questo gioco, l'indice è rappresentato da un'aura blu attorno alle icone nel file manager!
|
||||
|
||||
Inizialmente, l'indice è vuoto. Per fare un commit che contenga un nuovo file, dobbiamo aggiungerlo!
|
||||
|
||||
[cli]
|
||||
|
||||
Puoi usare il completamento con la tabulazione nel terminale! Inizia a scrivere il nome di un file e premi il tasto tab per completarlo. Così risparmi tempo!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "La candela brucia con una fiamma blu." > candle
|
||||
|
||||
[win]
|
||||
|
||||
# Aggiungi la candela.
|
||||
test "$(git diff --cached --name-only)" = "candle" || file -f .git/candle-added && touch .git/candle-added
|
||||
|
||||
# Crea un commit.
|
||||
test "$(git ls-tree --name-only HEAD)" = "candle"
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
title = Resettare i file nell'indice
|
||||
cards = add reset-file commit
|
||||
|
||||
[description]
|
||||
|
||||
Vedi l'ombra scura dietro le icone? Questa è la versione del file nell'ultimo commit!
|
||||
|
||||
Per esempio, queste candele sono state spente e quella modifica è stata aggiunta!
|
||||
|
||||
Ma è stato un errore! Vuoi solo spegnere al candela rossa nel prossimo commit!
|
||||
|
||||
Se hai già aggiunto un file modificato all'indice ma vuoi ripristinarlo, puoi usare `git reset`!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Sta bruciando!" > red_candle
|
||||
echo "Sta bruciando!" > green_candle
|
||||
echo "Sta bruciando!" > blue_candle
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
echo "È stata spenta." > red_candle
|
||||
echo "È stata spenta." > green_candle
|
||||
echo "È stata spenta." > blue_candle
|
||||
git add .
|
||||
|
||||
[win]
|
||||
|
||||
# Ripristina i cambiamenti nella candela verde e in quella blu!
|
||||
git show :green_candle | grep burning &&
|
||||
git show :blue_candle | grep burning &&
|
||||
git show :red_candle | grep -v burning
|
||||
|
||||
# E fai un commit
|
||||
git show main:green_candle | grep burning &&
|
||||
git show main:blue_candle | grep burning &&
|
||||
git show main:red_candle | grep -v burning
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
title = Delete a file in the next commit
|
||||
cards = add reset-file checkout-file rm file-delete commit
|
||||
|
||||
[description]
|
||||
|
||||
If you want to remove a file in the next commit, you can use `git rm`! This will both delete the file locally, and in the index.
|
||||
|
||||
If a file is modified, you'll need to reset these changes first/reset the files.
|
||||
|
||||
[setup]
|
||||
|
||||
echo a > a
|
||||
echo x > b
|
||||
echo x > c
|
||||
git add .
|
||||
git commit -m "Initial commit"
|
||||
echo x > a
|
||||
echo b > b
|
||||
git add b
|
||||
|
||||
[win]
|
||||
|
||||
# Make a commit where all files are deleted ¯\_(^_^)_/¯
|
||||
test "$(git ls-tree main | wc -l)" -eq 0
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
compare
|
||||
new
|
||||
change
|
||||
reset
|
||||
steps
|
||||
|
|
@ -1,53 +0,0 @@
|
|||
title = Aggiungere le modifice una per volta
|
||||
cards = add reset-file commit
|
||||
|
||||
[description]
|
||||
|
||||
L'indice è veramente utile perché ci permette di essere precisi su quali cambiamenti vogliamo includere in ogni commit!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Un martello, in equilibrio sul suo manico." > hammer
|
||||
echo "Una bottiglia contenente un liquido trasparente." > bottle
|
||||
echo "Un cubetto di zucchero bianco." > sugar_cube
|
||||
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
[win]
|
||||
|
||||
# Fai dei cambiamenti a tutti e tre gli oggetti per creare una sequenza logica di eventi!
|
||||
test "$(git diff --name-only | wc -l)" -eq 3 || file -f .git/candle-changed && touch .git/candle-changed
|
||||
|
||||
# Aggiungi solo uno dei cambiamenti!
|
||||
test "$(git diff --cached --name-only | wc -l)" -eq 1 || file -f .git/candle-added && touch .git/candle-added
|
||||
|
||||
# E fai un commit
|
||||
COUNT=0
|
||||
for commit in $(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep 'commit$' | cut -f1 -d' '); do
|
||||
if test "$(git diff --name-only $commit $commit^ | wc -l)" -eq 1; then
|
||||
COUNT=$((COUNT+1))
|
||||
fi
|
||||
done
|
||||
|
||||
test "$COUNT" -ge 1
|
||||
|
||||
# Fai un secondo commit che registri solo un singolo cambiamento.
|
||||
COUNT=0
|
||||
for commit in $(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep 'commit$' | cut -f1 -d' '); do
|
||||
if test "$(git diff --name-only $commit $commit^ | wc -l)" -eq 1; then
|
||||
COUNT=$((COUNT+1))
|
||||
fi
|
||||
done
|
||||
|
||||
test "$COUNT" -ge 2
|
||||
|
||||
# E aggiungine un terzo.
|
||||
COUNT=0
|
||||
for commit in $(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep 'commit$' | cut -f1 -d' '); do
|
||||
if test "$(git diff --name-only $commit $commit^ | wc -l)" -eq 1; then
|
||||
COUNT=$((COUNT+1))
|
||||
fi
|
||||
done
|
||||
|
||||
test "$COUNT" -ge 3
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
title = La line di comando
|
||||
cards =
|
||||
|
||||
[description]
|
||||
|
||||
Queste carte da gioco sono state disegnate per essere usate e ricordate facilmente! Ti consigliamo di attenerti a loro se non hai molta esperienza di Git!
|
||||
|
||||
[cli]
|
||||
|
||||
Ma c'è un'altra via per interagire con Git:
|
||||
|
||||
Prova a digitare `git init` nel terminale qui sotto e premere il pulsante Enter!
|
||||
|
||||
[setup]
|
||||
|
||||
rm -rf .git
|
||||
|
||||
[win]
|
||||
|
||||
# Inizializza la macchina del tempo!
|
||||
test -d .git
|
||||
|
||||
[congrats]
|
||||
|
||||
Perfetto! Al posto di usare le carte da gioco, puoi anche fare tutto dalla line di comando!
|
||||
|
||||
La line di comando e piuttosto potente! A volte, puoi usarla per risolvere le attività più velocemente che con l'interfaccia grafica.
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
title = Il tuo primo commit!
|
||||
cards = commit-auto
|
||||
|
||||
[description]
|
||||
|
||||
Puoi usare la tua macchina del tempo per scattare istantanee degli oggetti intorno a te! Qui puoi metterlo in pratica!
|
||||
|
||||
(Il tuo insegnante versa un pò di acqua nel bicchiere)
|
||||
|
||||
[cli]
|
||||
Nuovamente, al posto di usare le carte, puoi scrivere i comandi, che sono stampati sulle carte, nel terminale in basso!
|
||||
|
||||
Questo è totalmente opzionale! Ma questa è una conoscenza super utile nel mondo reale - e ti farà avere un distintivo scintillante! :)
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Il bicchiere è pieno di acqua." > glass
|
||||
|
||||
[win]
|
||||
|
||||
# Crea un'istantanea del bicchiere (un "commit")
|
||||
git rev-parse HEAD
|
||||
|
||||
# Cambia il contenuto del bicchiere!
|
||||
! test "$(cat glass)" = "Il bicchiere è pieno di acqua."
|
||||
|
||||
# E crea un secondo "commit"!
|
||||
git rev-parse HEAD^ && ! test "$(git show main:glass)" = "Il bicchiere è bieno di acqua."
|
||||
|
||||
[congrats]
|
||||
|
||||
Perfetto! Puoi provare a creare altri "commit". Quando ti sentirai a posto, premi su "Next Level".
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
title = Crea una copia
|
||||
cards =
|
||||
|
||||
[description]
|
||||
|
||||
Questa volta, stai facendo molte copie di backup - puoi guardarli cliccandoci sopra!
|
||||
|
||||
[congrats]
|
||||
|
||||
Okay, questo è un modo di lavorare.
|
||||
|
||||
Ma sei preoccupato che ti ritroverai con centinaia di copie di questo modulo e sarà difficile tenerne traccia nel tempo.
|
||||
|
||||
Specialmente quando lavori con altre persone, inviare copie avanti ed indietro non sembra l'ideale.
|
||||
|
||||
Fermati, devi provare questa macchina del tempo!
|
||||
|
||||
[setup]
|
||||
|
||||
rm -rf .git
|
||||
|
||||
echo "~ Perchè voglio imparare Git ~
|
||||
|
||||
(Devo ancora scriverlo.)" >> form.txt
|
||||
|
||||
|
||||
echo "~ Perchè volgio imparare Git ~
|
||||
|
||||
- Così posso annullare gli errori" >> form2.txt
|
||||
|
||||
|
||||
echo "~ Perchè volgio imparare Git ~
|
||||
|
||||
- Così posso annullare gli errori
|
||||
- Per tracciare i mie progetti attraverso il tempo" >> form2_final.txt
|
||||
|
||||
cp form2_final.txt form2_really_final.txt
|
||||
|
||||
[win]
|
||||
|
||||
# Aggiungi una nuova line al file form2_really_final.txt!
|
||||
test "$(cat form2_really_final.txt | wc -l )" -ge 5
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
title = Entra nella machina del tempo
|
||||
cards = init
|
||||
|
||||
[description]
|
||||
|
||||
Sei stato accettato nella scuola della macchina del tempo! Questo è il tuo primo giorno! Il tuo insegnate ti spiega:
|
||||
|
||||
"Per fare qualsiasi cosa con una macchina del tempo, devi prima inizializzarla!"
|
||||
|
||||
Trascina quella carta blu verso l'alto per usarla!
|
||||
|
||||
[setup]
|
||||
|
||||
rm -rf .git
|
||||
|
||||
[win]
|
||||
|
||||
# Inizializzazione della macchina del tempo
|
||||
test -d .git
|
||||
|
||||
[congrats]
|
||||
|
||||
Perfetto! Vedi quel piccolo animale che è apparso? Sarà il tuo compagno e ti mostrerà dove ti trovi nel tempo!
|
||||
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
title = Dai lavoriamo tutti assieme
|
||||
cards = pull commit-auto push
|
||||
|
||||
[description]
|
||||
|
||||
Aggiungi il tuo nome nella nostra lista di studenti!
|
||||
|
||||
Ho già un secondo "commit" nella mia macchina del tempo - Dai lavoriamo tutti assieme!
|
||||
|
||||
[cli]
|
||||
|
||||
Per tornare in dietro alle vecchie istruzioni, puoi premere la freccia in alto o in basso. In questo modo non devi digitare, nuovamente, le istruzioni.
|
||||
|
||||
[congrats]
|
||||
|
||||
Benvenuto nella scuola del viaggio nel tepo! :) Ci vediamo domani per la tua prima lezione!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "~ Lista degli attuali studenti ~" > students
|
||||
git add .
|
||||
git commit -m "Versione iniziale"
|
||||
git push -u teacher main
|
||||
|
||||
git update-ref -d refs/remotes/teacher/main
|
||||
|
||||
[setup teacher]
|
||||
|
||||
git reset --hard main
|
||||
|
||||
echo "
|
||||
- Sam
|
||||
- Alex" >> students
|
||||
|
||||
git add .
|
||||
git commit -m "Aggiunti due studenti"
|
||||
|
||||
[win]
|
||||
|
||||
# Ottieni il secondo "commit" dal tuo insegnante usando `git pull`.
|
||||
test "$(git log --oneline teacher/main | wc -l)" -ge 2
|
||||
|
||||
# Aggiungi il tuo nome alla lista degli studenti.
|
||||
test "$(cat students |wc -l)" -ge 5
|
||||
|
||||
# Crea un'istantanea dei risultati.
|
||||
test "$(git show main:students |wc -l)" -ge 5
|
||||
|
||||
[win teacher]
|
||||
|
||||
# E usa `git push` per inviarlo al tuo insegnante!
|
||||
test "$(git show main:students |wc -l)" -ge 5
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
title = Vivere è pericoloso
|
||||
cards =
|
||||
|
||||
[description]
|
||||
|
||||
Quindi hai deciso di fare domanda per la scuola di viaggio nel tempo, per usare la macchina del tempo chiamata "Git"!
|
||||
|
||||
Che emozione!
|
||||
|
||||
Hai quasi concluso le scartoffie! Devi solamente inserire un motivo per il quale vuoi imparare Git.
|
||||
|
||||
[congrats]
|
||||
|
||||
All'improvviso, il tuo gatto salta sul tavolo, strappa via il modulo, e scappa via! Oh no. Tutto il tuo duro lavoro, andato!
|
||||
|
||||
Devi trovare una buona soluzione.
|
||||
|
||||
(Premi "Prossimo livello" appena sei pronto!)
|
||||
|
||||
[setup]
|
||||
|
||||
rm -rf .git
|
||||
|
||||
echo "~ Perchè voglio imparare Git ~
|
||||
|
||||
- Così posso cancellare gli errori
|
||||
- Per seguire il mio progetto attraverso il tempo" >> form.txt
|
||||
|
||||
[actions]
|
||||
|
||||
test "$(cat form.txt | wc -l )" -ge 5 && echo "(E' stato rubato dal tuo gatto.)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
" > form.txt
|
||||
|
||||
[win]
|
||||
|
||||
# Aggiungi un'altra line a form.txt!
|
||||
test "$(cat form.txt | wc -l )" -ge 5
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
risky
|
||||
copies
|
||||
init
|
||||
cli
|
||||
commit
|
||||
remote
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
title = Benvenuto nella scuola del viaggio nel tempo!
|
||||
cards = config-name commit-auto checkout
|
||||
|
||||
[description]
|
||||
|
||||
Sei ancora confuso da tutto quello che sta succedendo. Il giorno seguente, decidi di iscriverti nella scuola del viaggio nel tempo!
|
||||
|
||||
Il tuo insegnante del viaggio nel tempo ti saluta: "Ciao come va! Vuoi dirci il tuo nome?"
|
||||
|
||||
[setup]
|
||||
|
||||
git config --global user.name "TU"
|
||||
|
||||
echo "~ Chi vuole imparare come si usa la macchina del tempo? ~
|
||||
|
||||
[ ] Per essere sicuro che il mio gatto non mangi il mio lavoro.
|
||||
[ ] Così non devo tenere copie di tutti i miei saggi.
|
||||
[ ] Per collaborare con altri studenti del viaggio nel tempo.
|
||||
[ ] Altro, perfavore specifica:" > form
|
||||
|
||||
[actions]
|
||||
|
||||
test "$(git config user.name)" != "TU" && cat form | grep -v Signature && echo "
|
||||
Firma: $(git config user.name)" >> form
|
||||
|
||||
[win]
|
||||
|
||||
# Presentati.
|
||||
test "$(git config user.name)" != "TU"
|
||||
|
||||
# Compila l'iscrizione e inviala!
|
||||
git show main:form | grep '\[[xX]\]'
|
||||
|
||||
[congrats]
|
||||
|
||||
"Siamo lieti di averti con noi!
|
||||
|
||||
Git puoi aiutarti a correggere i problemi del passato! Ti aiuta a collaborare con gli studenti del viaggio nel tempo! E' davvero potente e e popolare! Ci vediamo domani per la tua prima lezione!"
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
[description]
|
||||
|
||||
For this prototype, we assume you have some experience with the command line. Here are some commands that will be useful:
|
||||
|
||||
- ls
|
||||
- echo content > file
|
||||
- cat file
|
||||
- mkdir dir
|
||||
|
||||
Find the riddle in your current directory and put the answer into the file "answer"!
|
||||
|
||||
[congrats]
|
||||
|
||||
Omnomnom!
|
||||
|
||||
For technical reasons, you can't use `cd` in this prototype yet. But there won't be a lot of interaction with the file system anyways. :)
|
||||
|
||||
[setup]
|
||||
|
||||
mkdir riddle
|
||||
echo "ppl p" > riddle/consonants
|
||||
echo "ae ie" > riddle/vowels
|
||||
|
||||
[win]
|
||||
|
||||
cat answer | grep -i "apple \\?pie"
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
[description]
|
||||
|
||||
At its core, Git is very simple. It stores "objects", which are basically files identified by an "identifier" (short: ID).
|
||||
|
||||
There are four types of objects: blobs, trees, commits, and tags. The simplest type is a "blob", which is just a piece of text.
|
||||
|
||||
Let's create some blobs! To do that, create a file with the desired content, and then use
|
||||
|
||||
git hash-object -w <file>
|
||||
|
||||
The flag -w means "write", and tells Git to actually write the new blob to the disk.
|
||||
|
||||
Create three new blobs!
|
||||
|
||||
[congrats]
|
||||
|
||||
Tip: You can also use a command like this to create a blob in a single line:
|
||||
|
||||
echo "awesome content" | git hash-object -w --stdin
|
||||
|
||||
Did you already notice that you can drag and drop all objects? :)
|
||||
|
||||
[setup]
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo "Hi" > file1
|
||||
echo "Ho" > file2
|
||||
echo "Hu" > file3
|
||||
git hash-object -w file1
|
||||
git hash-object -w file2
|
||||
git hash-object -w file3
|
||||
|
||||
[win]
|
||||
|
||||
BLOB_COUNT=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep blob | wc -l)
|
||||
|
||||
test "$BLOB_COUNT" -gt 2
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
[description]
|
||||
|
||||
There's a simple command to remove all objects that are not referenced by anything:
|
||||
|
||||
git prune
|
||||
|
||||
Remove all blobs in this repository.
|
||||
|
||||
[congrats]
|
||||
|
||||
Generally, `git prune` will be useful if you want to clean up some objects you made.
|
||||
|
||||
Alternatively, you can also click the "Reload" button to restart a level.
|
||||
|
||||
[setup]
|
||||
|
||||
echo "My master password is a1b2c3d4e5" | git hash-object -w --stdin
|
||||
echo "This blob really should not exist" | git hash-object -w --stdin
|
||||
echo "This is a virus" | git hash-object -w --stdin
|
||||
|
||||
[setup goal]
|
||||
|
||||
[win]
|
||||
|
||||
OBJECT_COUNT=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | wc -l)
|
||||
|
||||
test "$OBJECT_COUNT" -eq 0
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
[description]
|
||||
|
||||
So a tree describes a directory structure at a specific point in time.
|
||||
|
||||
It would be nice if we could remember when that state existed, and who authored it, right?
|
||||
|
||||
Enter: commits. They are objects that point to a tree and contain some additional metadata. You can create a commit using
|
||||
|
||||
git commit-tree <tree> -m "Description of your commit"
|
||||
|
||||
Make a commit from the tree in this repository!
|
||||
|
||||
[setup]
|
||||
|
||||
touch empty_file
|
||||
git add .
|
||||
git write-tree
|
||||
|
||||
rm empty_file
|
||||
git update-index --remove empty_file
|
||||
|
||||
[setup goal]
|
||||
|
||||
touch empty_file
|
||||
git add .
|
||||
git write-tree
|
||||
|
||||
rm empty_file
|
||||
git update-index --remove empty_file
|
||||
|
||||
git commit-tree 3185 -m 'Clever commit message'
|
||||
|
||||
[win]
|
||||
|
||||
COMMIT_COUNT=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep commit | wc -l)
|
||||
|
||||
test "$COMMIT_COUNT" -gt 0
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
[description]
|
||||
|
||||
When using the commit-tree command, you can optionally specify a parent:
|
||||
|
||||
git commit-tree <tree> -m "Description" -p <parent commit>
|
||||
|
||||
Make a string of three commits!
|
||||
|
||||
Hint: You'll need a tree object. What could be the easiest way to obtain one?
|
||||
|
||||
[setup]
|
||||
|
||||
[setup goal]
|
||||
|
||||
git write-tree
|
||||
FIRST_COMMIT=$(git commit-tree 4b82 -m 'First commit :O')
|
||||
SECOND_COMMIT=$(git commit-tree 4b82 -p $FIRST_COMMIT -m 'Second commit :D')
|
||||
THIRD_COMMIT=$(git commit-tree 4b82 -p $SECOND_COMMIT -m 'Third commit \o/')
|
||||
|
||||
[win]
|
||||
|
||||
COMMITS=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep commit | cut -f1 -d" ")
|
||||
|
||||
for COMMIT in $COMMITS; do
|
||||
echo a commit named $COMMIT
|
||||
if [ $(git rev-list $COMMIT | wc -l) -ge 3 ]; then
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
|
||||
return 1
|
||||
|
|
@ -1,30 +0,0 @@
|
|||
[description]
|
||||
|
||||
A commit can have multiple parents! You can specify the -p option multiple times, like this:
|
||||
|
||||
git commit-tree <tree> -m "Description" -p <parent1> -p <parent2>
|
||||
|
||||
Build a rhombus shape from commits, where two commits point to the same parent, and then a fourth commit points to both of them.
|
||||
|
||||
[setup]
|
||||
|
||||
[setup goal]
|
||||
|
||||
TREE=$(git write-tree)
|
||||
SOUTH=$(git commit-tree $TREE -m "South")
|
||||
EAST=$(git commit-tree $TREE -m "East" -p $SOUTH)
|
||||
WEST=$(git commit-tree $TREE -m "West" -p $SOUTH)
|
||||
NORTH=$(git commit-tree $TREE -m "Nort" -p $EAST -p $WEST)
|
||||
|
||||
[win]
|
||||
|
||||
COMMITS=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep commit | cut -f1 -d" ")
|
||||
|
||||
for COMMIT in $COMMITS; do
|
||||
# My first parent's parents has to be the same as my second parent's parent.
|
||||
if [ "$(git rev-parse --verify -q $COMMIT^1^)" = "$(git rev-parse --verify -q $COMMIT^2^)" ]; then
|
||||
return 0
|
||||
fi
|
||||
done
|
||||
|
||||
return 1
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
[description]
|
||||
|
||||
Blobs usually represent the content of a file. But on their own, they don't have any metadata, not even a name!
|
||||
|
||||
Git has a very powerful concept to store metadata related to blobs: the index! It's a list that relates blobs to filenames and access permissions.
|
||||
|
||||
The most convenient option to add an entry to the index is via an existing file:
|
||||
|
||||
echo "my content" > file
|
||||
git update-index --add file
|
||||
|
||||
Add three entries to the index! For a bonus challenge: can you add a file that is inside of a directory, like "directory/file"?
|
||||
|
||||
[congrats]
|
||||
|
||||
There's another way to add an entry to the index directly:
|
||||
|
||||
git update-index --add --cacheinfo <mode>,<blobhash>,<name>
|
||||
|
||||
The first three numbers of the mode describe the type of the entry, "100" is a regular file.
|
||||
|
||||
The second three number describe the permissions. Only "644" (non-executable) and "755" (executable) are supported.
|
||||
|
||||
You can insert the hash of an object into the terminal by right-clicking on it! :)
|
||||
|
||||
[setup]
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
echo "file 3" > file3
|
||||
git add .
|
||||
|
||||
[win]
|
||||
|
||||
test "$(git ls-files | wc -l)" -ge 3
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
[description]
|
||||
|
||||
To remove an entry from the index, use a command like this:
|
||||
|
||||
git update-index --force-remove <file>
|
||||
|
||||
Remove all entries from the index!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
echo "file 3" > file3
|
||||
git add .
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
echo "file 3" > file3
|
||||
git add .
|
||||
|
||||
git update-index --force-remove file1
|
||||
git update-index --force-remove file2
|
||||
git update-index --force-remove file3
|
||||
|
||||
[win]
|
||||
|
||||
test "$(git ls-files | wc -l)" -eq 0
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
[description]
|
||||
|
||||
Instead of removing an entry from the index and adding one with the same name, you can also directly update that entry!
|
||||
|
||||
Put the content you want in a file with a matching name, and then run
|
||||
|
||||
git update-index <file>
|
||||
|
||||
This will create a new blob, and update the hash of the entry to that blob.
|
||||
|
||||
Update an entry in the index!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
echo "file 3" > file3
|
||||
git add .
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
echo "file 3" > file3
|
||||
git add .
|
||||
|
||||
echo "new content" > file1
|
||||
git update-index file1
|
||||
|
||||
[win]
|
||||
|
||||
# This is not really a good test for the winning condition...
|
||||
test "$(git ls-files -s | git hash-object --stdin)" != "10c4b28623e7e44e09f5a596450a50ab7ac31fbe" -a "$(git ls-files | wc -l)" -eq 3
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
[description]
|
||||
|
||||
Delete all objects in this repository using git commands only!
|
||||
|
||||
Useful commands:
|
||||
|
||||
git prune
|
||||
git reflog expire
|
||||
|
||||
[setup]
|
||||
|
||||
echo foo > foo
|
||||
BLOB=$(git hash-object -w foo)
|
||||
echo bar > bar
|
||||
git add .
|
||||
git commit -m "Initial commit"
|
||||
echo blabber >> bar
|
||||
git commit -a -m "Second commit"
|
||||
git update-ref refs/important HEAD
|
||||
git update-ref refs/interesting "$BLOB"
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo foo > foo
|
||||
BLOB=$(git hash-object -w foo)
|
||||
echo bar > bar
|
||||
git add .
|
||||
git commit -m "Initial commit"
|
||||
echo blabber >> bar
|
||||
git commit -a -m "Second commit"
|
||||
git update-ref refs/important HEAD
|
||||
git update-ref refs/interesting "$BLOB"
|
||||
|
||||
TREE=$(git mktree)
|
||||
git read-tree $TREE
|
||||
rm -rf .git/refs/*
|
||||
rm -rf .git/objects/*
|
||||
|
||||
[win]
|
||||
|
||||
test "$(git cat-file --batch-check --batch-all-objects | wc -l)" -eq 0
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
[description]
|
||||
|
||||
Create two trees pointing to the same blob!
|
||||
|
||||
[setup]
|
||||
|
||||
[setup goal]
|
||||
|
||||
BLOB=$(echo "I am precious" | git hash-object -w --stdin)
|
||||
git update-index --add --cacheinfo 100644,$BLOB,a
|
||||
git write-tree
|
||||
git update-index --force-remove a
|
||||
git update-index --add --cacheinfo 100644,$BLOB,b
|
||||
git write-tree
|
||||
git update-index --force-remove b
|
||||
|
||||
[win]
|
||||
|
||||
TREES=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep tree | cut -f1 -d" ")
|
||||
|
||||
ALL_TREE_CHILDREN=$(for TREE in $TREES; do
|
||||
git cat-file -p $TREE | cut -f1 | cut -f3 -d" "
|
||||
done)
|
||||
|
||||
NUMBER_OF_CHILDREN=$(echo "$ALL_TREE_CHILDREN" | wc -l)
|
||||
UNIQUE_CHILDREN=$(echo "$ALL_TREE_CHILDREN" | sort -u | wc -l)
|
||||
|
||||
test "$NUMBER_OF_CHILDREN" -gt "$UNIQUE_CHILDREN"
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
[description]
|
||||
|
||||
Construct a chain of three trees, which don't point to anything else.
|
||||
|
||||
This is hard! The `git mktree` command might be useful.
|
||||
|
||||
[setup]
|
||||
|
||||
[setup goal]
|
||||
|
||||
git mktree
|
||||
TREE=$(echo -e "040000 tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904\tdir" | git mktree)
|
||||
echo -e "040000 tree $TREE\tdir" | git mktree
|
||||
|
||||
[win]
|
||||
|
||||
TREES=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep tree | cut -f1 -d" ")
|
||||
|
||||
for TREE in $TREES; do
|
||||
if [ "$(git cat-file -p $TREE | wc -l)" -eq 1 ]; then
|
||||
if [ "$(git cat-file -p $TREE | cut -f1 | grep tree | wc -l)" -eq 1 ]; then
|
||||
# So the tree has exactly one child, and it is a tree!
|
||||
TREE2=$(git cat-file -p $TREE | cut -f1 | grep tree | cut -f3 -d" ")
|
||||
if [ "$(git cat-file -p $TREE2 | wc -l)" -eq 1 ]; then
|
||||
if [ "$(git cat-file -p $TREE2 | cut -f1 | grep tree | wc -l)" -eq 1 ]; then
|
||||
# Same for its child! \o/
|
||||
return 0
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
return 1
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
[description]
|
||||
|
||||
Let's take a look at "refs" (short for "references")! Refs are not objects, but rather very simple *pointers* to objects! They can help you keep track of what's where.
|
||||
|
||||
You can create or update a ref with
|
||||
|
||||
git update-ref refs/<refname> <newvalue>
|
||||
|
||||
Make sure to always start a ref's name with "refs/"! That's a convention that helps Git find all refs you create. If you forget the "refs/", you will not see the ref.
|
||||
|
||||
Create refs that point to all objects in this repository!
|
||||
|
||||
[setup]
|
||||
|
||||
echo hello > hello
|
||||
echo world > world
|
||||
BLOB1=$(git hash-object -w hello)
|
||||
BLOB2=$(git hash-object -w world)
|
||||
git add .
|
||||
TREE=$(git write-tree)
|
||||
COMMIT=$(git commit-tree $TREE -m "Initial commit")
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo hello > hello
|
||||
echo world > world
|
||||
BLOB1=$(git hash-object -w hello)
|
||||
BLOB2=$(git hash-object -w world)
|
||||
git add .
|
||||
TREE=$(git write-tree)
|
||||
COMMIT=$(git commit-tree $TREE -m "Initial commit")
|
||||
|
||||
git update-ref refs/a $BLOB1
|
||||
git update-ref refs/b $BLOB2
|
||||
git update-ref refs/c $TREE
|
||||
git update-ref refs/d $COMMIT
|
||||
|
||||
[win]
|
||||
|
||||
OBJECTS=$(git cat-file --batch-check='%(objectname)' --batch-all-objects | sort)
|
||||
REF_TARGETS=$(git show-ref -s | sort | uniq)
|
||||
test "$OBJECTS" = "$REF_TARGETS"
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
[description]
|
||||
|
||||
You can point refs to a new location using the same command you use to create them:
|
||||
|
||||
git update-ref refs/<refname> <object>
|
||||
|
||||
As an exercise, make all refs in this repository point to the tree object!
|
||||
|
||||
[setup]
|
||||
|
||||
echo hello > hello
|
||||
echo world > world
|
||||
BLOB1=$(git hash-object -w hello)
|
||||
BLOB2=$(git hash-object -w world)
|
||||
git add .
|
||||
TREE=$(git write-tree)
|
||||
COMMIT=$(git commit-tree $TREE -m "Initial commit")
|
||||
|
||||
git update-ref refs/a "$BLOB1"
|
||||
git update-ref refs/b "$COMMIT"
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo hello > hello
|
||||
echo world > world
|
||||
BLOB1=$(git hash-object -w hello)
|
||||
BLOB2=$(git hash-object -w world)
|
||||
git add .
|
||||
TREE=$(git write-tree)
|
||||
COMMIT=$(git commit-tree $TREE -m "Initial commit")
|
||||
|
||||
git update-ref refs/a "$BLOB1"
|
||||
git update-ref refs/b "$COMMIT"
|
||||
|
||||
for REF in $(git for-each-ref --format='%(refname)'); do
|
||||
git update-ref "$REF" "$TREE"
|
||||
done
|
||||
|
||||
[win]
|
||||
|
||||
test "$(git show-ref -s | sort -u)" = "c7863f72467ed8dd44f4b8ffdb8b57ca7d91dc9e"
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
[description]
|
||||
|
||||
And finally, to delete a ref, use
|
||||
|
||||
git update-ref -d refs/<refname>
|
||||
|
||||
Delete all refs! :P (Well, except for HEAD. HEAD is special.)
|
||||
|
||||
[setup]
|
||||
|
||||
echo hello > hello
|
||||
echo world > world
|
||||
BLOB1=$(git hash-object -w hello)
|
||||
BLOB2=$(git hash-object -w world)
|
||||
git add .
|
||||
TREE=$(git write-tree)
|
||||
COMMIT=$(git commit-tree $TREE -m "Initial commit")
|
||||
|
||||
git update-ref refs/best_blob_ever "$BLOB1"
|
||||
git update-ref refs/beautiful_commit "$COMMIT"
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo hello > hello
|
||||
echo world > world
|
||||
BLOB1=$(git hash-object -w hello)
|
||||
BLOB2=$(git hash-object -w world)
|
||||
git add .
|
||||
TREE=$(git write-tree)
|
||||
COMMIT=$(git commit-tree $TREE -m "Initial commit")
|
||||
|
||||
git update-ref refs/best_blob_ever "$BLOB1"
|
||||
git update-ref refs/beautiful_commit "$COMMIT"
|
||||
|
||||
for REF in $(git for-each-ref --format='%(refname)'); do
|
||||
git update-ref -d "$REF"
|
||||
done
|
||||
|
||||
[win]
|
||||
|
||||
test "$(git show-ref | wc -l)" -eq 0
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
welcome
|
||||
basics
|
||||
blob-create
|
||||
blob-remove
|
||||
index-add
|
||||
index-remove
|
||||
index-update
|
||||
tree-create
|
||||
tree-read
|
||||
tree-nested
|
||||
commit-create
|
||||
commit-parents
|
||||
commit-rhombus
|
||||
ref-create
|
||||
ref-move
|
||||
ref-remove
|
||||
symref-create
|
||||
symref-no-deref
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
[description]
|
||||
|
||||
Instead of pointing directly to objects, refs can also point to other refs!
|
||||
|
||||
When that happens, they are called "symbolic refs". You can create or update a symbolic ref using
|
||||
|
||||
git symbolic-ref <name> <ref>
|
||||
|
||||
Create a symbolic ref called "refs/rainbow"!
|
||||
|
||||
[setup]
|
||||
|
||||
[setup goal]
|
||||
|
||||
BLOB=$(git hash-object -w --stdin)
|
||||
git update-ref refs/double "$BLOB"
|
||||
git symbolic-ref refs/rainbow refs/double
|
||||
|
||||
[win]
|
||||
|
||||
git symbolic-ref refs/rainbow
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
[description]
|
||||
|
||||
When you have a symbolic ref (a ref pointing at another ref), and you decide you want it to be a regular ref again (pointing to an object), you're in for some trouble! :)
|
||||
|
||||
What happens when you try pointing the symbolic ref directly to the blob using `git update-ref`?
|
||||
|
||||
Oops! Turns out that when you reference a symbolic ref, it acts as if you had specified the ref it points to. To de-symbolic-ize it, use the `--no-deref` option directly after `update-ref`!
|
||||
|
||||
Weird, huh?
|
||||
|
||||
[congrats]
|
||||
|
||||
Whew, we've covered a lot of things: Blobs! The index! Trees! Commits! Refs!
|
||||
|
||||
You now know about almost everything about how Git repositories look like on the inside! We think that's pretty cool! :)
|
||||
|
||||
Everything else is just convention and high-level commands that make interacting with the objects more convenient.
|
||||
|
||||
We haven't covered:
|
||||
|
||||
- tag objects (they are the fourth object type - a bit like refs with a description and an author)
|
||||
- configuration (allows you to specify remote repositories, for example)
|
||||
- working with local files (which is, uh, arguably pretty important :P)
|
||||
|
||||
Thanks for playing! You're welcome to check out the "puzzle" levels in the dropdown, some of them are more advanced!
|
||||
|
||||
[setup]
|
||||
|
||||
BLOB1=$(echo delicious | git hash-object -w --stdin)
|
||||
BLOB2=$(echo very | git hash-object -w --stdin)
|
||||
git update-ref refs/curly "$BLOB1"
|
||||
git symbolic-ref refs/fries refs/curly
|
||||
|
||||
[setup goal]
|
||||
|
||||
BLOB1=$(echo delicious | git hash-object -w --stdin)
|
||||
BLOB2=$(echo very | git hash-object -w --stdin)
|
||||
git update-ref refs/curly "$BLOB1"
|
||||
git symbolic-ref refs/fries refs/curly
|
||||
|
||||
git update-ref --no-deref refs/fries "$BLOB2"
|
||||
|
||||
[win]
|
||||
|
||||
git symbolic-ref refs/fries && return 1
|
||||
test "$(git show-ref -s refs/fries)" = "035e2968dafeea08e46e8fe6743cb8123e8b9aa6"
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
[description]
|
||||
|
||||
After carefully building the index we want, it would be nice to save a permanent snapshot of it, right?
|
||||
|
||||
This is what the second type of objects is for: trees! You can convert the index into a tree using
|
||||
|
||||
git write-tree
|
||||
|
||||
Try it! :)
|
||||
|
||||
[congrats]
|
||||
|
||||
Nice!
|
||||
|
||||
Can you make a different tree? Modify the index, then call `git write-tree` again!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
echo "file 3" > file3
|
||||
git add .
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
echo "file 3" > file3
|
||||
git add .
|
||||
|
||||
git write-tree
|
||||
|
||||
[win]
|
||||
|
||||
git cat-file -p 21a638f28022064c1f1df20844278b494d197979
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
[description]
|
||||
|
||||
Trees can also point to other trees! This way, they can describe nested directory structures.
|
||||
|
||||
When you add a file inside of a directory to the index, and then call `git write-tree`, it will create a nested tree for the directory, and attach the blob to it.
|
||||
|
||||
To solve this level, build a little stick figure, as shown on the left - a tree that points to two blobs, as well to a tree that points to two blobs.
|
||||
|
||||
[setup]
|
||||
|
||||
[setup goal]
|
||||
|
||||
echo "I'm the left arm" > arm1
|
||||
echo "I'm the right arm" > arm2
|
||||
mkdir hip
|
||||
echo "I'm the left leg" > hip/leg1
|
||||
echo "I'm the right leg" > hip/leg2
|
||||
git add .
|
||||
git write-tree
|
||||
|
||||
[win]
|
||||
|
||||
TREES=$(git cat-file --batch-check='%(objectname) %(objecttype)' --batch-all-objects | grep tree | cut -f1 -d" ")
|
||||
|
||||
for OUTER_TREE in $TREES; do
|
||||
NUMBER_OF_BLOB_CHILDREN=$(git cat-file -p $OUTER_TREE | cut -f2 -d" " | grep blob | wc -l)
|
||||
NUMBER_OF_TREE_CHILDREN=$(git cat-file -p $OUTER_TREE | cut -f2 -d" " | grep tree | wc -l)
|
||||
|
||||
if [ $NUMBER_OF_BLOB_CHILDREN -eq 2 -a $NUMBER_OF_TREE_CHILDREN -eq 1 ]; then
|
||||
TREE_CHILD=$(git cat-file -p $OUTER_TREE | cut -f1 | grep tree | cut -d" " -f3)
|
||||
NUMBER_OF_BLOB_CHILDREN_OF_TREE_CHILD=$(git cat-file -p $TREE_CHILD | cut -f2 -d" " | grep blob | wc -l)
|
||||
if [ $NUMBER_OF_BLOB_CHILDREN_OF_TREE_CHILD -eq 2 ]; then
|
||||
return 0
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
return 1
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
[description]
|
||||
|
||||
As soon as you have some tree objects, you can always read them and set the index exactly to their content! Unsurprisingly, the command is called
|
||||
|
||||
git read-tree <tree>
|
||||
|
||||
For <tree>, you can provide the hash of any tree object - you can right-click one to insert its hash into the terminal!
|
||||
|
||||
Try reading some of the trees in this repository into the index!
|
||||
|
||||
[setup]
|
||||
|
||||
EMPTY_TREE=$(git write-tree)
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
git add .
|
||||
git write-tree
|
||||
|
||||
rm *
|
||||
echo "file A" > fileA
|
||||
echo "file B" > fileB
|
||||
echo "file C" > fileC
|
||||
git add .
|
||||
TRIPLE_TREE=$(git write-tree)
|
||||
|
||||
git read-tree "$EMPTY_TREE"
|
||||
|
||||
[setup goal]
|
||||
|
||||
EMPTY_TREE=$(git write-tree)
|
||||
|
||||
echo "file 1" > file1
|
||||
echo "file 2" > file2
|
||||
git add .
|
||||
git write-tree
|
||||
|
||||
rm *
|
||||
echo "file A" > fileA
|
||||
echo "file B" > fileB
|
||||
echo "file C" > fileC
|
||||
git add .
|
||||
TRIPLE_TREE=$(git write-tree)
|
||||
|
||||
git read-tree "$EMPTY_TREE"
|
||||
|
||||
git read-tree "$TRIPLE_TREE"
|
||||
|
||||
[win]
|
||||
|
||||
test "$(git ls-files | wc -l)" -gt 0
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
[description]
|
||||
|
||||
This is prototype #1 for the Git learning game by @bleeptrack and @blinry. Thanks for checking it out! <3
|
||||
|
||||
You can interact with the repository labelled "yours" by typing Bash commands in the terminal below! The visualization will show you its internal status.
|
||||
|
||||
Let's get started by initializing an empty Git repository in the current directory by typing:
|
||||
|
||||
git init
|
||||
|
||||
[congrats]
|
||||
|
||||
Well done!
|
||||
|
||||
An empty Git repository is... well, quite empty. The only thing that always exists is a reference called "HEAD" - we'll learn what that is later!
|
||||
|
||||
But first, let's look at some basics!
|
||||
|
||||
(Click "Next Level" as soon as you're ready!)
|
||||
|
||||
[setup]
|
||||
|
||||
rm -rf .git
|
||||
|
||||
[setup goal]
|
||||
|
||||
rm -rf .git
|
||||
|
||||
git init
|
||||
|
||||
[win]
|
||||
|
||||
test -d .git
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
title = Contraddizioni
|
||||
cards = checkout commit-auto merge reset-hard
|
||||
|
||||
[description]
|
||||
|
||||
A volte le linee temporali si contraddicono a vicenda.
|
||||
|
||||
Per esempio, in questo caso, un nostro cliente vuole che queste linee temporali siano unite ma hanno mangiato cose differenti in entrambe le linee temporali.
|
||||
|
||||
Prova ad unirle! Noterai che c'è un conflitto! La macchina del tempo ti lascerà decidere come procedere: puoi modificare l'elemento problematico, ti verranno mostrate le parti che vanno in conflitto. Puoi mantenere una delle due versioni o creare una combinazione di entrambe! Poi rimuovi i marcatori >>>, <<<, e === e crea un nuovo commit per finalizare l'unione!
|
||||
|
||||
La tua linea temporale definitiva è "main".
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Si è appena svegliato. È affamato." > sam
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
git checkout -b pancakes
|
||||
echo "Ha fatto colazione con pancakes ai mirtilli e sciroppo d'acero." > sam
|
||||
git add .
|
||||
git commit -m "Pancakes!"
|
||||
|
||||
echo "
|
||||
È al lavoro." >> sam
|
||||
git commit -am "Va al lavoro"
|
||||
|
||||
git checkout -b muesli main
|
||||
echo "Ha fatto colazione con muesli all'avena e fragole." > sam
|
||||
git add .
|
||||
git commit -m "Muesli!"
|
||||
|
||||
echo "
|
||||
È al lavoro." >> sam
|
||||
git commit -am "Va al lavoro"
|
||||
|
||||
git checkout main
|
||||
|
||||
[win]
|
||||
|
||||
# Crea un compromesso tra le due colazioni nel branch "main".
|
||||
git rev-parse main^ && test "$(git rev-parse main^1^^)" = "$(git rev-parse main^2^^)"
|
||||
|
||||
[congrats]
|
||||
|
||||
Yum, questa sembra una buona colazione!
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
title = Unire le linee temporali
|
||||
cards = checkout commit-auto merge
|
||||
|
||||
[description]
|
||||
|
||||
Ecco un trucco per domire un pò più a lungo: svolgi tutte le tue attività mattutine in universi paralleli, e poi uniscile!
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
|
||||
git add .
|
||||
git commit -m "L'inizio"
|
||||
|
||||
echo "Hai una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Compri una baguette"
|
||||
|
||||
echo "Mangi una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Mangi la baguette"
|
||||
|
||||
git checkout HEAD~2
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Hai caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Compri un pò di caffe"
|
||||
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Bevi il caffe.
|
||||
|
||||
Non hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Bevi il caffe"
|
||||
|
||||
git checkout HEAD~2
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Hai una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Compri una ciambella"
|
||||
|
||||
echo "Non hai una baguette.
|
||||
|
||||
Non hai caffe.
|
||||
|
||||
Mangi una ciambella." > you
|
||||
git add .
|
||||
git commit -m "Mangi la ciambella"
|
||||
|
||||
git checkout --detach
|
||||
git branch -D main
|
||||
|
||||
[win]
|
||||
|
||||
# Crea una situazione dove consumi una baguette, un caffe e una ciambella.
|
||||
{ git show HEAD:you | grep "Mangi.*baguette"; } && { git show HEAD:you | grep "Bevi.*caffe"; } && { git show HEAD:you | grep "Mangi.*ciambella"; }
|
||||
|
||||
# Crea (e spostati su) un commit di unione.
|
||||
test "$(git log --pretty=%P -n 1 HEAD | wc -w)" -ge 2
|
||||
|
||||
[congrats]
|
||||
|
||||
Mi chiedo se sei più rilassato quando *dormi* in linee temporali parallele...
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
title = Interrompere un merge
|
||||
cards = checkout commit-auto merge merge-abort
|
||||
|
||||
[description]
|
||||
|
||||
Può capitare che tu voglia unire il contenuto di due commit ma si verifica un conflitto che al momento non vuoi risolvere.
|
||||
|
||||
In queste situazioni, puoi interrompere il merge per riprendere successivamente. Usa
|
||||
git merge --abort
|
||||
mentre sei nel processo di merge.
|
||||
|
||||
Prova a unire i due commit e interrompi la procedura di merge.
|
||||
|
||||
[setup]
|
||||
|
||||
echo "Un nuovo giorno sta iniziando" > you
|
||||
|
||||
git add .
|
||||
git commit -m "Start"
|
||||
|
||||
echo "Stai camminando sulla corsia principale." >> you
|
||||
|
||||
git add .
|
||||
git commit -m "Corsia Principale"
|
||||
|
||||
|
||||
git checkout HEAD~1
|
||||
|
||||
echo "Stai camminando sulla corsia laterale." >> you
|
||||
|
||||
git add .
|
||||
git commit -m "Corsia laterale"
|
||||
|
||||
git checkout HEAD~1
|
||||
|
||||
git branch -D main
|
||||
|
||||
[actions]
|
||||
|
||||
if test -f .git/MERGE_HEAD; then
|
||||
touch .git/secretfile
|
||||
fi
|
||||
|
||||
[win]
|
||||
|
||||
# Hai provato a fare il merge?
|
||||
test -f .git/secretfile
|
||||
|
||||
# Hai interrotto il merge?
|
||||
test -f .git/secretfile && ! test -f .git/MERGE_HEAD && ! git rev-parse HEAD^^
|
||||
|
||||
[congrats]
|
||||
|
||||
Aaah, faremo il merge più tardi...
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
merge
|
||||
conflict
|
||||
merge-abort
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
title = Amici
|
||||
cards = pull push commit-auto checkout
|
||||
|
||||
[description]
|
||||
|
||||
Il tuo amico ha aggiunto un'altra linea alla tua tesi! Prendilo, aggiungine un'altra e reinvialo!
|
||||
|
||||
Fate botta e risposta fino a che non ti ritrovi ad avere cinque linee!
|
||||
|
||||
[setup yours]
|
||||
|
||||
echo "Linea 1" > essay
|
||||
git add .
|
||||
git commit -m "Una linea"
|
||||
|
||||
git push -u friend main
|
||||
|
||||
[setup friend]
|
||||
|
||||
git checkout main
|
||||
echo "Linea 2, gnihihi" >> essay
|
||||
git commit -am "Un'altra linea"
|
||||
|
||||
[actions friend]
|
||||
|
||||
if test "$(git log --oneline | wc -l)" -eq 3; then
|
||||
git reset --hard main # Necessario perché la directory di lavoro non è aggiornata quando viene inviata all'amico
|
||||
echo "Linea 4, blurbblubb" >> essay
|
||||
git commit -am "Linea finale"
|
||||
hint "Oh bene, Ho aggiunto la quarta linea!"
|
||||
fi
|
||||
|
||||
[win]
|
||||
|
||||
# Ricevuto la seconda linea dal tuo amico.
|
||||
git show HEAD:essay | grep gnihihi
|
||||
|
||||
# Ricevuto la quarta linea dal tuo amico.
|
||||
git show HEAD:essay | grep blurbblubb
|
||||
|
||||
[win friend]
|
||||
|
||||
# L'amico ha ricevuto la terza linea da te.
|
||||
test "$(git show HEAD:essay | wc -l)" -ge 3
|
||||
|
||||
# L'amico ha ricevuto la quinta linea da te.
|
||||
test "$(git show HEAD:essay | wc -l)" -ge 5
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
title = Problemi
|
||||
cards = checkout add pull push commit-auto merge
|
||||
|
||||
[description]
|
||||
|
||||
Entrambi, tu ed il tuo amico, avete lavorato sullo stesso file e volete sincronizare!
|
||||
|
||||
[setup yours]
|
||||
|
||||
echo "Il capannone delle bici dovrebbe essere ???" > file
|
||||
git add .
|
||||
git commit -m "inizio"
|
||||
|
||||
git push -u friend main
|
||||
|
||||
echo "Il capannone delle bici dovrebbe essere verde" > file
|
||||
|
||||
[setup friend]
|
||||
|
||||
git checkout main
|
||||
|
||||
echo "Il capannone delle bici dovrebbe essere blu" > file
|
||||
git commit -a -m "versione dell'amico"
|
||||
|
||||
[win]
|
||||
|
||||
# Fai il commit delle tue modifiche locali.
|
||||
test "$(git status -s)" = ""
|
||||
|
||||
[win friend]
|
||||
|
||||
# Quarda il suggerimento dell'amico, trova un compromesso e rimandalo in dietro.
|
||||
git rev-parse main^ && test "$(git rev-parse main^1^)" = "$(git rev-parse main^2^)"
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
friend
|
||||
problems
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
title = Empty sandbox
|
||||
|
||||
[description]
|
||||
|
||||
This is an empty sandbox you can play around in.
|
||||
|
||||
[setup]
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
title = Sandbox with a remote
|
||||
cards = checkout commit-auto pull fetch push
|
||||
|
||||
[description]
|
||||
|
||||
Here's a sandbox with a remote! Try pulling, fetching, or pushing!
|
||||
|
||||
How can you push tags and branches on a remote? How can you delete them again?
|
||||
|
||||
[setup yours]
|
||||
|
||||
echo "Line 1" > essay
|
||||
git add .
|
||||
git commit -m "Initial commit"
|
||||
|
||||
git push -u friend main
|
||||
|
||||
[setup friend]
|
||||
|
||||
git checkout main
|
||||
echo "Line 2" >> essay
|
||||
git commit -am "Another line"
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
empty
|
||||
remote
|
||||
three-commits
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
title = Sandbox with three commits
|
||||
cards = checkout add reset-file checkout-file commit merge rebase
|
||||
|
||||
[setup]
|
||||
|
||||
echo "You wake up." > you
|
||||
git add .
|
||||
git commit -m "The beginning"
|
||||
|
||||
echo "You drink coffee." >> you
|
||||
git commit -am "First things first"
|
||||
|
||||
echo "You hear a knock on the door." >> you
|
||||
git commit -am "Who's there?"
|
||||
|
||||
git branch not_main
|
||||
|
||||
[description]
|
||||
|
||||
Here's a sandbox you can play around in.
|
||||
|
||||
You can use both the playing cards, as well as the terminal. This is a real Git terminal! Fun things to try:
|
||||
|
||||
- Make a commit that merges three timelines together at once!
|
||||
- Create and delete some tags!
|
||||
- Make a timeline that's completely independent of the rest!
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
intro
|
||||
files
|
||||
branches
|
||||
merge
|
||||
index
|
||||
remotes
|
||||
changing-the-past
|
||||
shit-happens
|
||||
workflows
|
||||
bisect
|
||||
stash
|
||||
tags
|
||||
sandbox
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
title = Annullare un cattivo commit
|
||||
cards = reset commit-a
|
||||
|
||||
[description]
|
||||
|
||||
Oh no, abbiamo fatto un cattivo commit! Come possiamo annullare un commit e tornare ad un punto dove poter riprovare?
|
||||
|
||||
La risposta è usare `git reset [commit]` che fa due cose:
|
||||
|
||||
- Reimposta il riferimento (ref) del ramo corrente al commit che hai specificato.
|
||||
- Reimposta l'indice a quel commit.
|
||||
|
||||
Non cambia la tua directory di lavoro in nessun modo, il che significa che dopo puoi provare a rifare il commit che desideri.
|
||||
|
||||
|
||||
[setup]
|
||||
|
||||
echo "1 2 3 4" > numbers
|
||||
git add .
|
||||
git commit -m "commit iniziale"
|
||||
echo "1 2 3 4 5 6 7 8 9 11" > numbers
|
||||
git commit -am "Più numerrrrri"
|
||||
|
||||
[win]
|
||||
|
||||
# Nel primo commit il file numbers contiene i numeri da 1 a 10.
|
||||
test "$(git show main:numbers)" = "1 2 3 4 5 6 7 8 9 10"
|
||||
# Il messaggio di questo commit è "Più numeri".
|
||||
git log -1 --oneline | grep "Più numeri"
|
||||
# Il commit con l'errore si battitura non fa più parte del ramo principale.
|
||||
git log --oneline | grep -v "rrrrr"
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue