mirror/pcottle.learnGitBranching
1
0
Fork 0
mirror of https://github.com/pcottle/learnGitBranching.git synced 2025-08-03 09:35:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #815 from ShardanaSoft/italianTransl

Browse source 
Italian transl
This commit is contained in:
Peter Cottle 2021-03-17 08:04:32 -06:00 • committed by GitHub
commit 493a0c601c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
17 changed files with 1046 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

89
src/levels/advanced/multipleParents.js
View file

@ -20,6 +20,7 @@ exports.level = {
'vi': 'Nhiều cha lắm mẹ',
'sl_SI': 'Več Staršev',
'ta_IN': 'ஒன்றுக்கு மேற்ப்பட்ட துவக்க கிலைகள்',
'it_IT': "Genitori multipli",
"pl": "Wielu rodziców",
},
"hint": {
@ -40,6 +41,8 @@ exports.level = {
'vi': 'Dùng lệnh `git branch bugWork` để tạo nhánh tại vị trí chỉ định',
'sl_SI': 'Uporabi `git branch bugWork` s ciljnim commitom za ustvarjanje manjkajoče reference.',
"ta_IN": "`git branch bugWork` பயன்படுத்தி தேவைப்படும் கமிட்டுடன் இழந்த இணைப்பை உருவாக்குக.",
'it_IT':
"Scrivi `git branch bugWork` con un commit per creare il riferimento mancante.",
"pl": "Użyj `git branch bugWork` na docelowym commicie, aby utworzyć brakującą referencję.",
},
"startDialog": {
@ -1610,5 +1613,91 @@ exports.level = {
}
]
},
'it_IT': {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"### Speficicare i genitori",
"",
"Come il modificatore `~` , anche il modificatore `^` accetta un numero (opzionale) dopo di esso.",
"",
"Invece che specificare il numero di generazioni di cui tornare indietro (come accade con `~`), il modificatore `^` specifica quale genitore seguire partendo da un merge commit (di fusione). Ricorda che i merge commit hanno genitori multipli, quindi il percorso da seguire può essere ambiguo.",
"",
'Git normalmente sege il primo genitore partendo da un merge commit, ma specificando un numero con `^` cambia questo comportamento predefinito.',
"",
"Basta parlare, vediamolo in azione.",
"",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Qui abbiamo un merge commit. Se facciamo checkout `main^` senza modificatore, seguiremo il primo genitore dopo il merge commit. ",
"",
"(*Nell'immagine, il primo genitore è situato direttamente al di sopra al merge commit.*)",
],
afterMarkdowns: ["Facile -- questo è quello a cui siamo abituati."],
command: "git checkout main^",
beforeCommand:
"git checkout HEAD^; git commit; git checkout main; git merge C2",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Ora invece proviamo a specificare il secondo genitore...",
],
afterMarkdowns: ["Vedi? Abbiamo seguito il secondo genitore verso l'alto."],
command: "git checkout main^2",
beforeCommand:
"git checkout HEAD^; git commit; git checkout main; git merge C2",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"I modificatori `^` e `~` riescono a farci muovere lungo l'albero dei commit in modo agevole:",
],
afterMarkdowns: ["Super veloce!"],
command:
"git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
beforeCommand:
"git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Ancora più sorprendente, questi modificatori possono essere concatenati tra loro! Dai un occhiata:",
],
afterMarkdowns: [
"Stessi passaggi di prima, ma tutto con un comando.",
],
command: "git checkout HEAD~^2~2",
beforeCommand:
"git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"### Mettilo in pratica",
"",
"Per completare questo livello, crea un nuovo ramo alla destinazione specificata.",
"",
"Sarebbe facile specificare il commit direttamente (con qualcosa del tipo `C6`), ovvio, ma ti sfido invece a utilizare i modificatori di cui abbiamo parlato!",
],
},
},
],
},
}
};

98
src/levels/intro/branching.js
View file

@ -19,6 +19,7 @@ exports.level = {
"vi": "Rẽ nhánh với Git",
"sl_SI": "Branchanje v Gitu",
"pl" : "Rozgałęzienia w GIT-cie (branch)",
'it_IT': "Creare rami in Git",
"ta_IN": "கிட் கிளை நிருவாகம்"
},
"hint": {
@ -39,6 +40,8 @@ exports.level = {
"vi": "Tạo một nhánh mới với lệnh \"git branch <ten-nhanh>\" và chuyển sang đó với lệnh \"git checkout <ten-nhanh>\"",
"sl_SI": "Naredi nov branch z \"git branch [ime-brancha]\" in ga checkoutaj z \"git checkout [ime-brancha]\"",
"pl" : "Utwórz nowy branch za pomocą \"git branch <branch-name>\" i sprawdź ją za pomocą \"git checkout <branch-name>\"",
'it_IT':
'Crea un nuovo ramo con "git branch <branch-name>" and selezionalo con "git checkout <branch-name>"',
"ta_IN": "இப்போது \"git branch <branch-name>\" கட்டளையை கொண்டு புதிய கிளை ஒன்றை உருவாக்குக பின் \"git checkout <branch-name>\" கொண்டு அந்த கிளைக்கு தாவுக"
},
"disabledMap": {
@ -1505,6 +1508,99 @@ exports.level = {
}
}
]
}
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Rami Git",
"",
"Anche i rami in Git sono incredibilmenteare leggeri. Sono semplicemente puntatori a uno specifico commit -- nulla di più. Questo è il motivo per cui gli appassionati di Git predicano:",
"",
"```",
"ramifica presto, e ramifica spesso",
"```",
"",
"Perché non c'è un sovraccarico della memoria nel fare molti rami, è più semplice suddividere il lavoro piuttosto che avere rami enormi.",
"",
'Quando iniziamo a mischiare rami e commit, vedremo come queste caratteristiche si combinano. Per ora però, ricorda che un ramo essenzialmente dice "Voglio includere il lavoro di questo commit e tutti i commit del genitore."',
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Vediamo nella pratica cosa sono i rami.",
"",
"Qui creeremo un nuovo ramo di nome `newImage`.",
],
afterMarkdowns: [
"Ecco, questa è la divisione in rami! Il ramo `newImage` ora punta al commit `C1`.",
],
command: "git branch newImage",
beforeCommand: "",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Proviamo ad aggiungere un po di lavoro su questo nuovo ramo. Premi il pulsante qua sotto.",
],
afterMarkdowns: [
"Oh no! Il ramo `main` si è spostato ma il ramo `newImage` no! Questo perché non eravamo sul nuovo ramo, infatti l'asterisco (*) era su `main`.",
],
command: "git commit",
beforeCommand: "git branch newImage",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Diciamo a Git che vogliamo selezionare il ramo con",
"",
"```",
"git checkout <name>",
"```",
"",
"Questo ci metterà sul nuovo ramo prima di fare un nuovo commit.",
],
afterMarkdowns: [
"Ecco qua! I cambiamenti sono stati memorizzati sul nuovo ramo.",
],
command: "git checkout newImage; git commit",
beforeCommand: "git branch newImage",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"*Nota: In Git versione 2.23, è stato introdotto un nuovo comando, `git switch`, per sostituire `git checkout`, ",
"che è sovraccaricato di funzionalità (fa un sacco di cose diverse). Queste lezioni usano comunque ",
"`checkout` invece che `switch` perché molti non hanno ancora accesso a `switch`, ma quest'app supporta comunque il comando ",
'se sei curioso di provarlo! Potete <a href="https://git-scm.com/docs/git-switch" target="_blank">scoprire di piu qui</a>.* ',
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Ok! Ora sei pronto a lavorare con i rami. Dopo che questa finestra si chiude,",
"crea un nuovo ramo `bugFix` e passa su quel ramo.",
"",
"Comunque, c'è una scorciatoia: se vuoi creare un nuovo ",
"ramo E selezionarlo in un solo passaggio, puoi semplicemente ",
"digitare `git checkout -b [yourbranchname]`.",
],
},
},
],
},
}
};

75
src/levels/intro/merging.js
View file

@ -19,6 +19,7 @@ exports.level = {
"vi": "Gộp nhánh trong Git",
"sl_SI": "Merganje v Gitu",
"pl" : "Łączenie/Scalanie w GIT (merge)",
'it_IT': "Fusione in Git",
"ta_IN": "கிட்டில் இணைத்தல்"
},
"hint": {
@ -39,6 +40,8 @@ exports.level = {
"vi": "Nhớ là commit theo đúng thứ tự(bugFix trước main)",
"sl_SI": 'Zapomni si, da je potrebno commitati v pravilnem vrstnem redu (bugfix pred main)',
"pl" : "Pamiętaj, aby commit-ować w określonej kolejności (bugFix przed main)",
"it_IT":
"Ricorda di effettuare i commit nell'ordine specificato (bugFix prima di main)",
"ta_IN": "bugFix முன் main என்ற கொடுக்கப்பட்ட வரிசையில் கட்டலை இடுவதை கருத்தில் கொள்க"
},
"disabledMap": {
@ -1286,6 +1289,76 @@ exports.level = {
}
}
]
}
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Rami e fusione",
"",
"Ottimo! Ora sappaimo come funzionano i commit e i rami. Adesso dobbiamo trovare il modo per unire il lavoro di due rami diversi. Questo ci permetterà di creare un nuovo ramo, aggiungere una nuova funzionalità, e poi riunire il tutto.",
"",
'Il primo metodo che vediamo per unire il lavoro è `git merge` (fusione). La fusione in Git crea un commit speciale che possiede due genitori distinti. Un commit con due genitori significa "Voglio unire tutto il lavoro da questo e da quest altro genitore, *e anche* di tutti i loro genitori."',
"",
"E' più semplice con le immagini, vediamolo nella prossima schermata.",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
'Qui abbiamo due rami; ognuno di essi ha un commit univoco. Ciò significa che nessuno dei rami contiene per intero il "lavoro" del repository. Sistemiamo le cose con una fusione.',
"",
"Ora facciamo `merge` del ramo `bugFix` nel `main`.",
],
afterMarkdowns: [
"WOW! Visto? Prima di tutto, `main` ora punta a un commit con due genitori. Se ripercorri l'albero dei commit dal `main`, potrai attraversare tutti i commit fino alla radice (root). Questo significa che `main` ora contiene tutto il lavoro del repository.",
"",
"Hai visto come è cambiato il colore del commit è cambiato? Per imparare più facilmente, ho aggiunto i colori. Ogni ramo ha un colore univoco. Ogni (merge) commit ha un colore che è la combinazione dei colori dei rami che lo compongono.",
"",
"Qui vediamo che il colore del ramo `main` è la combinazione di tutti i commit , ma il colore di `bugFix` è diverso. Sistemiamolo...",
],
command: "git merge bugFix",
beforeCommand:
"git checkout -b bugFix; git commit; git checkout main; git commit",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: ["Fondiamo `main` in `bugFix`:"],
afterMarkdowns: [
"Visto che `bugFix` era un antenato di `main`, git non ha dovuto fare nulla di che; ha semplicemente spostato `bugFix` sullo stesso commit in cui era collegato `main`.",
"",
"Ora tutti i commit hanno lo stesso colore, il che significa che ogni ramo contiene tutti il lavoro del repository! WoWoWoW!",
],
command: "git checkout bugFix; git merge main",
beforeCommand:
"git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Per completare questo livello, esegui i seguenti passaggi:",
"",
"* Crea un nuovo ramo di nome `bugFix`",
"* Seleziona il ramo `bugFix` con il comando `git checkout bugFix`",
"* Esegui un commit",
"* Ritorna al ramo `main` con `git checkout`",
"* Esegui un nuovo commit",
"* Fondi il ramo `bugFix` nel `main` con `git merge`",
"",
'*Ricorda, puoi sempre rivedere questa schermata digitando "objective"!*',
],
},
},
],
},
}
};

72
src/levels/intro/rebasing.js
View file

@ -18,6 +18,7 @@ exports.level = {
"uk": "Знайомство з rebase",
"vi": "Giới thiệu về rebase",
'sl_SI': 'Uvod v Rebase',
'it_IT': "Introduzione al rebase (ribasare)",
"pl" : "Wprowadzenie do Rebase"
},
"hint": {
@ -37,6 +38,7 @@ exports.level = {
"uk": "Впевнись, що зробив коміт в гілці bugFix",
"vi": "Hãy chắc chắn rằng bạn commit từ bugFix trước",
'sl_SI': 'Prepričaj se, da si najprej commital bugFix.',
'it_IT': "Assicurati di fare prima il commit da bugFix",
"pl" : "Upewnij się, że masz commit z bugFix"
},
"disabledMap": {
@ -1183,6 +1185,74 @@ exports.level = {
}
}
]
}
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Git Rebase",
"",
'Il secondo modo per unire il lavoro tra rami è il *rebasing* (ribasare). Quando si ribasa vengono presi una serie di commit, vengono "copiati", e incollati da qualche parte.',
"",
"Anche se sembra un sistema complesso, il vantaggio del rebasing è che può essere usato per creare una sequenza lineare di commit. Il log / storia dei commit del repository sarebbe molto più ordinata e comprensibile se fosse consentito solo il rebasing.",
"",
"Vediamolo in azione...",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Anche qui abbiamo ancora due rami; prestate attenzione al fatto che il ramo selezionato è bugFix (notare l'asterisco*)",
"",
"Ora vogliamo spostare il nostro lavoro dal ramo bugFix direttamente sul ramo main. In questo modo sembrerà che i due lavori sono stati sviluppati in sequenza, quando in realtà sono stati sviluppati in parallelo.",
"",
"Vediamo il comando `git rebase` all'opera.",
],
afterMarkdowns: [
"Fantastico! Ora il lavoro del ramo bugFix è sopra al main e abbiamo una sequenza lineare di commit.",
"",
'Nota che il commit C3 continua ad esistere (messo in trasparenza), e C3\' è la "copia" che abbiamo ribasato sul main.',
"",
"L'unico problema è che il main non è ancora stato aggiornato, facciamolo ora...",
],
command: "git rebase main",
beforeCommand: "git commit; git checkout -b bugFix C1; git commit",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Ora il ramo selezionato è il main. Procediamo e facciamo rebase su `bugFix`...",
],
afterMarkdowns: [
"Ecco qua! Visto che main era un antenato di `bugFix`, git sposta semplicemente il riferimento al ramo `main` branch in avanti.",
],
command: "git rebase bugFix",
beforeCommand:
"git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Per completare questo livello, esegui i seguenti passaggi",
"",
"* Crea un nuovo ramo di nome `bugFix`",
"* Crea un commit",
"* Torna al main e crea un nuovo commit",
"* Seleziona nuovamente bugFix e fai rebase sul main",
"",
"In bocca al lupo!",
],
},
},
],
},
}
};

68
src/levels/mixed/describe.js
View file

@ -18,6 +18,7 @@ exports.level = {
"uk" : "Git Describe",
"vi": "Git Describe(mô tả)",
"sl_SI": "Git Describe",
"it_IT": "Git Describe",
"pl": "Git Describe"
},
"hint": {
@ -36,6 +37,7 @@ exports.level = {
"uk" : "Просто зроби один коміт в bugFix коли ти будеш готовий іти далі",
"vi": "Đơn giản là hãy commit một lẩn ở bugFix là xong rồi",
"sl_SI": "Commitaj enkrat na bugFix, ko boš pripravljen za nadaljevanje.",
"it_IT": "Fai un commit da bugFix per procedere",
"pl": "Zcommituj raz na bugFix kiedy jesteś gotowy, aby przejść dalej",
},
"startDialog": {
@ -1050,6 +1052,70 @@ exports.level = {
}
}
]
}
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"### Git Describe",
"",
'Visto che i tag fungono da "ancore", si può usare il comando `git describe` per capire dove ci si trova in riferimento all\'"ancora" (tag) più vicina!',
"",
"Git describe aiuta ad orientarti dopo che hai creato molti commit su per giù nell'albero; oppure dopo che hai concluso un git bisect (per ricercare bug) o quando utilizzi il computer di un collega che è appena tornato dalle vacanze.",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Git describe ha questa forma:",
"",
"`git describe <ref>`",
"",
"Dove `<ref>` è qualunque cosa che può indicare un commit. Se non specifichi un ref, git farà riferimento alla tua posizione attuale (`HEAD`).",
"",
"L'output del comando sarà:",
"",
"`<tag>_<numCommits>_g<hash>`",
"",
"Dove `tag` è il tag antenato più vicino, `numCommits` corrisponde al numero di commit tra ref e il tag, e `<hash>` è l'hash del commit che è descritto.",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Vediamo un esempio semplice. In quest'albero:",
],
afterMarkdowns: [
"Il comando `git describe main` genera come output:",
"",
"`v1_2_gC2`",
"",
"Mentre `git describe side` genererà:",
"",
"`v2_1_gC4`",
],
command: "git tag v2 C3",
beforeCommand:
"git commit; go -b side HEAD~1; gc; gc; git tag v1 C0",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Questo è più o meno quanto fa git describe! Prova questo comando in vari punti in questo livello per prendere confidenza.",
"",
"Quando hai finito, procedi e crea un commit per concludere il livello. Consideralo un omaggio della casa :P",
],
},
},
],
},
}
};

41
src/levels/mixed/grabbingOneCommit.js
View file

@ -29,6 +29,7 @@ exports.level = {
"uk": "Вибираємо всього один коміт",
"vi": "Chỉ lấy 1 commit",
"sl_SI": "Izbiranje Samo Enega Commita",
"it_IT": "Prendi solo 1 Commit",
"pl": "Wzięcie tylko 1 commita",
},
"hint": {
@ -47,6 +48,7 @@ exports.level = {
"uk": "Не забувай, що інтерактивний rebase та cherry-pick -- це твої друзі!",
"vi": "Hãy nhớ 2 anh bạn tương tác rebase và cherry-pick!",
"sl_SI": "Pomni, interaktivni rebase ali cherry-pick sta tu tvoja prijatelja.",
"it_IT": "Ricorda, rebase interattivo o cherry-pick sono tuoi amici",
"pl": "Pamiętaj, interaktywny rebase oraz cherry-picking są tu twoimi przyjaciółmi",
},
"startDialog": {
@ -674,5 +676,44 @@ exports.level = {
}
]
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Commit impilati localmente",
"",
"Ecco una situazione che accade spesso in fase di sviluppo: Sto cercando di scovare un bug. Per aiutarmi nel mio lavoro di detective, inserisco alcuni comandi per il debug e alcune print per fare stampe.",
"",
"Questi comandi aggiunti per il debug vengono salvati con un commit loro dedicato. Finalmente riesco a beccare il bug, sistemo il tutto, e brindo!",
"",
"Ora l'unico problema è che devo salvare il lavoro di `bugFix` nel ramo `main`. Se eseguo un semplice fast-forwarded `main`, allora il `main` andrebbe a prendere anche tutto ciò che è stato aggiunto per il debug. Se solo ci fosse un altro modo...",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Dobbiamo dire a Git di fare la copia di un solo commit. Questo assomiglia a quanto visto in precedenza -- possiamo riusare gli stessi comandi:",
"",
"* `git rebase -i`",
"* `git cherry-pick`",
"",
"Per raggiungere l'obiettivo.",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Questo è un livello più avanzato, lascerò a te la libertà di decidere quale comando usare, ma per concludere il livello, assicurati che `main` riceva il commit puntato da `bugFix`.",
],
},
},
],
},
}
};

38
src/levels/mixed/jugglingCommits.js
View file

@ -33,6 +33,7 @@ exports.level = {
"uk": "Жонглюємо комітами",
"vi": "Tung hứng commit",
"sl_SI": "Žongliranje s Commiti",
"it_IT": "Giocoliere di Commit",
"pl": "Żonglowanie commitami",
},
"hint": {
@ -51,6 +52,7 @@ exports.level = {
"uk": "Перша команда має бути git rebase -i HEAD~2",
"vi": "Lệnh đầu tiên là git rebase -i HEAD~2",
"sl_SI": "Prvi ukaz je git rebase -i HEAD~2.",
"it_IT": "Il primo comando è git rebase -i HEAD~2",
"pl": "Pierwszą komendą jest git rebase -i HEAD~2",
},
"startDialog": {
@ -601,6 +603,40 @@ exports.level = {
}
}
]
}
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Giocoliere di commit",
"",
"Ecco una situazione che capita spesso. Hai dei cambiamenti (`newImage`) e un altro insieme di modifiche (`caption`) che sono collegate tra loro, quindi sono posizionate una dopo l'altra nel repository.",
"",
"La cosa complicata è che a volte hai bisogno di fare una piccola modifica a un commit precedente. In questo caso, dobbiamo apporre una modifica a `newImage`, anche se questo commit non risulta essere l'ultimo!!",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Supereremo queste difficoltà facendo i seguenti passaggi:",
"",
"* Riordineremo i commit in modo che quello che vogliamo modificare risulti l'ultimo con `git rebase -i`",
"* Faremo `git commit --amend` per apporre la modifica",
"* Riordineremo i commit nello stesso ordine in cui erano, sempre con `git rebase -i`",
"* Alla fine, sposteremo main in questo ramo aggiornato dell'albero per finire il livello (utilizzate il metodo che volete)",
"",
"Ci sono vari modi per raggiungere l'obbiettivo finale (vedo che strizzi l'occhio verso cherry-pick), e ne vedremo altri più tardi, ma per ora concentriamoci su questa tecnica.",
"In fine, presta attenzione all'obiettivo -- visto che spostiamo i commit due volte, a entrambi viene messo un apostrofo. Un ulteriore apostrofo è aggiunto per il commit --amend, che completa in fine l'albero.",
"",
"Detto questo, posso confrontare i livelli in base alla struttura e i relativi apostrofi. Finchè il tuo ramo `main` avrà la stessa struttura con i giusti apostrofi, ti darò pieni voti.",
],
},
},
],
},
}
};

46
src/levels/mixed/jugglingCommits2.js
View file

@ -32,6 +32,7 @@ exports.level = {
"uk": "Жонглюємо комітами #2",
"vi": "Tung hứng commit #2",
"sl_SI": "Žongliranje s Commiti #2",
"it_IT": "Giocoliere di commit #2",
"pl": "Żonglowanie commitami #2",
},
"hint": {
@ -50,6 +51,8 @@ exports.level = {
"uk": "Не забудь перемістити main на останні зміни!",
"vi": "Đừng quên đẩy nhánh main lên cập nhật mới nhất!",
"sl_SI": "Ne pozabi prestaviti main naprej na posodobljene spremembe.",
"it_IT":
"Non dimenticare di avanzare il main verso le ultime modifiche aggiornate!",
"pl": "Nie zapomnij zforwardować maina do najnowszych zmian!",
},
"startDialog": {
@ -735,5 +738,48 @@ exports.level = {
}
]
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Giocoliere di commit #2",
"",
"*Se non hai completato Giocoliere di commit #1 (il livello precedente), sei pregato di farlo prima di proseguire*",
"",
"Come hai visto nell'ultimo livello, abbiamo usato `rebase -i` per riordinare i commit. Una volta che il commit che volevamo modificare era in cima, abbiamo potuto facilmente fare --amend per poi ritornare nell'ordine di partenza.",
"",
"L'unico problema qui è che ci sono tanti riordini da fare, che può portare a conflitti nel rebase. Vediamo di farlo attraverso il metodo `git cherry-pick`.",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Ricorda che git cherry-pick creerà un qualsiasi commit del repository su HEAD (a condizione che il commit non sia un antenato di HEAD).",
"",
"Qui un breve demo per rinfrescare la memoria:",
],
afterMarkdowns: ["Grande! Andiamo avanti."],
command: "git cherry-pick C2",
beforeCommand:
"git checkout -b bugFix; git commit; git checkout main; git commit",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"In questo livello, dobbiamo fare amend di `C2` una volta, evitando di usare `rebase -i`. Lascerò a te il compito di scoprire come farlo! :D",
"",
"Ricorda, il numero esatto di apostrofi sul commit non sono importanti, solo le differenze tra essi. Per esempio, considererò l'albero che corrisponde a quello della soluzione ma che ha un apostrofo extra dappertutto.",
],
},
},
],
},
}
};

55
src/levels/mixed/tags.js
View file

@ -18,6 +18,7 @@ exports.level = {
"uk" : "Git Tags",
"vi" : "Tag trong Git",
"sl_SI": "Git Tagi",
"it_IT": "Git Tag",
"pl": "Git Tagi",
},
"hint": {
@ -36,6 +37,8 @@ exports.level = {
"uk" : "ти можеш або зробити checkout коміта напряму чи просто зачекаутити таг!",
"vi" : "Bạn có thể chuyển trực tiếp sang commit hoặc đơn giản là chuyển sang tag!",
"sl_SI": "Checkoutaš lahko neposredno commit ali pa preprosto njegov tag!",
"it_IT":
"Puoi fare direttamente checkout del commit o semplicemente del tag!",
"pl": "Możesz checkoutować commit bezpośrednio lub po prostu tag!",
},
"startDialog": {
@ -871,5 +874,57 @@ exports.level = {
}
]
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Git Tag",
"",
"Come hai già imparato nelle lezioni precedenti, i rami sono facili da spostare e puntano a commit differenti man mano che il lavoro avanza. I rami subiscono modifiche, spesso temporaneamente, ma sono sempre in continua evoluzione.",
"",
"Ti starai chedendo se esiste un modo *definitivo* per segnare un particolare commit del repository. Nel caso di release importanti e grandi merge (fusioni), esiste un modo per segnare questi commit con qualcosa di più permanente dei rami?",
"",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
'Ci puoi scommettere! Git tags serve proprio a questo -- i tag contrassegnano in modo permanente dei commit "importanti" a cui puoi far riferimento come avviene con i rami.',
"",
'Ancora più importante il fatto che non si spostano anche se vengono eseguiti nuovi commit. Non puoi selezionare un tag e aggiungere del lavoro su quel tag -- i tag esistono come ancore nell\'albero dei commit, e si riferiscono a determinati punti.',
"",
"Vediamo in pratica a cosa servono i tag.",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Creiamo un tag in `C1` che è la nostra versione 1 del prototipo.",
],
afterMarkdowns: [
"Ecco! Abbastanza facile. Abbiamo creato il tag `v1` che si riferisce al solo commit `C1`. Se non specifichi il commit, git creera il tag sul commit puntato da `HEAD`.",
],
command: "git tag v1 C1",
beforeCommand: "git commit",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"In questo livello riproduci gli stessi tag mostrati nell'obbiettivo, e alla fine seleziona il tag `v1`. Presta attenzione a come vai nello stato di detached `HEAD` -- questo perché non puoi creare commit direttamente dal tag `v1.",
"",
"Nel livello successivo vedremo un utilizzo più interessante dell'uso dei tag.",
],
},
},
],
},
}
};

60
src/levels/rampup/cherryPick.js
View file

@ -22,6 +22,7 @@ exports.level = {
"uk": "Знайомство з cherry-pick",
"vi" : "Giới thiệu về cherry-pick",
"sl_SI": "Uvod v Cherry-pick",
"it_IT": "Introduzione al cherry-pick",
"pl": "Wprowadzenie do Cherry-pick'ingu"
},
"hint": {
@ -40,6 +41,7 @@ exports.level = {
"uk": "git cherry-pick базується на іменах комітів!",
"vi" : "git cherry-pick sau đó là tên commit!",
"sl_SI": "git cherry-pick nato pa imena commitov.",
"it_IT": "git cherry-pick seguito dai nomi dei commit!",
"pl": "git cherry-pick a po nim nazwy commitów!",
},
"startDialog": {
@ -954,5 +956,63 @@ exports.level = {
}
]
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Spostare il lavoro in giro",
"",
"Fino a ora abbiamo intravisto le basi di git -- creazione di commit, rami, e come spostarsi sull'albero dei commit. Questi concetti sono sufficienti per sfruttare il 90% della potenza di git, e soddisfano gli utilizzi standard degli sviluppatori.",
"",
'Il restante 10%, può rivelarsi utile in situazioni più complesse (o se ti sei messo nei guai). Il prossimo concetto che affronteremo è lo "spostare il lavoro in giro" -- in altre parole, è un modo per gli sviluppatori di dire "Voglio questo lavoro qua e quel lavoro la" in maniera chiara e precisa.',
"",
"Sembra un grosso lavoro, ma è un concetto semplice.",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"## Git Cherry-pick",
"",
"Il primo comando si chiama `git cherry-pick`. Il comando ha il seguente aspetto:",
"",
"* `git cherry-pick <Commit1> <Commit2> <...>`",
"",
"E' un modo chiaro e diretto di dire che vuoi la copia di una serie di commit da applicare sulla posizione in cui ti trovi attualmente (`HEAD`). Io personalmente adoro `cherry-pick` perché e semplice e facile da capire.",
"",
"Vediamo una demo!",
"",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"In questo repository abbiamo del lavoro nel ramo `side` che vogliamo copiare nel `main`. Questo può essere eseguito tramite rebase (che abbiamo già imparato), ma vediamo il cherry-pick all'opera.",
],
afterMarkdowns: [
"Ecco qua! Volevamo i commit `C2` and `C4` e git gli ha copiati sotto di noi. Semplicissimo!",
],
command: "git cherry-pick C2 C4",
beforeCommand:
"git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Per completare questo livello, copia il lavoro dai tre rami sul main. Puoi vedere quali sono i commit richiesti guardando l'obbiettivo.",
"",
],
},
},
],
},
}
};

80
src/levels/rampup/detachedHead.js
View file

@ -18,6 +18,7 @@ exports.level = {
"uk": "Втрачаємо голову чи detached HEAD",
'vi': "Tháo đầu cái nào",
"sl_SI": "Ločevanje tvoje glave - HEAD-a",
"it_IT": "Perdere la testa (HEAD)",
"pl" : "Odczep swój HEAD"
},
"hint": {
@ -36,6 +37,7 @@ exports.level = {
"uk": "Орієнтуйся по індентифікаторам (hash) комітів.",
"vi": "Dùng mã băm (hash) của commit để hoàn thành!",
"sl_SI": "Uporabi oznako (hash) commita za pomoč!",
"it_IT": "Usa l'etichetta (hash) sul commit per aiutarti!",
"pl": "Wpisz (hash) w wiadomości commita aby uzyskać pomoc!",
},
"startDialog": {
@ -1282,6 +1284,82 @@ exports.level = {
}
}
]
}
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Spostarsi in Git",
"",
"Prima di imparare comandi avanzati in Git, è fondamentale conoscere i diversi modi per spostarsi nell'albero dei commit che costituiscono il tuo progetto.",
"",
"Una volta che ti sentirai a tuo agio, il potere con gli altri comandi git sarà amplificato!",
"",
"",
"",
"",
"",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"## HEAD",
"",
"Prima di tutto dobbiamo parlare di \"HEAD\". HEAD (testa) è il nome simbolico dato al commit selezionato -- in pratica è il commit su cui stai lavorando.",
"",
"HEAD punta sempre al commit più recente. La maggiorparte dei commandi git che fanno cambiamenti all'albero dei commit, faranno cambiamento a HEAD.",
"",
"Di norma HEAD punta al nome di un ramo (per esempio bugFix). Quando esegui un commit, lo stato di bugFix viene modificato, e questo cambiamento è visibile attraverso HEAD.",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Vediamolo in azione. Qui mostreremo HEAD prima e dopo un commit.",
],
afterMarkdowns: [
"Visto! HEAD era nascosto sotto il ramo `main`.",
],
command:
"git checkout C1; git checkout main; git commit; git checkout C2",
beforeCommand: "",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"### Detaching HEAD (testa distaccata)",
"",
"Detaching HEAD significa attaccare la testa a un commit invece che a un ramo. All'inizio la situazione è questa:",
"",
"HEAD -> main -> C1",
"",
],
afterMarkdowns: ["E ora è", "", "HEAD -> C1"],
command: "git checkout C1",
beforeCommand: "",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Per completare questo livello, stacchiamo HEAD da `bugFix` e attacchiamolo a un commit.",
"",
"Per specificare un commit si usa l'hash. L'hash per ogni commit è presente sul cerchio che rappresenta il commit.",
],
},
},
],
},
}
};

71
src/levels/rampup/interactiveRebase.js
View file

@ -22,6 +22,8 @@ exports.level = {
"uk" : "ти можеш використовувати гілки чи відносні посилання (HEAD~) щоб вказувати ціль для rebase",
"vi": "bạn có thể sử dụng tham chiếu tương đối (HEAD~) hoặc nhánh để chỉ định mục tiêu rebase",
"sl_SI": "Uporabiš lahko bilokateri branch ali relativno referenco (HEAD~), da določiš cilj za rebase.",
"it_IT":
"Puoi usare sia i rami o i riferimenti relativi (HEAD~) per specificare l'obbiettivo del rebase",
"pl": "Możesz użyć gałęzi lub referencji względnych (HEAD~), aby określić cel rebase'a"
},
"name": {
@ -40,6 +42,7 @@ exports.level = {
"uk" : "Знайомство з інтерактивним rebase",
"vi" : "Giới thiệu về tương tác rebase",
"sl_SI": "Interaktivni uvod v Rebase",
"it_IT": "Introduzione al rebase interattivo",
"pl": "Wprowadzenie do interaktywnego Rebase'a",
},
"startDialog": {
@ -1087,5 +1090,73 @@ exports.level = {
}
]
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Git rebase interattivo",
"",
"Git cherry-pick è fantastico quando sai quale commit vuoi (_e_ conosci l'hash corrispondente) -- è difficile avere di meglio.",
"",
"Ma cosa accade se non sai quale commit ti serve? Per fortuna git ci viene in contro anche in questo caso! Possiamo usare il rebase interattivo -- è il miglior modo per rivedere la sequenza di commit di cui stai per fare il rebase.",
"",
"Vediamolo nel dettaglio...",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Fare rebase interattivo significa usare il comando `rebase` con l'opzione `-i`.",
"",
"Se aggiungi quest'opzione, git aprirà un'interfaccia per mostrarti quali commit stanno per essere copiati sotto il commit su cui vuoi fare il rebase. Verrà anche mostrato l'hash e il messaggio del commit, il che è grandioso per darci l'idea di cosa è cosa",
"",
'Nel git "vero", l\'interfaccia che si apre in realtà è un editor di testo come `vim`. Nel nostro caso, ho creato una piccola finestra che si comporta allo stesso modo.',
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Quando la finestra si apre, hai la possibilità di fare due cose:",
"",
"* Puoi riordinare i commit modificandone l'ordine (drag & drop con il mouse).",
"* Puoi decidere se conservare tutti i commit o rimuoverne qualcuno. Quando la finestra si apre, ogni commit è considerato preso dal pulsante `pick` " +
"attivo affianco a esso. Per scartare un commit, disattiva il suo pulsante `pick`.",
"",
"*Vale la pena ricordare che nel vero rebase interattivo puoi fare molte più cose come lo squashing (combinazione) di commit, " +
"la modifica del messaggio di commit (amending), e perfino la modifica dello stesso commit. Noi ci concentreremo sulle due funzioni descritte sopra.*",
"",
"Bene! Vediamo un esempio.",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Quando premi il pulsante, apparira la finestra del rebase interattivo. Riordina qualche commit (o sentiti libero di scartarne qualcuno) e vediamo il risultato!",
],
afterMarkdowns: [
"Boom! Git ha fatto la copia nell'ordine esatto che hai specificato nell'interfaccia grafica.",
],
command: "git rebase -i HEAD~4 --aboveAll",
beforeCommand: "git commit; git commit; git commit; git commit",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Per concludere questo livello, esegui un rebase interattivo e raggiungi l'obiettivo mostrato. Ricordati che puoi sempre fare `undo` o `reset` per correggere gli errori :D",
],
},
},
],
},
}
};

79
src/levels/rampup/relativeRefs.js
View file

@ -18,6 +18,7 @@ exports.level = {
"uk": "Відносні посилання",
"vi": "Tham chiếu tương đối (^)",
"sl_SI": "Relativne Reference (^)",
"it_IT": "Riferimenti relativi (^)",
"pl": "Referencje względne (^)",
},
"hint": {
@ -36,6 +37,7 @@ exports.level = {
"uk": "Не забудь оператор `^`",
"vi": "Đừng quên dấu mũ (^)!",
"sl_SI": "Spomni se na (^) operator!",
"it_IT": "Ricorda l'operatore Caret(^)... l'accento circonflesso!",
"pl": "Pamiętaj o operatorze karetu (^)!",
},
"startDialog": {
@ -1239,5 +1241,82 @@ exports.level = {
}
]
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Riferimenti relativi",
"",
"Spostarsi in Git specificando l'hash dei commit può essere una scocciatura. Nella vita vera non avrai un bel albero con tutti i commit sullo schermo, dovrai usare `git log` per vedere gli hash.",
"",
"Inoltre, gli hash sono solitamente molto più lunghi. Per esempio, l'hash del commit nel livello precedente è `fed2da64c0efc5293610bdd892f82a58e8cbc5d8`. Non così semplice da ricordare...",
"",
"La nota positiva è che Git è furbo con gli hash. Richiede un numero di caratteri dell'hash tali da poter identificare in modo univoco il commit. Posso scrivere `fed2` invece dell'hash completo.",
],
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Come detto prima, specificare un commit tramite l'hash non è assolutamente il modo migliore, ragion per cui Git ha i riferimenti relativi. Sono stupendi!",
"",
"Tramite i riferimenti relativi, puoi partire da un punto facile da ricordare (per esempio dal ramo `bugFix` o `HEAD`) e procedere da li.",
"",
"Questi riferimenti sono strumenti potenti, introduciamo i più semplici:",
"",
"* Risalire di un commit alla volta con `^`",
"* Risalire di tot commit alla volta con `~<num>`",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Diamo un occhiata all'operatore (^) chiamato Caret o accento circonflesso. Ogni volta che lo aggiungi a un riferimento, stai dicendo a Git di cercare il genitore del commit specificato.",
"",
'Quindi, dire `main^` è equivalente a dire "il primo genitore di `main`".',
"",
"`main^^` è il nonno (antenato di seconda generazione) di `main`",
"",
"Selezioniamo il commit sopra main.",
],
afterMarkdowns: [
"Colpito! Fatto. Mille volte meglio che scrivere l'hash.",
],
command: "git checkout main^",
beforeCommand: "git commit",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Puoi considerare `HEAD` come un riferimento relativo. Usiamolo un paio di volte per risalire l'albero dei commit.",
],
afterMarkdowns: [
"Facile! Possiamo viaggiare in dietro nel tempo con `HEAD^`",
],
command:
"git checkout C3; git checkout HEAD^; git checkout HEAD^; git checkout HEAD^",
beforeCommand: "git commit; git commit",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Per completare questo livello, seleziona il commit padre di `bugFix`. Questo provocherà una detached `HEAD`.",
"",
"Puoi usare l'hash se vuoi, ma prova a usare i riferimenti relativi!",
],
},
},
],
},
}
};

70
src/levels/rampup/relativeRefs2.js
View file

@ -18,6 +18,8 @@ exports.level = {
"uk": "Тобі потрібно використати як мінімум одне пряме посилання (хеш) щоб пройти цей рівень",
"vi": "Bạn sẽ cần dùng ít nhất một tham chiếu trực tiếp (mã băm) để hoàn thành cấp độ này",
"sl_SI": "Moral boš uporabiti vsaj eno direktno referenco (hash) za dokončanje te stopnje.",
"it_IT":
"Dovrai usare almeno un riferimento diretto (hash) per completare questo livello",
"pl": "Aby ukończyć ten poziom, musisz użyć co najmniej jednego bezpośredniej referencji (hasza).",
},
"name": {
@ -36,6 +38,7 @@ exports.level = {
"uk": "Відносні посилання №2",
"vi": "Tham chiếu tương đối #2 (~)",
"sl_SI": "Relativne Reference #2 (~)",
"it_IT": "Riferimenti relativi #2 (~)",
"pl": "Referencje względne #2 (~)"
},
"startDialog": {
@ -1126,5 +1129,72 @@ exports.level = {
}
]
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
'### L\'operatore "~"',
"",
"Nel caso in cui vuoi risalire di più livelli l'albero dei commit, è una seccatura aggiungere `^` per ogni salto, per questo Git ha l'operatore tilde(~).",
"",
"",
"A questo operatore si può (facoltativamente) aggiungere un numero che specifica di quanti livelli si vuole risalire l'albero dei commit. Vediamolo in azione.",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"Specifichiamo il numero di commit con `~`.",
],
afterMarkdowns: ["Fatto! Breve ed efficace -- i riferimenti relativi sono stupendi."],
command: "git checkout HEAD~4",
beforeCommand: "git commit; git commit; git commit",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"### Forzatura dei rami (branch forcing)",
"",
"Ormai sei un esperto di riferimenti relativi, quindi facciamone realmente *uso* per qualcosa.",
"",
"Uno dei motivi più comuni per cui uso i riferimenti relativi è per spostare i rami. E' possibile assegnare un ramo a un commit con l'opzione `-f`. Per esempio:",
"",
"`git branch -f main HEAD~3`",
"",
"sposta (con la forza) il ramo main al terzo antenato di HEAD.",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: ["Vediamolo in azione."],
afterMarkdowns: [
"Ecco qua! I riferimenti relativi ci permettono facilmente di specificare `C1` e il branch forcing (`-f`) ci da modo di spostare rapidamente il ramo su quella posizione.",
],
command: "git branch -f main HEAD~3",
beforeCommand:
"git commit; git commit; git commit; git checkout -b bugFix",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Ora che hai visto i riferimenti relativi e il branch forcing, usiamoli per completare il prossimo livello.",
"",
"Per completare questo livello, sposta `HEAD`, `main`, e `bugFix` alla loro destinazione finale mostrata nell'obiettivo.",
],
},
},
],
},
}
};

68
src/levels/rampup/reversingChanges.js
View file

@ -19,6 +19,7 @@ exports.level = {
"uk": "Відміна змін в Git",
"vi": "Hoàn tác thay đổi trong Git",
"sl_SI": "Revertanje Sprememb v Gitu",
"it_IT": "Annullare i cambiamenti in Git",
"pl": "Odwracanie zmian w Gitcie",
},
"hint": {
@ -37,6 +38,7 @@ exports.level = {
"uk": "Зверни увагу на те що revert та reset приймають різні параметри",
"vi": "Lưu ý rằng hoàn tác(revert) và đặt lại(reset) có những đối số khác nhau.",
"sl_SI": "Revert in reset sprejmeta različne argumente.",
"it_IT": "Revert e reset hanno parametri diversi.",
"pl": "Zauważ, że revert i reset przyjmują różne argumenty",
},
"startDialog": {
@ -1039,6 +1041,70 @@ exports.level = {
}
},
]
}
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"## Annullare i cambiamenti in Git",
"",
"Esistono molti modi per annullare i cambiamenti in Git. Come la creazione di commit, anche l'annullamento in Git ha sia una componente di basso livello (tracciatura dei singoli file o blocchi) e uno di alto livello (come l'annullamento viene realmente eseguito). La nostra applicazione si concentrerà su quest'ultima.",
"",
"Ci sono due modi principali per annullare con Git -- uno è usare `git reset` e l'altro è `git revert`. Entreremo nel dettaglio per entrambi",
"",
],
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"## Git Reset",
"",
'`git reset` annulla le modifiche spostando il puntatore al ramo indietro nel tempo a un commit precedente. Puoi vederla come se stessi "riscriveno la storia;" `git reset` torna al commit precedente come se il nuovo commit non fosse mai esistito.',
"",
"Vediamone una rappresentazione:",
],
afterMarkdowns: [
"Grande! Git ha spostato il puntatore del ramo main the main sul commit `C1`; ora il nostro repository locale è come se non avesse mai avuto un commit `C2`.",
],
command: "git reset HEAD~1",
beforeCommand: "git commit",
},
},
{
type: "GitDemonstrationView",
options: {
beforeMarkdowns: [
"## Git Revert",
"",
'Git reset funziona perfettamente in locale sul proprio computer, la funzione di "riscrivere la storia" non va d\'accordo con i rami salvati in remoto utilizzati da altri colleghi.',
"",
"Per fare in modo di annullare e *condividere* con gli altri le modifiche annullate, dobbiamo usare `git revert`. Vediamolo in azione.",
],
afterMarkdowns: [
"Strano, un nuovo commit è stato creato sotto il commit che volevamo annullare. Questo perché il nuovo commit `C2'` porta *cambiamenti* -- per l'esattezza i cambiamenti sono quelli che annullano il commit `C2`.",
"",
"Con git revert, aggiungi i cambiamenti che possono essere poi condivisi con altrri.",
],
command: "git revert HEAD",
beforeCommand: "git commit",
},
},
{
type: "ModalAlert",
options: {
markdowns: [
"Per completare questo livello, annulla i commit più recenti sia in `local` che in `pushed`. Alla fine annullerai due commit in totale (uno per ramo).",
"",
"Tieni presente che `pushed` è un ramo remoto e `local` è un ramo remoto -- questo dovrebbe aiutarti a scegliere quale metodo usare.",
],
},
},
],
},
}
};

21
src/levels/rebase/manyRebases.js
View file

@ -23,6 +23,7 @@ exports.level = {
"uk" : "Rebase over 9000 разів",
"vi" : "Rebase hơn 9000 lần",
"sl_SI": "Več kot 9000 Rebaseov",
"it_IT": "Rebasing livello 8000",
"pl" : "Rebase ponad 9000 razy"
},
"hint": {
@ -41,6 +42,8 @@ exports.level = {
"uk" : "Не забувай, що краще всього буде перемістити main в самому кінці... ",
"vi" : "Hãy nhớ rằng, cách tốt nhất có lẽ là nên cuối cùng mới cập nhật nhánh `main`... ",
"sl_SI": "Pomni, morda je najbolj učinkovit način posodabljanje masterja samo na koncu ...",
"it_IT":
"Ricorda, il modo migliore potrebbe essere di aggiornare il main alla fine...",
"pl" : "Pamiętaj, że najskuteczniejszym sposobem może być aktualizacja `main` tylko na samym końcu..."
},
"startDialog": {
@ -331,5 +334,23 @@ exports.level = {
}
]
},
"it_IT": {
childViews: [
{
type: "ModalAlert",
options: {
markdowns: [
"### Fare rebase con più rami",
"",
"Hey, qui abbiamo un bel po di rami! Facciamo un po di rebase di questi rami nel main.",
"",
"I piani alti ci stanno rendendo la vita complicata -- vogliono i commit tutti in ordine progressivo. Questo significa che alla fine il nostro albero avrà `C7'` come ultimo commit, `C6'` sopra di esso, e così via, tutto in ordine.",
"",
"Se ti smarrisci lungo la via, usa `reset` senza problemi per ripartire da capo. Assicurati di raggiungere l'obiettivo e cerca di farlo con il minor numero di comandi!",
],
},
},
],
},
}
};

22
src/levels/rebase/selectiveRebase.js
View file

@ -22,6 +22,7 @@ exports.level = {
"uk" : "Макарони з гілок",
"vi" : "Nhánh rối như canh hẹ",
"sl_SI": "Špageti iz Branchev",
"it_IT": "Rami spaghettificati",
"pl": "Gałęziowe Spaghetti",
},
"hint": {
@ -40,6 +41,7 @@ exports.level = {
"uk": "Переконайся, що все йде за порядком! Спершу гілка `one`, потім `two`, і тільки потім `three`",
"vi": "Hãy chắc chắn rằng bạn làm đúng thứ tự! Nhánh `one` trước, rồi `two`, rồi mới đến `three`",
"sl_SI": "Glej da boš vse opravil v pravilnem vrstnem redu! Najprej branch ena, nato pa dva in tri.",
"it_IT": "Assicurati di fare tutto nel giusto ordine! Prima il primo ramo, poi il secondo, poi il terzo",
"pl": "Upewnij się, że robisz wszystko w odpowiedniej kolejności! Gałąź pierwsza, potem druga, potem trzecia.",
},
"startDialog": {
@ -362,5 +364,25 @@ exports.level = {
}
]
},
"it_IT": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Rami spaghettificati",
"",
"Accidenti! C'è tanto da fare per raggiungere l'obiettivo questa volta.",
"",
"Qui abbiamo il `main` situato qualche commit più avanti rispetto ai rami `one` `two` e `three`. Per una qualche ragione, dobbiamo aggiungere questi altri tre rami con versioni aggiornate degli ultimi commit sul main.",
"",
"Il ramo `one` deve essere riordinato e il commit`C5` è da rimuovere. `two` deve essere riordinato, e `three` deve avere un solo commit!",
"",
"Tocca a te capire come farlo -- controlla la soluzione alla fine con il comando `show solution`. "
]
}
}
]
},
}
};