translate rampup

src/levels/index.js

@@ -114,7 +114,7 @@ var sequenceInfo = exports.sequenceInfo = {
       'gl'   : 'Alixeirando',
       'zh_CN': '高级篇',
       'zh_TW': '進階篇',
-      'ro': "Mai departe",
+      'ro': "În continuare",
       'ru_RU': 'Едем дальше',
       'uk'   : 'Їдемо далі',
       'ko'   : '다음 단계로',

src/levels/rampup/cherryPick.js

@@ -18,6 +18,7 @@ exports.level = {
     "gl": "Introuducción a cherry-pick",
     "zh_CN": "Git Cherry-pick",
     "zh_TW": "介紹 cherry-pick",
+    "ro":"Introducere în cherry-pick",
     "ru_RU": "Введение в Cherry-pick",
     "ko": "Cherry-pick 소개",
     "uk": "Знайомство з cherry-pick",
@@ -40,6 +41,7 @@ exports.level = {
     "gl": "git cherry-pick seguido das referencias a commits",
     "zh_CN": "git cherry-pick 后面要跟提交的名字",
     "zh_TW": "git cherry-pick 後面要接著 commit 的名稱",
+    "ro": "git cherry-pick urmat de numele commit-urilor",
     "ru_RU": "git cherry-pick основывается на именах коммитов!",
     "ko": "커밋의 이름들로 git cherry-pick 하세요!",
     "uk": "git cherry-pick базується на іменах комітів!",
@@ -677,6 +679,63 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Mutarea Modificărilor",
+              "",
+              "Până acum am acoperit conceptele de bază ale git -- commit-uri, ramuri și navigarea în arborele sursă. Aceste concepte sunt suficiente pentru a profita de 90% din puterea repozitoriilor git și pentru a acoperi nevoile principale ale dezvoltatorilor.",
+              "",
+              "Restul 10% pot fi foarte utile în fluxuri de lucru complexe (sau atunci când te-ai pus singur într-o situație dificilă). Următorul concept pe care îl vom aborda este \"mutarea modificărilor/comit-urilor\" -- în alte cuvinte, este o modalitate pentru dezvoltatori de a spune \"Vreau acest lucru aici și acel lucru acolo\" într-un mod precis, elocvent și flexibil.",
+              "",
+              "Aceasta poate părea complicat, însă este defapt un concept simplu."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Git Cherry-pick",
+              "",
+              "Prima comandă din această serie este `git cherry-pick`. Se folosește în următorul mod:",
+              "",
+              "* `git cherry-pick <Commit1> <Commit2> <...>`",
+              "",
+              "Este o modalitate foarte directă de a spune că dorești să copiezi o serie de commit-uri sub locația ta curentă (`HEAD`). Personal, îmi place foarte mult `cherry-pick` deoarece nu are prea multă magie și este ușor de înțeles.",
+              "",
+              "Să vedem o demonstrație!",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Iată un repozitoriu în care avem unele modificări în ramura `side` pe care dorim să le copiem în `main`. Acest lucru ar putea fi realizat printr-un rebase (pe care l-am învățat deja), dar să vedem cum se comportă cherry-pick."
+            ],
+            "afterMarkdowns": [
+              "Asta e tot! Am vrut commit-urile `C2` și `C4`, iar git le-a plasat imediat sub noi. Simplu, nu?"
+            ],
+            "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": [
+              "Pentru a finaliza acest nivel, pur și simplu copiază modificările din cele trei ramuri în `main`. Poți vedea ce commit-uri dorim să copiem în vizualizarea obiectivului.",
+              ""
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/rampup/detachedHead.js

@@ -14,6 +14,7 @@ exports.level = {
     "zh_TW": "分離 HEAD",
     "de_DE": "Den Kopf abtrennen",
     "ja": "HEADの分離",
+    "ro":"Detașează-ți capul",
     "ru_RU": "Теряем голову, или detached HEAD",
     "ko": "HEAD 분리하기",
     "uk": "Втрачаємо голову чи detached HEAD",
@@ -36,6 +37,7 @@ exports.level = {
     "fr_FR": "Utilisez le label (identifiant) du commit pour aider !",
     "zh_TW": "使用 commit 上的標籤（hash）來幫助你！",
     "zh_CN": "使用提交记录上的标签（哈希值）来指定提交记录！",
+    "ro": "Folosește eticheta (hash) de pe commit pentru ajutor!",
     "ru_RU": "Ориентируйся по идентификаторам (hash) коммитов.",
     "ko": "커밋에 있는 라벨(hash)을 활용하세요!",
     "uk": "Орієнтуйся по індентифікаторам (hash) комітів.",
@@ -901,6 +903,84 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Plimbându-te prin Git",
+              "",
+              "Înainte să trecem la unele dintre funcțiile mai avansate ale Git, este important să înțelegem diferitele moduri de a te deplasa prin arborele de commit-uri care reprezintă proiectul tău.",
+              "",
+              "Odată ce te simți confortabil să te miști prin acesta, puterile tale cu celelalte comenzi Git vor fi amplificate!",
+              "",
+              "",
+              "",
+              "",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## HEAD",
+              "",
+              "În primul rând, trebuie să vorbim despre \"HEAD\". HEAD este un nume simbolic pentru commit-ul pe care teai mutat în prezent -- este, practic, commit-ul pe care lucrezi în acel moment.",
+              "",
+              "HEAD întotdeauna indică cel mai recent commit, reflectat în arborele de commit-uri. Majoritatea comenzilor Git care fac modificări în arborele de commit-uri vor începe prin a modifica HEAD.",
+              "",
+              "În mod normal, HEAD indică numele unei ramuri (de exemplu, bugFix). Când faci un commit, starea ramurii bugFix se modifică și această modificare este vizibilă prin HEAD."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Să vedem asta în acțiune. Aici vom vedea HEAD înainte și după un commit."
+            ],
+            "afterMarkdowns": [
+              "Vezi! HEAD era ascuns sub ramura noastră `main` până acum."
+            ],
+            "command": "git checkout C1; git checkout main; git commit; git checkout C2",
+            "beforeCommand": ""
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "### Detașarea HEAD-ului",
+              "",
+              "Detașarea HEAD-ului înseamnă pur și simplu să îl atașezi la un commit în loc de o ramură. Așa arată înainte:",
+              "",
+              "HEAD -> main -> C1",
+              ""
+            ],
+            "afterMarkdowns": [
+              "Iar acum arată așa:",
+              "",
+              "HEAD -> C1"
+            ],
+            "command": "git checkout C1",
+            "beforeCommand": ""
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Pentru a finaliza acest nivel, trebuie să detașăm HEAD de `bugFix` și să îl atașăm la commit în schimb.",
+              "",
+              "Specifică acest commit prin hash-ul său. Hash-ul fiecărui commit este afișat în cercul care reprezintă commit-ul."
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/rampup/interactiveRebase.js

@@ -17,6 +17,7 @@ exports.level = {
     "fr_FR": "Vous pouvez utiliser soit les branches, soit les références relatives (HEAD~) pour spécifier la cible à rebaser",
     "zh_CN": "branch 或者是相对位置（HEAD~）都可以用來指定 rebase 的目标",
     "zh_TW": "你可以指定 branch 或者是相對位置（HEAD~）來表示 rebase 的目標",
+    "ro":"Poți folosi fie ramuri, fie referințe relative (HEAD~) pentru a specifica ținta rebase-ului",
     "ru_RU": "Можно использовать либо ветки, либо относительные ссылки (HEAD~), чтобы указать цель для Rebase",
     "ja": "リベースする対象の指定には、ブランチ名や相対リファレンス(HEAD~)が使えます",
     "ko": "리베이스할 타겟으로 브랜치나 상대 참조(HEAD~)를 사용할 수 있습니다",
@@ -40,6 +41,7 @@ exports.level = {
     "fr_FR": "Introduction au rebase interactif",
     "zh_CN": "交互式 rebase",
     "zh_TW": "介紹互動式的 rebase",
+    "ro": "Introducere în rebase interactiv",
     "ru_RU": "Введение в интерактивный Rebase",
     "ko": "인터랙티브 리베이스 소개",
     "uk": "Знайомство з інтерактивним rebase",
@@ -770,6 +772,72 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Git Rebase Interactiv",
+              "",
+              "Git cherry-pick este grozav atunci când știi ce commit-uri vrei (_și_ știi hash-urile lor) -- e greu să depășești simplitatea pe care o oferă.",       
+              "",
+              "Dar ce se întâmplă când nu știi ce commit-uri vrei? Din fericire, git te ajută și în această situație! Putem folosi rebase-ul interactiv pentru asta -- este cea mai bună modalitate de a revizui o serie de commit-uri cărora urmează să le faci rebase.",
+              "",
+              "Hai să ne uităm în detalii..."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Rebase-ul interactiv înseamnă pur și simplu că folosești comanda `rebase` cu opțiunea `-i`.",
+              "",
+              "Dacă incluzi această opțiune, git va deschide o interfață pentru a-ți arăta ce commit-uri sunt pe cale să fie copiate sub ținta rebase-ului. De asemenea, îți arată hash-urile și mesajele commit-urilor, ceea ce este grozav pentru a înțelege ce reprezintă fiecare.",
+              "",
+              "În git-ul \"adevărat\", interfața înseamnă deschiderea unui fișier într-un editor de text (de exemplu `vim`). Pentru scopurile noastre, am construit o mică fereastră de dialog care se comportă la fel."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Când dialogul de rebase interactiv se deschide, ai posibilitatea de a face 3 lucruri diferite:",
+              "",
+              "* Poți reordona commit-urile pur și simplu schimbând ordinea lor în interfață (în fereastra noastră, asta înseamnă să tragi și să lași cu mouse-ul).",
+              "* Poți alege să păstrezi toate commit-urile sau să omiți unele. Fiecare commit este setat să fie inclus prin butonul `pick` activ lângă el. Pentru a omite un commit, dezactivează butonul `pick`.",
+              "",
+              "* Merită de știut că în rebase-ul interactiv poți face multe alte lucruri, cum ar fi combinarea commit-urilor (squashing), modificarea mesajelor commit-urilor și chiar editarea lor. Pentru scopurile noastre, ne vom concentra doar pe aceste două operațiuni de mai sus.",
+              "",
+              "Perfect! Să vedem un exemplu."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Când apeși butonul, va apărea o fereastră de rebase interactiv. Reordonează unele commit-uri (sau simte-te liber să omiți unele) și vezi rezultatul!"
+            ],
+            "afterMarkdowns": [
+              "Boom! Git a copiat commit-urile exact așa cum le-ai specificat în interfață."
+            ],
+            "command": "git rebase -i HEAD~4 --aboveAll",
+            "beforeCommand": "git commit; git commit; git commit; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Pentru a finaliza acest nivel, fă un rebase interactiv și obține ordinea afișată în vizualizare. Amintește-ți că poți folosi întotdeauna `undo` sau `reset` pentru a corecta greșelile :D"
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/rampup/relativeRefs.js

@@ -14,6 +14,7 @@ exports.level = {
     "pt_BR": "Referências relativas (^)",
     "gl": "Referencias relativas (^)",
     "de_DE": "Relative Referenzen (^)",
+    "ro":"Referințe relative (^)",
     "ru_RU": "Относительные ссылки (^)",
     "ko": "상대 참조 (^) (Relative Refs)",
     "uk": "Відносні посилання",
@@ -36,6 +37,7 @@ exports.level = {
     "gl": "Non se esqueza do operador circunflexo (^)",
     "zh_CN": "记住操作符（^）！",
     "zh_TW": "不要忘記插入（^）符號！",
+    "ro": "Nu uita operatorul `^`",
     "ru_RU": "Не забудь оператор `^`",
     "ko": "(^)연산자를 기억하세요!",
     "uk": "Не забудь оператор `^`",
@@ -872,6 +874,81 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Referințe relative",
+              "",
+              "Navigarea în Git specificând hash-urile commit-urilor poate deveni puțin obositoare. În lumea reală nu vei avea o vizualizare a arborelui de commit-uri atât de frumoasă lângă terminalul tău, așa că va trebui să folosești `git log` pentru a vedea hash-urile.",
+              "",
+              "În plus, hash-urile sunt de obicei mult mai lungi în lumea reală a Git-ului. De exemplu, hash-ul commit-ului care a introdus nivelul anterior este `fed2da64c0efc5293610bdd892f82a58e8cbc5d8`. Nu este tocmai ușor de pronunțat...",
+              "",
+              "Partea bună este că Git este destul de inteligent cu hash-urile. El necesită doar să specifici suficiente caractere din hash pentru a identifica în mod unic commit-ul. Astfel că pot tasta `fed2` în loc de șirul lung de mai sus."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Așa cum am spus, specificarea commit-urilor prin hash nu este cea mai convenabilă metodă, motiv pentru care Git are referințe relative. Acestea sunt grozave!",
+              "",
+              "Cu referințele relative, poți începe de undeva memorabil (cum ar fi ramura `bugFix` sau `HEAD`) și să lucrezi de acolo.",
+              "",
+              "Commit-urile relative sunt puternice, dar aici vom introduce doar două moduri simple de a le utiliza:",
+              "",
+              "* Deplasarea în sus cu un singur commit folosind `^`",
+              "* Deplasarea în sus de mai multe ori folosind `~<num>`"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Să începem cu operatorul `^`. De fiecare dată când îl adaugi la un nume de referință, îi spui lui Git să găsească părintele commit-ului specificat.",
+              "",
+              "Deci, spunând `main^` este echivalent cu \"primul părinte al lui `main`\".",
+              "",
+              "`main^^` este bunicul (strămoșul de a doua generație) al lui `main`",
+              "",
+              "Dă să trecem pe commit-ul deasupra lui main."
+            ],
+            "afterMarkdowns": [
+              "Ura! Gata. Mult mai ușor decât să scrii hash-ul commit-ului."
+            ],
+            "command": "git checkout main^",
+            "beforeCommand": "git commit"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "De asemenea, poți referi `HEAD` ca o referință relativă. Să folosim asta de câteva ori pentru a ne deplasa în sus în arborele de commit-uri."
+            ],
+            "afterMarkdowns": [
+              "Ușor! Putem călători înapoi în timp cu `HEAD^`"
+            ],
+            "command": "git checkout C3; git checkout HEAD^; git checkout HEAD^; git checkout HEAD^",
+            "beforeCommand": "git commit; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Pentru a finaliza acest nivel, treci la părintele commit-ului `bugFix`. Aceasta va detașa `HEAD`.",
+              "",
+              "Poți specifica hash-ul dacă vrei, dar încearcă să folosești mai întâi referințe relative!"
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/rampup/relativeRefs2.js

@@ -14,6 +14,7 @@ exports.level = {
     "gl": "Precisarás usar polo menos unha referencia directa (hash) para completar este nivel",
     "de_DE": "Du musst mindestens einen Hash benutzen, um dieses Level zu schaffen",
     "ja": "このレベルをクリアするには少なくとも一つの直接リファレンス（hash）を使用する必要があります",
+    "ro":"Vei avea nevoie să folosești cel puțin o referință directă (hash) pentru a termina acest nivel",
     "ru_RU": "Понадобится использовать как минимум одну прямую ссылку (хеш), чтобы пройти этот уровень",
     "ko": "이번 레벨을 완료하려면 최소 한번은 직접 참조(해시)를 사용해야 합니다.",
     "uk": "Тобі потрібно використати як мінімум одне пряме посилання (хеш) щоб пройти цей рівень",
@@ -36,6 +37,7 @@ exports.level = {
     "fr_FR": "Références relatives #2 (~)",
     "zh_CN": "相对引用2（~）",
     "zh_TW": "相對引用二（~）",
+    "ro": "Referințe relative #2 (~)",
     "ru_RU": 'Относительные ссылки №2',
     "ko": "상대 참조 #2 (~)",
     "uk": "Відносні посилання №2",
@@ -792,6 +794,77 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Operatorul \"~\"",
+              "",
+              "Să presupunem că vrei să te muți cu multe niveluri în sus în arborele de commit-uri. Ar putea fi obositor să tastezi `^` de mai multe ori, pentru acest scenariu Git are operatorul tilde (~).",
+              "",
+              "",
+              "Operatorul tilde primește opțional un număr care specifică numărul de commit-uri părinte cu care vrei să te muți în sus. Să vedem cum funcționează."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Să specificăm un număr de commit-uri înapoi cu `~`."
+            ],
+            "afterMarkdowns": [
+              "Boom! Atât de concis -- referințele relative sunt grozave."
+            ],
+            "command": "git checkout HEAD~4",
+            "beforeCommand": "git commit; git commit; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Forțarea ramurilor",
+              "",
+              "Acum că ești expert în referințele relative, hai să le *folosim* pentru ceva.",
+              "",
+              "Una dintre cele mai comune modalități în care se folosesc referințele relative este pentru a muta ramurile. Poți atribui direct o ramură la un commit folosind opțiunea `-f`. Ceva de genul:",
+              "",
+              "`git branch -f main HEAD~3`",
+              "",
+              "Aceasta va muta (forțat) ramura main cu trei commit-uri în spate față de HEAD.",
+              "",
+              "*Notă: Într-un mediu real de git, `git branch -f` nu este permis pentru branch-ul curent.*"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Să vedem comanda anterioară în acțiune"
+            ],
+            "afterMarkdowns": [
+              "Grozav! Referințele relative ne-au oferit o modalitate concisă de a ne referi la `C1`, iar mutarea forțată (`-f`) ne-a oferit o modalitate rapidă de a muta o ramură la acea locație."
+            ],
+            "command": "git branch -f main HEAD~3",
+            "beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Acum că ai văzut referințele relative și mutarea forțată a ramurilor împreună, hai să le folosim pentru a rezolva următorul nivel.",
+              "",
+              "Pentru a completa acest nivel, mută `HEAD`, `main` și `bugFix` la destinațiile lor finale arătate în vizualizare."
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/rampup/reversingChanges.js

@@ -16,6 +16,7 @@ exports.level = {
     "ko": "Git에서 작업 되돌리기",
     "zh_CN": "撤销变更",
     "zh_TW": "在 git 中取消修改 ",
+    "ro":"Anularea modificărilor în Git",
     "ru_RU": "Отмена изменений в Git",
     "uk": "Відміна змін в Git",
     "vi": "Hoàn tác thay đổi trong Git",
@@ -37,6 +38,7 @@ exports.level = {
     "zh_TW": "注意 revert 和 reset 使用不同的參數。",
     "ko": "revert와 reset이 받는 인자가 다름을 기억하세요",
     "ja": "revertとresetとで引数が異なることに注意。",
+    "ro": "Observă că revert și reset primesc argumente diferite.",
     "ru_RU": "Обрати внимание, что revert и reset принимают разные параметры.",
     "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.",
@@ -805,6 +807,69 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Anularea modificărilor în Git",
+              "",
+              "Există multe moduri de a anula modificările în Git. Și la fel ca la comitere, anularea modificărilor în Git are atât o componentă de nivel scăzut (staging-ul fișierelor sau al fragmentelor individuale) cât și o componentă de nivel înalt (modul în care modificările sunt efectiv anulate). Aplicația noastră se va concentra pe aceasta din urmă.",
+              "",
+              "Există două moduri principale de a anula modificările în Git -- unul este folosind `git reset` și celălalt este folosind `git revert`. Vom analiza fiecare dintre acestea în dialogul următor.",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "## Git Reset",
+              "",
+              "`git reset` anulează modificările mutând referința unei ramuri înapoi în timp la un commit mai vechi. În acest sens, poți să te gândești la el ca la o \"rescriere a istoriei\"; `git reset` va muta o ramură înapoi ca și cum commit-ul nu ar fi fost niciodată făcut.",
+              "",
+              "Să vedem cum arată asta:"
+            ],
+            "afterMarkdowns": [
+              "Frumos! Git a mutat pur și simplu referința ramurii main înapoi la `C1`; acum repozitoriul nostru local este într-o stare ca și cum `C2` nu ar fi existat niciodată."
+            ],
+            "command": "git reset HEAD~1",
+            "beforeCommand": "git commit"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "## Git Revert",
+              "",
+              "Deși resetarea funcționează foarte bine pentru ramurile locale de pe propriul tău calculator, metoda de \"rescriere a istoriei\" nu funcționează pentru ramurile remote pe care le folosesc și alții.",
+              "",
+              "Pentru a anula modificările și a le *partaja* cu alții, trebuie să folosim `git revert`. Să vedem cum funcționează."
+            ],
+            "afterMarkdowns": [
+              "Ciudat, a apărut un nou commit sub commit-ul pe care voiam să-l anulăm. Asta pentru că noul commit `C2'` introduce *modificări* -- se întâmplă doar ca aceste modificări să fie exact cele care inversează modificările din commit-ul `C2`.",
+              "",
+              "Cu `revert`, poți să partajezi modificările tale pentru a le împărtăși cu ceilalți."
+            ],
+            "command": "git revert HEAD",
+            "beforeCommand": "git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Pentru a finaliza acest nivel, anulează ultimul commit atât pe ramura `local` cât și pe ramura `pushed`. Vei anula în total două commit-uri (câte unul pentru fiecare ramură).",
+              "",
+              "Ține minte că `pushed` este o ramură remote și `local` este o ramură locală -- acest lucru ar trebui să te ajute să alegi metoda potrivită."
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {