diff --git a/src/levels/advanced/multipleParents.js b/src/levels/advanced/multipleParents.js index 66106217..0f86693f 100644 --- a/src/levels/advanced/multipleParents.js +++ b/src/levels/advanced/multipleParents.js @@ -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!", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/intro/branching.js b/src/levels/intro/branching.js index 08b226c9..db26d533 100644 --- a/src/levels/intro/branching.js +++ b/src/levels/intro/branching.js @@ -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 \" và chuyển sang đó với lệnh \"git checkout \"", "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 \" i sprawdź ją za pomocą \"git checkout \"", + 'it_IT': + 'Crea un nuovo ramo con "git branch " and selezionalo con "git checkout "', "ta_IN": "இப்போது \"git branch \" கட்டளையை கொண்டு புதிய கிளை ஒன்றை உருவாக்குக பின் \"git checkout \" கொண்டு அந்த கிளைக்கு தாவுக" }, "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 ", + "```", + "", + "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 scoprire di piu qui.* ', + ], + }, + }, + { + 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]`.", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/intro/merging.js b/src/levels/intro/merging.js index d2126bfe..8749c481 100644 --- a/src/levels/intro/merging.js +++ b/src/levels/intro/merging.js @@ -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"!*', + ], + }, + }, + ], + }, + } }; diff --git a/src/levels/intro/rebasing.js b/src/levels/intro/rebasing.js index befd7aef..0a7d5d4d 100644 --- a/src/levels/intro/rebasing.js +++ b/src/levels/intro/rebasing.js @@ -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!", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/mixed/describe.js b/src/levels/mixed/describe.js index 76c6c7ef..bef8b859 100644 --- a/src/levels/mixed/describe.js +++ b/src/levels/mixed/describe.js @@ -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 `", + "", + "Dove `` è 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à:", + "", + "`__g`", + "", + "Dove `tag` è il tag antenato più vicino, `numCommits` corrisponde al numero di commit tra ref e il tag, e `` è 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", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/mixed/grabbingOneCommit.js b/src/levels/mixed/grabbingOneCommit.js index 8740d591..c2a28558 100644 --- a/src/levels/mixed/grabbingOneCommit.js +++ b/src/levels/mixed/grabbingOneCommit.js @@ -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`.", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/mixed/jugglingCommits.js b/src/levels/mixed/jugglingCommits.js index 74c39292..ce8b3d50 100644 --- a/src/levels/mixed/jugglingCommits.js +++ b/src/levels/mixed/jugglingCommits.js @@ -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.", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/mixed/jugglingCommits2.js b/src/levels/mixed/jugglingCommits2.js index 81923887..1a68b565 100644 --- a/src/levels/mixed/jugglingCommits2.js +++ b/src/levels/mixed/jugglingCommits2.js @@ -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.", + ], + }, + }, + ], + }, + } }; diff --git a/src/levels/mixed/tags.js b/src/levels/mixed/tags.js index ecf5b1ef..c384a650 100644 --- a/src/levels/mixed/tags.js +++ b/src/levels/mixed/tags.js @@ -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.", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/rampup/cherryPick.js b/src/levels/rampup/cherryPick.js index 8976475d..ddc2b369 100644 --- a/src/levels/rampup/cherryPick.js +++ b/src/levels/rampup/cherryPick.js @@ -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 <...>`", + "", + "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.", + "", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/rampup/detachedHead.js b/src/levels/rampup/detachedHead.js index d001b03b..8bb63d9f 100644 --- a/src/levels/rampup/detachedHead.js +++ b/src/levels/rampup/detachedHead.js @@ -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.", + ], + }, + }, + ], + }, + } }; diff --git a/src/levels/rampup/interactiveRebase.js b/src/levels/rampup/interactiveRebase.js index 600f3de6..ba368d5d 100644 --- a/src/levels/rampup/interactiveRebase.js +++ b/src/levels/rampup/interactiveRebase.js @@ -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", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/rampup/relativeRefs.js b/src/levels/rampup/relativeRefs.js index 0cee8da9..16b107f5 100644 --- a/src/levels/rampup/relativeRefs.js +++ b/src/levels/rampup/relativeRefs.js @@ -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 `~`", + ], + }, + }, + { + 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!", + ], + }, + }, + ], + }, + } }; diff --git a/src/levels/rampup/relativeRefs2.js b/src/levels/rampup/relativeRefs2.js index 8081ed98..c6583deb 100644 --- a/src/levels/rampup/relativeRefs2.js +++ b/src/levels/rampup/relativeRefs2.js @@ -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.", + ], + }, + }, + ], + }, + } }; diff --git a/src/levels/rampup/reversingChanges.js b/src/levels/rampup/reversingChanges.js index a39daaa8..b63c9222 100644 --- a/src/levels/rampup/reversingChanges.js +++ b/src/levels/rampup/reversingChanges.js @@ -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.", + ], + }, + }, + ], + }, + } }; diff --git a/src/levels/rebase/manyRebases.js b/src/levels/rebase/manyRebases.js index 851f1ad3..ad3f2939 100644 --- a/src/levels/rebase/manyRebases.js +++ b/src/levels/rebase/manyRebases.js @@ -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!", + ], + }, + }, + ], + }, } }; diff --git a/src/levels/rebase/selectiveRebase.js b/src/levels/rebase/selectiveRebase.js index b718fe33..c29e608b 100644 --- a/src/levels/rebase/selectiveRebase.js +++ b/src/levels/rebase/selectiveRebase.js @@ -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`. " + ] + } + } + ] + }, } };