translate advenced git remotes

src/js/stores/LocaleStore.js

@@ -19,6 +19,7 @@ var langLocaleMap = {
   fr: 'fr_FR',
   de: 'de_DE',
   pt: 'pt_BR',
+  ro: 'ro',
   ru: 'ru_RU',
   uk: 'uk',
   vi: 'vi',

src/levels/remote/fetchArgs.js

@@ -13,6 +13,7 @@ exports.level = {
     "gl": "Parámetros de fetch",
     "de_DE": "Optionen für Fetch",
     "ja": "Fetchの引数",
+    "ro":"Argumente pentru fetch",
     "ru_RU": "Аргументы для fetch",
     "ko": "Fetch의 인자들",
     "uk": "Аргументи для fetch",
@@ -33,6 +34,7 @@ exports.level = {
     "gl": "Preste atención en como poderían invertirse os ids dos commits! Podes volver ler toda a lección usando \"help level\"",
     "de_DE": "Beachte wie die Commit IDs getauscht wurden! Du kannst den Einführungsdialog mit \"help level\" erneut anzeigen",
     "ja": "コミットIDの入れ替わりに注意！スライドを復習するには`help level`を実行",
+    "ro": "Fii atent la modul în care ID-urile commit-urilor pot fi inversate! Poți citi din nou slide-urile cu comanda \"help level\"",
     "ru_RU": "Обратите внимание на то, как номера коммитов могут меняться! Вы можете прочесть слайды вновь, воспользовавшись командой \"help level\"",
     "ko": "커밋 ID가 바뀔수도있으니 주의하세요! \"help level\"을 입력하면 슬라이드들을 다시 읽어볼수 있습니다.",
     "uk": "Зверни увагу на те, що номери комітів можуть змінюватися! Слайди уроку можна переглянути ще раз командою \"help level\"",
@@ -1286,6 +1288,129 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Argumentele git fetch",
+              "",
+              "Am învățat deja totul despre argumentele git push, acest parametru fain `<locatie>`, și chiar și refspec-urile cu două puncte (`<sursa>:<destinatie>`). Putem folosi toate aceste cunoștințe și pentru `git fetch`?",
+              "",
+              "Ai ghicit! Argumentele pentru `git fetch` sunt de fapt *foarte, foarte* asemănătoare cu cele pentru `git push`. Sunt aceleași concepte, doar că aplicate în direcția opusă (deoarece acum descarci commit-uri în loc să le încarci).",
+              "",
+              "Să luăm fiecare concept pe rând..."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Parametrul `<locatie>`",
+              "",
+              "Dacă specifici o locatie la `git fetch`, cum ar fi în următoarea comandă:",
+              "",
+              "`git fetch origin foo`",
+              "",
+              "Git se va duce la ramura `foo` de pe remote, va aduce toate commit-urile care nu sunt prezente local și le va plasa pe ramura locală `o/foo`.",
+              "",
+              "Hai să vedem asta în acțiune."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Prin specificarea unei locații..."
+            ],
+            "afterMarkdowns": [
+              "Descărcăm doar commit-urile de pe `foo` și le plasăm pe `o/foo`."
+            ],
+            "command": "git fetch origin foo",
+            "beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Te întrebi poate -- de ce a pus git acele commit-uri pe ramura `o/foo` de pe remote în loc să le pună direct pe ramura locală `foo`? Nu cumva parametrul `<locatie>` este un loc care există atât local cât și pe remote?",
+              "",
+              "Ei bine, git face o excepție specială în acest caz pentru că s-ar putea să ai lucruri pe ramura `foo` care nu vrei să le strici! Asta se leagă de lecția anterioară despre `git fetch` -- nu actualizează ramurile tale locale care nu sunt legate de remote, ci doar descarcă commit-urile (astfel încât să le poți inspecta sau integra mai târziu).",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "În acest caz, ce se întâmplă dacă specific locul sursă și destinație explicit cu `<sursa>:<destinatie>`?",
+              "",
+              "Dacă ești suficient de pasionat să aduci commit-uri *direct* pe o ramură locală, atunci poți specifica asta cu o refspec cu două puncte. Nu poți aduce commit-uri pe o ramură pe care deja te afli (checkout), dar în rest git îți va permite asta.",
+              "",
+              "Aici este singura problemă -- `<sursa>` este acum un loc pe *remote* și `<destinatie>` este un *loc local* unde să pui acele commit-uri. Este exact opusul la git push, și asta are sens deoarece transferăm date în direcția opusă!",
+              "",
+              "Acestea fiind spuse, dezvoltatorii rareori fac asta în practică. Îl introduc aici mai mult ca o modalitate de a conceptualiza cum `fetch` și `push` sunt foarte asemănătoare, doar că în direcții opuse.",
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Hai să vedem această nebunie în acțiune:"
+            ],
+            "afterMarkdowns": [
+              "Wow! Vezi, git a rezolvat `C2` ca un loc pe remote și apoi a descărcat acele commit-uri în `bar` (care era o ramură locală)."
+            ],
+            "command": "git fetch origin C2:bar",
+            "beforeCommand": "git branch foo; git clone; git branch bar; git fakeTeamwork foo 2"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Ce se întâmplă dacă destinația nu există înainte să rulez comanda? Să vedem ultimul exemplu, dar de data aceasta fără ca `bar` să existe.",
+            ],
+            "afterMarkdowns": [
+              "Vezi? E EXACT ca la git push. Git a creat destinația local înainte de a face fetch, la fel cum git va crea destinația pe remote înainte de a face push (dacă nu există).",
+            ],
+            "command": "git fetch origin C2:bar",
+            "beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Nici un argument?",
+              "",
+              "Dacă `git fetch` nu primește nici un argument, atunci pur și simplu descarcă toate commit-urile de pe remote pe toate ramurile remote..."
+            ],
+            "afterMarkdowns": [
+              "Foarte simplu, dar merită să fie văzut măcar o dată."
+            ],
+            "command": "git fetch",
+            "beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Ok, destul cu vorbitul! Pentru a termina acest nivel, adu doar commit-urile specificate în vizualizarea folosind `fetch`. Experimentează cu aceste comenzi!",
+              "",
+              "Pentru ambele comenzi `fetch`, va trebui să specifici sursa și destinația. Fii atent la vizualizare, deoarece ID-urile pot fi schimbate între ele!"
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/remote/mergeManyFeatures.js

@@ -13,6 +13,7 @@ exports.level = {
     "de_DE": "Änderungen vom Remote zusammenführen",
     "ja": "リモートとのmerge",
     "fr_FR": "Fusionner avec les branches distantes",
+    "ro":"Fuzionare cu remote",
     "ru_RU": "Слияние с удалённым репозиторием",
     "ko": "원격 작업과 merge하기",
     "uk": "Мердж з віддаленим репозиторієм",
@@ -33,6 +34,7 @@ exports.level = {
     "de_DE": "Beachte den Ziel-Baum!",
     "ja": "ゴールツリーをよく見てください！",
     "fr_FR": "Respectez l'arbre représentant l'objectif !",
+    "ro": "Fii atent la arborele din vizualizare!",
     "ru_RU": "Внимательно посмотрите на цель уровня!",
     "ko": "goal을 잘 살펴보세요!",
     "uk": "Уважно подивись як має виглядати результат!",
@@ -494,6 +496,51 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## De ce nu facem merge?",
+              "",
+              "Pentru a face push noilor actualizări către remote, tot ce trebuie să faci este să *încorporezi* ultimele modificări de pe remote. Asta înseamnă că poți face fie rebase *sau* merge pe ramura remote (de exemplu, `o/main`).",
+              "",
+              "Deci, dacă poți face oricare dintre metode, de ce lecțiile s-au concentrat până acum pe rebase? De ce nu există dragoste pentru `merge` atunci când lucrăm cu remote?",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Există multe dezbateri în comunitatea dezvoltatorilor despre avantajele și dezavantajele între merge și rebase. Iată avantajele și dezavantajele generale ale rebase-ului:",
+              "",
+              "Avantaje:",
+              "",
+              "* Rebase-ul face ca arborele tău de commit-uri să arate foarte curat, deoarece totul este într-o linie dreaptă",
+              "",
+              "Dezavantaje:",
+              "",
+              "* Rebase-ul modifică istoricul arborelui de commit-uri.",
+              "",
+              "De exemplu, commit-ul `C1` poate fi mutat *după* `C3`. Apoi pare că munca pentru `C1'` a venit după `C3`, când de fapt a fost finalizată înainte.",
+              "",
+              "Unii dezvoltatori iubesc să păstreze istoria și, prin urmare, preferă să facă merge. Alții (ca mine) preferă să aibă un arbore de commit-uri curat și preferă rebase-ul. Totul se reduce la preferințe :D"
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Pentru acest nivel, să încercăm să rezolvăm nivelul anterior, dar cu *merge* în schimb. Poate fi puțin complicat, dar ilustrează bine punctul."
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/remote/pullArgs.js

@@ -14,6 +14,7 @@ exports.level = {
     "de_DE": "Optionen für Pull",
     "ja": "Pullの引数",
     "fr_FR": "Arguments de pull",
+    "ro": "Argumente pentru pull",
     "ru_RU": "Аргументы для pull",
     "ko": "pull 인자들",
     "uk": "Аргументи pull",
@@ -35,6 +36,7 @@ exports.level = {
     "de_DE": "Du kannst neue lokale Branches mittels fetch / pull erstellen",
     "ja": "Fetchとpullの引数を利用してローカルで新規ブランチを作成できるのをお忘れなく",
     "fr_FR": "Vous pouvez aussi créer une nouvelle branche locale avec les arguments de fetch/pull",
+    "ro":"Amintește-ți că poți crea ramuri locale noi folosind argumentele la fetch/pull",
     "ru_RU": "Напоминаю, что новые ветки можно создавать и с помощью команд fetch/pull",
     "ko": "fetch/pull 과 인자들로 새 로컬 브랜치를 생성할수 있다는것을 기억하세요.",
     "uk": "Пам'ятай, що ти можеш створювати нові гілки, використовуючи fetch/pull з аргументами",
@@ -868,6 +870,80 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Argumente pentru git pull",
+              "",
+              "Acum că știi practic *tot* ce este de știut despre argumentele pentru `git fetch` și `git push`, nu mai rămâne aproape nimic de acoperit pentru git pull :)",
+              "",
+              "Asta pentru că, la sfârșitul zilei, git pull este *cu adevărat* doar o prescurtare pentru un fetch urmat de un merge al ceea ce tocmai a fost fetch-uit. Poți să-l consideri ca și cum ai rula git fetch cu aceleași argumente specificate și apoi să faci merge în locul unde au ajuns acele commit-uri.",
+              "",
+              "Aceasta se aplică chiar și atunci când folosești argumente foarte complicate. Să vedem câteva exemple:"
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Iată câteva comenzi echivalente în git:",
+              "",
+              "`git pull  origin foo` este echivalent cu:",
+              "",
+              "`git fetch origin foo; git merge o/foo`",
+              "",
+              "Și...",
+              "",
+              "`git pull origin bar:bugFix` e echivalent:",
+              "",
+              "`git fetch origin bar:bugFix; git merge bugFix`",
+              "",
+              "Vezi? git pull este cu adevărat doar o prescurtare pentru fetch + merge, iar tot ce îi pasă lui git pull este unde au ajuns commit-urile (argumentul `destinatie` pe care îl determină în timpul fetch-ului).",
+              "",
+              "Să vedem o demonstrație:"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Dacă specificăm locul de unde să facem fetch, totul se întâmplă ca înainte cu fetch, dar vom face merge cu ceea ce tocmai am fetch-uit."
+            ],
+            "afterMarkdowns": [
+              "Vezi! Specificând `main`, am descărcat commit-urile în `o/main` ca de obicei. Apoi am făcut merge de `o/main` în locul unde ne aflăm acum, *indiferent* de unde ne aflam."
+            ],
+            "command": "git pull origin main",
+            "beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Funcționează și dacă specificăm `<sursă>` și `<destinație>`? Sigur că da! Să vedem:"
+            ],
+            "afterMarkdowns": [
+              "Wow, o MULȚIME de lucruri într-o singură comandă. Am creat o nouă ramură locală numit `foo`, am descărcat commit-urile de pe `main` de la remote în această ramură `foo`, și apoi am făcut merge acestuia în ramura curentă `bar`."
+            ],
+            "command": "git pull origin main:foo",
+            "beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Ok, pentru a termina, încearcă să atingi starea vizualizată în obiectiv. Vei avea nevoie să descarci câteva commit-uri, să creezi câteva ramuri noi și să faci merge unor ramuri în altele, dar nu ar trebui să fie prea multe comenzi :P"
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/remote/pushArgs.js

@@ -17,6 +17,7 @@ exports.level = {
     "de_DE": "Optionen für Git Push",
     "ja": "Git pushの引数",
     "fr_FR": "Arguments de git push",
+    "ro": "Argumente pentru git push",
     "ru_RU": "Аргументы git push",
     "ko": "git push의 인자들",
     "uk": "Аргументи git push",
@@ -37,6 +38,7 @@ exports.level = {
     "de_DE": "Du kannst dir die Zielsetzung des Levels immer wieder mit \"objective\" anzeigen lassen",
     "ja": "ダイアログの最後のスライドを参照するには\"objective\"を実行",
     "fr_FR": "Vous pouvez toujours regarder le dernier slide des dialogues en tapant \"objective\".",
+    "ro": "Poți vedea întotdeauna ultimul slide tastând \"objective\".",
     "ru_RU": "Вы всегда можете ознакомиться с последним слайдом, воспользовавшись \"objective\".",
     "ko": "대화창의 마지막 슬라이드를 \"objective\"로 다시 볼 수 있습니다.",
     "uk": "Завжди можна подивитися останній слайд діалогу за допомогою \"objective\"",
@@ -701,6 +703,80 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Argumentele comenzii Push",
+              "",
+              "Perfect! Acum că știi despre urmărirea ramurilor remote, putem începe să descoperim câteva dintre misterele din spatele comenzilor git push, fetch și pull. Vom aborda câte o comandă pe rând, dar conceptele dintre ele sunt foarte similare.",
+              "",
+              "În primul rând, vom analiza `git push`. Ai învățat în lecția despre urmărirea ramurilor remote că git determină remote-ul *și* ramura la care să facă push prin examinarea proprietăților ramurii curente (remote-ul pe care îl \"urmărește\"). Acesta este comportamentul implicit atunci când nu sunt specificate argumente, dar git push poate accepta opțional argumente sub formă de:",
+              "",
+              "`git push <remote> <locatie>`",
+              "",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Ce este un parametru `<locatie>`? Vom discuta mai detaliat în curând, dar mai întâi să vedem un exemplu. Executarea comenzii:",
+              "",
+              "`git push origin main`",
+              "",
+              "se traduce în română astfel:",
+              "",
+              "*Mergi la ramura numită \"main\" din repozitoriul meu, ia toate commit-urile, apoi mergi la ramura \"main\" de pe remote-ul numit \"origin\". Plasează acolo toate commit-urile care lipsesc și spune-mi când ai terminat.*",
+              "",
+              "Specificând `main` ca argument pentru \"locatie\", i-am spus lui git de unde vor veni commit-urile și unde vor merge. Este practic \"locația\" sau \"poziția\" care trebuie sincronizată între cele două repozitorii.",
+              "",
+              "Ține minte că, deoarece i-am spus lui git tot ce are nevoie să știe (specificând ambele argumente), el ignoră complet ramura pe care suntem la moment!"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Să vedem un exemplu în care specificăm ambele argumente. Observă poziția unde ne aflăm în acest exemplu."
+            ],
+            "afterMarkdowns": [
+              "Așa! `main` a fost actualizat pe remote deoarece am specificat aceste argumente."
+            ],
+            "command": "git checkout C0; git push origin main",
+            "beforeCommand": "git clone; git commit"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Ce s-ar fi întâmplat dacă nu am fi specificat argumentele?"
+            ],
+            "afterMarkdowns": [
+              "Comanda eșuează (așa cum poți vedea), deoarece `HEAD` nu este pe o ramură care urmărește un remote."
+            ],
+            "command": "git checkout C0; git push",
+            "beforeCommand": "git clone; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "În regulă, pentru acest nivel să actualizăm atât `foo` cât și `main` pe remote. Provocarea este că `git checkout` este dezactivat pentru acest nivel!",
+              "",
+              "*Notă: Ramurile remote sunt etichetate cu prefixul `o/` deoarece eticheta completă `origin/` nu încape în UI-ul nostru. Nu-ți face griji în legătură cu asta... folosește pur și simplu `origin` ca numele remote-ului ca de obicei.*"
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/remote/pushArgs2.js

@@ -13,6 +13,7 @@ exports.level = {
     "de_DE": "Optionen für Git Push -- noch mehr!",
     "ja": "Git pushの引数 -- 拡張編!",
     "fr_FR": "Arguments de git push -- toujours plus !",
+    "ro": "Argumente git push -- Continuarea!",
     "ru_RU": "Аргументы для push -- расширенная версия!",
     "ko": "git push 인자 -- 확장판!",
     "uk": "Розширені аргументи git push!",
@@ -33,6 +34,7 @@ exports.level = {
     "de_DE": "Vergiss nicht dass du aufgeben kannst, indem du \"show solution\" eingibst :P",
     "ja": "降参して解説を見るには\"show solution\"を実行できるのをお忘れなく",
     "fr_FR": "N'oubliez pas que vous pouvez toujours déclarer forfait avec \"show solution\" :P",
+    "ro": "Nu uita că îți poți admite înfrângerea și tasta \"show solution\" pentru a vedea soluția :P",
     "ru_RU": "Помните, Вы всегда можете признать своё поражение, набрав команду \"show solution\" (показать решение) :P",
     "ko": "혹시 아세요? 패배를 인정하고 \"show solution\"을 입력할 수 있다는 걸요 :P",
     "uk": "Пам'ятай, ти завжди можеш визнати поразку і підглянути рішення командою \"show solution\" :P",
@@ -753,6 +755,76 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Detalii a argumentului `<locatie>`",
+              "",
+              "Îți amintești din lecția anterioară că atunci când am specificat `main` ca argument pentru git push, am specificat atât *sursa* de unde vor veni commit-urile cât și *destinația* unde vor merge.",
+              "",
+              "Te-ai putea întreba -- dar ce se întâmplă dacă vrem ca sursa și destinația să fie diferite? Ce se întâmplă dacă vrei să împingi commit-uri din ramura locală `foo` în ramura `bar` de pe remote?",
+              "",
+              "Ei bine, din păcate asta este imposibil în git... glumesc! Sigur că este posibil :)... git are o flexibilitate extrem de mare (poate chiar prea mare).",
+              "",
+              "Vom vedea cum în următorul slide..."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Pentru a specifica atât sursa cât și destinația pentru `<locatie>`, pur și simplu le unești folosind două puncte:",
+              "",
+              "`git push origin <sursa>:<destinatie>`",
+              "",
+              "Acest lucru este adesea denumit refspec cu două puncte. Refspec este doar un nume fain pentru o locație pe care git o poate înțelege (cum ar fi ramura `foo` sau chiar `HEAD~1`)",
+              "",
+              "Odată ce specifici atât sursa cât și destinația în mod independent, poți deveni foarte elegant și precis cu comenzile pentru remote. Hai să vedem o demonstrație!"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Amintește-ți, `sursa` este orice locație pe care git o poate înțelege:"
+            ],
+            "afterMarkdowns": [
+              "Wow! Aceasta este o comandă destul de ciudată, dar are sens -- git a rezolvat `foo^` într-o locație, a încărcat toate commit-urile care nu erau deja prezente pe remote și apoi a actualizat destinația."
+            ],
+            "command": "git push origin foo^:main",
+            "beforeCommand": "git clone; go -b foo; git commit; git commit"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Ce se întâmplă dacă destinația în care vrei să faci push nu există? Nicio problemă! Doar dă un nume de ramură și git va crea ramura pe remote pentru tine."
+            ],
+            "afterMarkdowns": [
+              "Super, asta e foarte fain :D"
+            ],
+            "command": "git push origin main:newBranch",
+            "beforeCommand": "git clone; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Pentru acest nivel, încearcă să ajungi la starea finală a obiectivului afișată în vizualizare și amintește-ți formatul:",
+              "",
+              "`<sursa>:<destinatie>`"
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/remote/pushManyFeatures.js

@@ -13,6 +13,7 @@ exports.level = {
     "de_DE": "Denk dran, du kannst immer undo oder reset benutzen, um deine Befehle zurück zu nehmen.",
     "ja": "undoやresetコマンドをいつでも使用することができるのをお忘れなく",
     "fr_FR": "Rappelez-vous que vous pouvez toujours utiliser les commandes undo et reset.",
+    "ro":"Amintește-ți că poți folosi oricând comenzile undo sau reset",
     "ru_RU": "Помни - ты всегда можешь отменить команды с помощью undo или reset",
     "ko": "명령어를 undo와 reset으로 되돌릴 수 있다는 것을 잊지마세요",
     "uk": "Пам'ятай, ти в будь-який момент можеш використовувати команди undo або reset",
@@ -33,6 +34,7 @@ exports.level = {
     "de_DE": "Push Main!",
     "ja": "Push Main!",
     "fr_FR": "Maître du push !",
+    "ro": "Push Main!",
     "ru_RU": "Push Мастер!",
     "ko": "Push Main!",
     "uk": "Push Maйстер!",
@@ -521,6 +523,59 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Merge a ramurilor cu funcționalități",
+              "",
+              "Acum că ești confortabil cu fetch, pull și push, hai să punem la încercare aceste abilități cu un nou flux de lucru.",
+              "",
+              "Este obișnuit ca dezvoltatorii de pe proiecte mari să își facă toată munca pe ramuri cu funcționalități (de la `main`) și apoi să integreze acea muncă doar atunci când este gata. Acest lucru este similar cu lecția anterioară (unde ramurile secundare erau împinse către remote), dar aici introducem un pas în plus.",
+              "",
+              "Unii dezvoltatori fac push și pull doar când sunt pe ramura `main` -- astfel `main` rămâne mereu actualizat cu ceea ce este pe remote (`o/main`).",
+              "",
+              "Deci, pentru acest flux de lucru combinăm două lucruri:",
+              "",
+              "* integrarea muncii din ramurile cu funcționalități în `main`, și",
+              "* pull și push de la remote"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Să ne reamintim rapid cum să actualizăm `main` și să partajăm munca făcută."
+            ],
+            "afterMarkdowns": [
+              "Am executat două comenzi aici:",
+              "",
+              "* rebase pentru a muta schimbările de la remote pe noi commit-uri, și",
+              "* push pentru a publica munca noastră pe remote"
+            ],
+            "command": "git pull --rebase; git push",
+            "beforeCommand": "git clone; git commit; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Acest nivel este destul de complex -- iată o schiță generală pentru a-l rezolva:",
+              "",
+              "* Există trei ramuri cu funcționalități -- `side1`, `side2` și `side3`",
+              "* Vrem să partajăm fiecare dintre aceste funcționalități, în ordine, către remote",
+              "* La remote au fost făcute unele modificări, așa că va trebui să integrăm și acea muncă",
+              "",
+              ":O intens! Mult noroc, finalizarea acestui nivel reprezintă un pas important."
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/remote/sourceNothing.js

@@ -19,6 +19,7 @@ exports.level = {
     "de_DE": "Die Quelle des Nichts",
     "ja": "無のsource",
     "fr_FR": "Source de rien du tout",
+    "ro":"Sursă goală",
     "ru_RU": "Пустой источник",
     "ko": "Source가 없다",
     "uk": "Нема джерела",
@@ -39,6 +40,7 @@ exports.level = {
     "de_DE": "Der branch Befehl ist für diesen Level inaktiv, du musst also fetch benutzen",
     "ja": "このレベルではbranchコマンドが無効になっているのでfetchを使うしかない！",
     "fr_FR": "La commande branch est désactivée pour ce niveau, vous devrez donc utiliser fetch !",
+    "ro": "Comanda branch este dezactivată pentru acest nivel, așa că va trebui să folosești fetch!",
     "ru_RU": "Команда branch недоступна на этом упражнении, пользуйтесь командой fetch!",
     "ko": "branch 명령이 비활성화 되어있습니다. fetch를 사용해야 돼요!",
     "uk": "Команда branch недоступна на цьому уроці, користуйся командою fetch!",
@@ -583,6 +585,59 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Ciudățenii ale `<sursă>`",
+              "",
+              "Git abuzează parametrul `<sursă>` în două moduri ciudate. Aceste abuzuri vin din faptul că poți specifica tehnic \"nimic\" ca o `sursă` validă atât pentru git push cât și pentru git fetch. Modul în care specifici nimic este printr-un argument gol:",
+              "",
+              "* `git push origin :side`",
+              "* `git fetch origin :bugFix`",
+              "",
+              "Să vedem ce fac acestea..."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Ce face git push cu \"nimic\" către o ramură remote? O șterge!"
+            ],
+            "afterMarkdowns": [
+              "Aici, am șters cu succes ramura `foo` de pe remote prin împingerea conceptului de \"nimic\" către ea. Asta are oarecum sens..."
+            ],
+            "command": "git push origin :foo",
+            "beforeCommand": "git clone; git push origin main:foo"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "În cele din urmă, făcând fetch \"nimicului\" într-un loc local creează de fapt o ramură nouă."
+            ],
+            "afterMarkdowns": [
+              "Foarte ciudat / bizar, dar nu contează. Așa este git-ul!"
+            ],
+            "command": "git fetch origin :bar",
+            "beforeCommand": "git clone"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Aceasta este un nivel mic -- pur și simplu șterge o ramură remote și creează o nouă ramură locală folosind `git fetch` pentru a termina!"
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {

src/levels/remote/tracking.js

@@ -13,6 +13,7 @@ exports.level = {
     "de_DE": "Remote Tracking",
     "ja": "リモートのトラッキング",
     "fr_FR": "Suivi de branche distante",
+    "ro":"Urmărirea unui remote",
     "ru_RU": "Слежка за удалённым репозиторием",
     "ko": "원격 저장소 추적하기",
     "uk": "Слідкуємо за віддаленим репозиторієм",
@@ -33,6 +34,7 @@ exports.level = {
     "de_DE": "Nicht vergessen, es gibt zwei Arten Remote Tracking einzurichten!",
     "ja": "リモートトラッキングを設定する方法が二つあるのをお忘れなく!",
     "fr_FR": "Rappelez-vous qu'il existe deux façons de configurer le suivi de branche distante !",
+    "ro": "Amintește-ți că există două moduri de a urmări un remote!",
     "ru_RU": "Помни, есть два способа установить слежку за удалённым репозиторием!",
     "ko": "원격 추적하기를 설정하는데에는 두가지 방법이 있습니다!",
     "uk": "Пам'ятай, є два способи слідкувати за віддаленим репозиорієм!",
@@ -1106,6 +1108,124 @@ exports.level = {
         }
       ]
     },
+    "ro": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Ramuri de urmărire a Remote-urilor",
+              "",
+              "Un lucru care ar fi putut părea \"magic\" în lecțiile anterioare este că git știa că ramura `main` este legată de `o/main`. Sigur, aceste ramuri au nume asemănătoare și ar putea avea sens logic să conecteze ramura `main` de pe remote cu ramura locală `main`, dar această conexiune este demonstrată clar în două scenarii:",
+              "",
+              "* În timpul unei operațiuni de pull, commit-urile sunt descărcate în `o/main` și apoi *îmbinate* în ramura `main`. Ținta implicită a fuziunii este determinată de această conexiune.",
+              "* În timpul unei operațiuni de push, lucrul din ramura `main` este împins pe ramura `main` a remote-ului (care este apoi reprezentată local de `o/main`). Destinația *push-ului* este determinată de conexiunea dintre `main` și `o/main`.",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Urmărirea Remote-urilor",
+              "",
+              "Pe scurt, această conexiune între `main` și `o/main` este explicată simplu prin proprietatea de \"urmărire a remote-urilor\" a ramurilor. Ramura `main` este setată să urmărească `o/main` -- asta înseamnă că există o țintă implicită de fuziune și o destinație implicită de push pentru ramura `main`.",
+              "",
+              "Te-ai putea întreba cum a fost setată această proprietate pe ramura `main` când nu ai rulat niciun fel de comandă pentru a o specifica. Ei bine, când clonezi un repozitoriu cu git, această proprietate este setată automat pentru tine.",
+              "",
+              "În timpul unei clonări, git creează o ramură remote pentru fiecare ramură de pe remote (de exemplu, ramuri precum `o/main`). Apoi creează o ramură locală care urmărește ramura activă de pe remote, care este `main` în majoritatea cazurilor.",
+              "",
+              "După ce clonarea git este completă, ai doar o ramură locală (astfel încât să nu fii copleșit), dar poți vedea toate ramurile diferite de pe remote (dacă ești foarte curios). Este cea mai bună variantă din ambele lumi!",
+              "",
+              "Aceasta explică de asemenea de ce ai putea vedea următorul mesaj când clonezi:",
+              "",
+              "    local branch \"main\" set to track remote branch \"o/main\""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Pot specifica acest lucru?",
+              "",
+              "Da, poți! Poți face ca orice ramură să urmărească `o/main`, iar dacă faci asta, acea ramură va avea aceeași destinație implicită de push și țintă de combinare a commi-turilor ca `main`. Asta înseamnă că poți rula `git push` pe o ramură numită `totallyNotMain` și să împingi munca ta pe ramura `main` de pe remote!",
+              "",
+              "Există două moduri de a seta această proprietate. Primul este să faci treci la o ramură nouă folosind o ramură remote ca referință specificată. Rulând",
+              "",
+              "`git checkout -b totallyNotMain o/main`",
+              "",
+              "Creează o nouă ramură numită `totallyNotMain` și o setează să urmărească `o/main`."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Destul cu atâta vorbă, să vedem o demonstrație! Vom face un checkout la o nouă ramură numită `foo` și o vom seta să urmărească `main` de pe remote."
+            ],
+            "afterMarkdowns": [
+              "După cum poți vedea, am folosit ținta implicită de fuziune `o/main` pentru a actualiza ramura `foo`. Observă că `main` nu este actualizată!"
+            ],
+            "command": "git checkout -b foo o/main; git pull",
+            "beforeCommand": "git clone; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Aceasta se aplică și pentru `git push`."
+            ],
+            "afterMarkdowns": [
+              "Bam. Am împins munca noastră pe `main` de pe remote chiar dacă ramura noastră se numea complet diferit."
+            ],
+            "command": "git checkout -b foo o/main; git commit; git push",
+            "beforeCommand": "git clone"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Metoda #2",
+              "",
+              "O altă modalitate de a seta urmărirea remote-urilor pe o ramură este să folosești opțiunea `git branch -u`. Rulând",
+              "",
+              "`git branch -u o/main foo`",
+              "",
+              "va seta ramura `foo` să urmărească `o/main`. Dacă ești deja pe ramura `foo`, poți chiar să o omiți:",
+              "",
+              "`git branch -u o/main`",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Hai să vedem rapid această altă modalitate de a specifica urmărirea remote-urilor..."
+            ],
+            "afterMarkdowns": [
+              "La fel ca înainte, doar că este o comandă mai explicită. Grozav!"
+            ],
+            "command": "git branch -u o/main foo; git commit; git push",
+            "beforeCommand": "git clone; git checkout -b foo"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Bine! Pentru acest nivel, trebuie să faci push muncii tale pe ramura `main` de pe remote *fără* a fi pe ramura `main` local. Îți las să descoperi restul singur, deja ești la un nivel avansat :P"
+            ]
+          }
+        }
+      ]
+    },
     "ru_RU": {
       "childViews": [
         {