mirror of
https://github.com/pcottle/learnGitBranching.git
synced 2025-07-30 07:34:54 +02:00
merge main
This commit is contained in:
Peter Cottle
commit
cfd27002ba
34 changed files with 1597 additions and 928 deletions
|
|
@ -742,7 +742,6 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
|
||||
"gl": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
@ -1532,15 +1531,15 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Określanie rodzica",
|
||||
"### Określanie rodziców",
|
||||
"",
|
||||
"Podobnie jak modyfikator `~`, modyfikator `^` również akceptuje opcjonalną liczbę po nim.",
|
||||
"Podobnie jak modyfikator `~`, modyfikator `^` również przyjmuje po sobie opcjonalną liczbę.",
|
||||
"",
|
||||
"Zamiast określać liczbę pokoleń do cofnięcia się (co robi `~`), modyfikator `^` określa, do którego rodzica należy się odwołać po wykonaniu merge commita. Pamiętaj, że polecenia scalania/mergowania mają wielu rodziców, więc ścieżka, którą należy wybrać jest niejednoznaczna.",
|
||||
"Zamiast określać liczbę pokoleń do cofnięcia się (co robi `~`), modyfikator `^` określa, do którego rodzica należy się odwołać po wykonaniu merge commita. Pamiętaj, że scalanie ma wielu rodziców, więc wybór ścieżki nie jest jednoznaczny.",
|
||||
"",
|
||||
"Git zazwyczaj podąża za \"pierwszym\" rodzicem w górę od commitu scalającego, ale określenie liczby za pomocą `^` zmienia to domyślne zachowanie.",
|
||||
"",
|
||||
"Dość gadania, zobaczmy to w akcji.",
|
||||
"Dość gadania - zobaczmy, jak to działa.",
|
||||
""
|
||||
]
|
||||
}
|
||||
|
|
@ -1549,7 +1548,7 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Tutaj mamy merge commit. Jeśli zcheckoutujemy `main^` bez liczby na końcu, przejdziemy do pierwszego rodzica po merge commicie. ",
|
||||
"Tutaj mamy merge commit. Jeśli checkoutujemy `main^` bez liczby na końcu, przejdziemy do pierwszego rodzica po merge commicie. ",
|
||||
"",
|
||||
"(*Na naszych wizualizacjach pierwszy rodzic jest umieszczony bezpośrednio nad commitem scalającym.*)"
|
||||
],
|
||||
|
|
@ -1564,7 +1563,7 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Teraz spróbujmy określić drugiego rodzica zamiast tego. . ."
|
||||
"A teraz spróbujmy określić drugiego rodzica..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Spójrz. Przenieślismy się do drugiego rodzica."
|
||||
|
|
@ -1577,7 +1576,7 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Modyfikatory `^` i `~` mogą uczynić poruszanie się po drzewie commitów bardzo potężnym:"
|
||||
"Modyfikatory `^` i `~` mogą dodać supermoce do poruszania się po drzewie commitów:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Co za prędkość!"
|
||||
|
|
@ -1590,10 +1589,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Jeszcze bardziej szalone jest to, że modyfikatory mogą być ze sobą łączone! Sam zobacz:"
|
||||
"Jeszcze bardziej szalone jest to, że modyfikatory mogą być ze sobą łączone! Zobacz:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Ten sam ruch co poprzednio, ale wszystko w jednej komendzie."
|
||||
"Ten sam ruch co poprzednio, ale wszystko w jednym poleceniu."
|
||||
],
|
||||
"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"
|
||||
|
|
@ -1605,9 +1604,9 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"### Zastosuj to w praktyce",
|
||||
"",
|
||||
"Aby ukończyć ten poziom, utwórz nowa gałąź w określonym miejscu docelowym.",
|
||||
"Aby ukończyć ten poziom, utwórz nową gałąź w określonym miejscu docelowym.",
|
||||
"",
|
||||
"Oczywiście, łatwo byłoby określić commit bezpośrednio (coś jak `C6`), lecz zachęcam Cię do użycia modyfikatorów, o których mówiliśmy przed chwilą!"
|
||||
"Oczywiście łatwo byłoby określić commit bezpośrednio (coś jak `C6`), ale spróbuj użyć modyfikatorów, o których mówiliśmy przed chwilą!"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ exports.level = {
|
|||
"uk": "Розгалуження в Git",
|
||||
"vi": "Rẽ nhánh với Git",
|
||||
"sl_SI": "Branchanje v Gitu",
|
||||
"pl" : "Rozgałęzienia w Gitcie",
|
||||
"pl": "Rozgałęzienia w Gicie",
|
||||
'it_IT': "Creare rami in Git",
|
||||
"ta_IN": "கிட் கிளை நிருவாகம்"
|
||||
},
|
||||
|
|
@ -1330,13 +1330,13 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Git Branch",
|
||||
"",
|
||||
"Gałęzie w Gitcie są niezwykle lekkie. Są po prostu wskazówkami dla konkretnego commita. Wielu entuzjastów gita przestrzega Mantry:",
|
||||
"Gałęzie w Gicie są niezwykle lekkie. Są po prostu wskazówkami do konkretnego commita. Wielu entuzjastów Gita przestrzega mantry:",
|
||||
"",
|
||||
"```",
|
||||
"twórz gałęzie wcześnie i często",
|
||||
"```",
|
||||
"",
|
||||
"W polskim nazewnictwie stosuje się wymiennie nawzwę branch oraz gałąź. Natomiast commit (zatwierdzenie) stosuje się tylko w różnych odmienionych formach np. commita, commitów itp",
|
||||
"W polskim nazewnictwie stosuje się wymiennie nazwę branch oraz gałąź. Natomiast commit (zatwierdzenie) stosuje się tylko w różnych odmienionych formach, np. commita, commitów itp.",
|
||||
"",
|
||||
"Tworzenie wielu gałęzi nie wiąże się z dodatkowymi kosztami przestrzeni czy też pamięci. Z tego powodu łatwiej jest logicznie podzielić swoją pracę, niż mieć duże, różne od siebie gałęzie.",
|
||||
"",
|
||||
|
|
@ -1396,9 +1396,9 @@ exports.level = {
|
|||
"options": {
|
||||
"markdowns": [
|
||||
"*Uwaga: w wersji 2.23 Gita zostało wprowadzono nowe polecenie o nazwie \n`git switch`, które zastępuje polecenie `git checkout`, ",
|
||||
"a jest nieco przeciążonym poleceniem (robi kilka oddzielnych rzeczy). Tutaj nadal będziemy używać",
|
||||
"`checkout` zamiast `switch`, ponieważ wciąż jest najczęściej stosowanym poleceniem",
|
||||
"Jeśli chcesz możesz je wypróbować, ta aplikacja jest na to gotowa! Jeśli chciałbyś dowiedzieć się więcej o poleceniu <a href=\"https://git-scm.com/docs/git-switch\" target=\"_blank\">tutaj</a>.* "
|
||||
"a jest nieco przeciążone (robi kilka oddzielnych rzeczy). Tutaj nadal będziemy używać",
|
||||
"`checkout` zamiast `switch`, ponieważ wciąż jest to najczęściej stosowane polecenie",
|
||||
"Jeśli chcesz, możesz je wypróbować, ta aplikacja jest na to gotowa! Jeśli chcesz dowiedzieć się więcej o poleceniu <a href=\"https://git-scm.com/docs/git-switch\" target=\"_blank\">, zajrzyj tutaj</a>.* "
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1406,8 +1406,8 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Okej, teraz jesteś gotowy do samodzielnego tworzenia gałęzi.",
|
||||
"Po zamknięciu tego okna, stwórz nową gałąź o nazwie `bugFix` i przełącz się na nią.",
|
||||
"Okej, teraz możesz samodzielnie zacząć tworzyć gałęzie.",
|
||||
"Po zamknięciu tego okna stwórz nową gałąź o nazwie `bugFix` i przełącz się na nią.",
|
||||
"",
|
||||
"Przy okazji, oto skrót: jeśli chcesz stworzyć",
|
||||
"nową gałąź ORAZ przełączyć się na nią w tym samym czasie,",
|
||||
|
|
|
|||
|
|
@ -741,9 +741,9 @@ exports.level = {
|
|||
"",
|
||||
"Git stara się, aby commity były tak lekkie, jak to tylko możliwe, więc nie kopiuje na ślepo całego katalogu za każdym razem, gdy zatwierdzasz zmiany. Możesz (jeśli to możliwe) skompresować commita jako zestaw zmian (lub _\"delta\"_) między jedną wersją w repozytorium a następną.",
|
||||
"",
|
||||
"Git przechowuje również historię, kiedy dokonano zatwierdzenia. Dlatego większość commitów ma na sobie zmiany przodków -- oznaczamy to strzałkami w naszej wizualizacji. Utrzymanie historii jest świetne dla wszystkich, którzy pracują nad projektem!",
|
||||
"Git przechowuje również całą historię, kiedy dokonano każdego zatwierdzenia. Dlatego większość commitów ma na sobie zmiany przodków -- oznaczamy to strzałkami w naszej wizualizacji. Zachowanie historii to świetna funkcja dla wszystkich, którzy pracują nad projektem!",
|
||||
"",
|
||||
"Jest mnóstwo rzeczy do zagłębienia, ale na razie możesz myśleć o commitach jako migawkach projektu. Są bardzo lekkie, a przełączanie się między nimi jest niesamowicie szybkie!"
|
||||
"To sporo do zapamiętania, ale na razie możesz myśleć o commitach jako \"rewiznajch\" albo migawkach projektu. Są bardzo lekkie, a przełączanie się między nimi jest niesamowicie szybkie!"
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -751,12 +751,12 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Zobaczmy, jak to wygląda w praktyce. Po prawej stronie mamy wizualizację (małego) repozytorium Gita. Istnieją dwa zatwierdzenia:\n początkowy commit `C0`, a następnie po nim commit `C1`, które mogą mieć kilka interesujących zmian.",
|
||||
"Zobaczmy, jak to wygląda w praktyce. Po prawej stronie mamy wizualizację (małego) repozytorium Gita. Istnieją dwa zatwierdzenia:\n początkowy commit `C0`, a następnie po nim commit `C1`, który może mieć kilka interesujących zmian.",
|
||||
"",
|
||||
"Kliknij poniższy przycisk, aby dodać nowego commita."
|
||||
"Kliknij przycisk poniżej, aby dodać nowego commita."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Gotowe! Niesamowite. Właśnie wprowadziliśmy zmiany w repozytorium i zapisaliśmy je jako commita. Commit, który właśnie wykonaliśmy ma rodzica `C1`, który odnosi się do commitu, na którym się opierał."
|
||||
"Gotowe! Niesamowite. Właśnie wprowadziliśmy zmiany w repozytorium i zapisaliśmy je jako commita. Commit, który właśnie wykonaliśmy, ma rodzica `C1`, który odnosi się do commitu, na którym się opierał."
|
||||
],
|
||||
"command": "git commit",
|
||||
"beforeCommand": ""
|
||||
|
|
@ -766,7 +766,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Śmiało, wypróbuj to sam! Po zamknięciu tego okna wykonaj dwa commity, aby ukończyć poziom."
|
||||
"Śmiało, wypróbuj to! Po zamknięciu tego okna wykonaj dwa commity, aby ukończyć poziom."
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,21 +11,21 @@ exports.level = {
|
|||
"gl": "Merge en Git",
|
||||
"fr_FR": "Faire des 'merge' (fusions de branches) avec Git",
|
||||
"ko": "Git에서 브랜치 합치기(Merge)",
|
||||
"ja" : "ブランチとマージ",
|
||||
"ja": "ブランチとマージ",
|
||||
"zh_CN": "Git Merge",
|
||||
"zh_TW": "git 中的 merge",
|
||||
"ru_RU": "Слияния веток в Git",
|
||||
"uk": "Злиття гілок в Git",
|
||||
"vi": "Gộp nhánh trong Git",
|
||||
"sl_SI": "Merganje v Gitu",
|
||||
"pl" : "Mergowanie w Gitcie",
|
||||
"pl": "Merge w Gicie",
|
||||
'it_IT': "Fusione in Git",
|
||||
"ta_IN": "கிட்டில் இணைத்தல்"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember to commit in the order specified (bugFix before main)",
|
||||
"de_DE": "Denk dran in der angegebenen Reihenfolge zu committen (erst bugFix, dann main)",
|
||||
"ja" : "指示された順番でコミットすること（mainの前にbugFixで）",
|
||||
"ja": "指示された順番でコミットすること（mainの前にbugFixで）",
|
||||
"es_AR": "Acordate de commitear en el orden especificado (bugFix antes de main)",
|
||||
"es_MX": "Acuérdate de hacer commit en el orden especificado (bugFix antes de main)",
|
||||
"es_ES": "Acuérdate de hacer commit en el orden especificado (bugFix antes de main)",
|
||||
|
|
@ -1158,13 +1158,13 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Mergowanie gałęzi",
|
||||
"## Łączenie gałęzi",
|
||||
"",
|
||||
"Świetnie! Już wiemy, jak dodawać commity oraz jak tworzyć gałęzie. Teraz musimy się nauczyć jak połączyć pracę dwóch różnych branchy. Stwórzmy nową gałąź, wprowadźmy nową funkcjonalność, a następnie je połączmy.",
|
||||
"Świetnie! Już wiemy, jak dodawać commity oraz jak tworzyć gałęzie (czyli branche). Teraz musimy się nauczyć, jak połączyć pracę dwóch z nich. Stwórzmy nową gałąź, wprowadźmy nową funkcjonalność, a następnie połączmy gałęzie.",
|
||||
"",
|
||||
"Pierwszą metodą łączenia gałęzi, którą zamierzamy użyć, jest `git merge` (stąd mergowanie czyt. merdżowanie). Połączenie te tworzy w Git specjalny commit, który ma dwóch różnych rodziców. Commit z dwojgiem rodziców zasadniczo oznacza: \"Chcę uwzględnić całą pracę tych dwóch rodziców oraz zbiory wszystkich swoich przodków\".",
|
||||
"Pierwszą metodą scalania (łączenia) gałęzi, której zamierzamy użyć, jest `git merge` (w Polsce możesz spotkać się z takimi określeniami jak merge'owanie albo usłyszeć o merdżowaniu). Połączenie to tworzy w Git specjalny commit, który ma dwoje różnych rodziców. Commit z dwojgiem rodziców zasadniczo oznacza: \"Chcę uwzględnić całą pracę tych rodziców *oraz* zbiory wszystkich swoich przodków\".",
|
||||
"",
|
||||
"Wszystko powinno się wyjaśnić, kiedy to zobaczymy już za chwilę."
|
||||
"Zaraz zobaczysz, jak to wygląda i łatwiej będzie ci wszystko zrozumieć."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1172,14 +1172,14 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Mamy tutaj dwie gałęzie. Każda z nich ma po jednym unikalnym commitcie. Oznacza to, że żadna z gałęzi nie zawiera \"całej pracy\", które jest w naszym repozytorium. Naprawmy to!.",
|
||||
"Mamy tutaj dwie gałęzie. Każda z nich ma po jednym unikalnym commicie. Oznacza to, że żadna z nich nie zawiera \"całej pracy\", którą wykonaliśmy w naszym repozytorium. Naprawmy to!.",
|
||||
"",
|
||||
"Użyjmy `git merge` aby połączyć gałęzie `bugFix` oraz `main`."
|
||||
"Użyjmy `git merge`, aby połączyć branche `bugFix` oraz `main`."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Wow! Widziałeś to? Teraz \"main\" wskazuje na commit, który ma dwoje rodziców. Jeśli podążasz za strzałkami w górę drzewa źródłowego od `main`, trafisz na każdy commit po drodze do korzenia. Oznacza to, że `main` zawiera teraz całą pracę w repozytorium.",
|
||||
"Łał! Widzisz to? Teraz \"main\" wskazuje na commit, który ma dwoje rodziców. Jeśli podążasz za strzałkami w górę drzewa źródłowego od `main`, trafisz na każdy commit po drodze do korzenia. Oznacza to, że `main` zawiera teraz całą pracę w repozytorium.",
|
||||
"",
|
||||
"Czy widziałeś również, jak zmieniły się kolory commitów? Aby pomóc Ci w nauce, dołączyłem kilka konwencji kolorów. Każdy branch ma swój własny kolor. Każdy commit staje się kolorem wynikającym z mieszania kolorów wszystkich branchy, które commitujesz",
|
||||
"Zobacz też, jak zmieniły się kolory commitów. Aby pomóc Ci w nauce, dołączyłem kilka konwencji kolorów. Każdy branch ma swój własny kolor. Kolor każdego commita to mieszanka kolorów wszystkich gałęzi, które commitujesz",
|
||||
"",
|
||||
"Tutaj widzimy, że kolor gałęzi `main` jest składową kolorów wszystkich commitów, ale kolor gałęzi `bugFix` już nie. Naprawmy to..."
|
||||
],
|
||||
|
|
@ -1194,9 +1194,9 @@ exports.level = {
|
|||
"Połączmy gałąź `main` z gałęzią `bugFix`:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Ponieważ `bugFix` był przodkiem gałęzi `main`, git nie musiał wykonywać żadnej pracy. Po prostu przeniosł gałąź `bugFix` do tego samego commita.",
|
||||
"Ponieważ `bugFix` był przodkiem gałęzi `main`, git nie musiał wykonywać żadnej pracy. Po prostu przeniósł branch `bugFix` do tego samego commita, do którego dołączony był `main`.",
|
||||
"",
|
||||
"Teraz wszystkie commity mają ten sam kolor, co oznacza, że każdy branch zawiera całą pracę znajdującą się w repozytorium! Super!"
|
||||
"Teraz wszystkie commity mają ten sam kolor, co oznacza, że każda gałąź zawiera całą pracę znajdującą się w repozytorium! Super!"
|
||||
],
|
||||
"command": "git checkout bugFix; git merge main",
|
||||
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
|
||||
|
|
@ -1208,14 +1208,14 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"Aby ukończyć ten poziom, wykonaj następujące czynności:",
|
||||
"",
|
||||
"* Stwórz nowy branch o nazwie `bugFix`",
|
||||
"* Przełącz się na branch `bugFix`, używając polecenia `git checkout bugFix`",
|
||||
"* Zrób commit",
|
||||
"* Wróć do brancha `main` za pomocą polecenia `git checkout`",
|
||||
"* Zrób ponownie commit",
|
||||
"* Zmerguj gałąź `bugFix` z gałęzią `main` używając polecenia `git merge`",
|
||||
"* Stwórz nową gałąź o nazwie `bugFix`",
|
||||
"* Przełącz się na gałąź `bugFix`, używając polecenia `git checkout bugFix`",
|
||||
"* Zrób jeden commit",
|
||||
"* Wróć do gałęzi `main` za pomocą polecenia `git checkout`",
|
||||
"* Zrób kolejny commit",
|
||||
"* Połącz gałąź `bugFix` z gałęzią `main`, używając polecenia `git merge`",
|
||||
"",
|
||||
"*Pamiętaj: zawsze możesz zobaczyć tą wiadomość ponownie, wpisując \"objective\"!*"
|
||||
"*Pamiętaj: zawsze możesz zobaczyć tę wiadomość ponownie, wpisując \"objective\"!*"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ exports.level = {
|
|||
"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"
|
||||
"pl": "Upewnij się, że masz już commit z bugFix"
|
||||
},
|
||||
"disabledMap": {
|
||||
"git revert": true
|
||||
|
|
@ -1052,7 +1052,8 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},"sl_SI": {
|
||||
},
|
||||
"sl_SI": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
|
|
@ -1127,11 +1128,11 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Git Rebase",
|
||||
"",
|
||||
"Drugim sposobem na łączenie naszej pracy między gałęziami jest *rebase*. Rebase zasadniczo pobiera zestaw commitów, \"kopiuje\" je i umieszcza w innym miejscu.",
|
||||
"Drugim sposobem na łączenie naszej pracy z różnych gałęzi jest *rebase*. Rebase zasadniczo pobiera zestaw commitów, \"kopiuje\" je i wrzuca je gdzie indziej.",
|
||||
"",
|
||||
"Chociaż brzmi to niejasno, zaletą rebase jest to, że można go użyć do stworzenia ładnej, prostej sekwencji commitów. Rebase sprawi, że historia commitów w repozytorium będzie wyglądała na dużo prostszą, ponieważ nia ma wtedy commitów scalających.",
|
||||
"",
|
||||
"Sparwdźmy to w akcji..."
|
||||
"Sprawdźmy, jak to działa..."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1139,9 +1140,9 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Tutaj znowu mamy dwa gałęzie. Zwróć uwagę, że gałąź bugFix jest aktualnie wybrana (zwróć uwagę, że ma gwiazdkę)",
|
||||
"Tutaj znowu mamy dwie gałęzie. Zauważ, że gałąź bugFix jest aktualnie wybrana (zwróć uwagę, że ma gwiazdkę)",
|
||||
"",
|
||||
"Chcielibyśmy przenieść nasze pracę z gałęzi bugFix bezpośrednio na gałąź main. W ten sposób wyglądałoby to tak, jakby te dwa zadania były rozwijane sekwencyjnie, podczas gdy w rzeczywistości rozwijano je równolegle.",
|
||||
"Chcielibyśmy przenieść naszą pracę z gałęzi bugFix bezpośrednio na gałąź main. W ten sposób wyglądałoby to tak, jakby te dwa zadania były rozwijane sekwencyjnie, podczas gdy w rzeczywistości rozwijano je równolegle.",
|
||||
"",
|
||||
"Zróbmy to za pomocą polecenia `git rebase`."
|
||||
],
|
||||
|
|
@ -1150,7 +1151,7 @@ exports.level = {
|
|||
"",
|
||||
"Zauważ, że commit C3 nadal gdzieś istnieje (jest wyblakły w drzewie), a commit C3' jest \"kopią\", którą przenosimy na main.",
|
||||
"",
|
||||
"Jedynym problemem jest to, że `main` nie jest teraz aktualny. Zaktualizujmy go..."
|
||||
"Jedynym problemem jest to, że `main` nie został jeszcze zaktualizowany. Zróbmy to teraz..."
|
||||
],
|
||||
"command": "git rebase main",
|
||||
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
|
||||
|
|
@ -1163,7 +1164,7 @@ exports.level = {
|
|||
"Znajdujemy się na gałęzi `main`. Przejdźmy dalej i zróbmy połączenie rebase z branchem `bugFix`..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Oto jest! Ponieważ `main` był przodkiem `bugFix`, git po prostu przesunął odniesienie do `main` do przodu w historii."
|
||||
"Gotowe! Ponieważ `main` był przodkiem `bugFix`, git po prostu przesunął odniesienie do `main` do przodu w historii."
|
||||
],
|
||||
"command": "git rebase bugFix",
|
||||
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
|
||||
|
|
@ -1178,9 +1179,9 @@ exports.level = {
|
|||
"* Przejdź do nowej gałęzi o nazwie `bugFix`",
|
||||
"* Zrób commit",
|
||||
"* Wróć do gałęzi `main` i zrób kolejny commit",
|
||||
"* Przejdź do `bugFix` i połącz za pomocą rebase z main",
|
||||
"* Przejdź do `bugFix` i połącz za pomocą rebase z `main`",
|
||||
"",
|
||||
"Powodzenia, misja zakończona!"
|
||||
"Powodzenia!"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ exports.level = {
|
|||
"vi": "Git Describe(mô tả)",
|
||||
"sl_SI": "Git Describe",
|
||||
"it_IT": "Git Describe",
|
||||
"pl": "Git Describe"
|
||||
"pl": "Git describe"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Just commit once on bugFix when you're ready to move on",
|
||||
|
|
@ -38,7 +38,7 @@ exports.level = {
|
|||
"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",
|
||||
"pl": "Scommituj raz na bugFix, żeby przejść dalej",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -996,11 +996,11 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Git Describe",
|
||||
"### Git describe",
|
||||
"",
|
||||
"Ponieważ znaczniki służą jako tak wspaniałe \"kotwice\" w bazie kodu, git ma polecenie *opisujące*, gdzie jesteś w stosunku do najbliższej \"kotwicy\". Ta komenda nazywa się `git describe`!",
|
||||
"Ponieważ znaczniki służą jako świetne \"kotwice\" w bazie kodu, git ma polecenie *opisujące*, gdzie jesteś w stosunku do najbliższej \"kotwicy\". I jest to `git describe`!",
|
||||
"",
|
||||
"`Git describe` może pomóc Ci zorientować się w sytuacji, gdy przesunąłeś wiele commitów wstecz lub do przodu w historii; może się to zdarzyć po wykonaniu bisekcji git (na potrzeby debugowania) lub gdy siedzisz przy komputerze współpracownika, który właśnie wrócił z wakacji."
|
||||
"`Git describe` może pomóc ci zorientować się w sytuacji, gdy przesuniesz wiele commitów wstecz lub do przodu w historii; może się to zdarzyć po użyciu git bisect (na potrzeby debugowania) lub gdy siedzisz przy komputerze współpracownika, który właśnie wrócił z wakacji."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1012,13 +1012,13 @@ exports.level = {
|
|||
"",
|
||||
"`git describe <ref>`",
|
||||
"",
|
||||
"Gdzie `<ref>` jest czymkolwiek, co git może przekształcić w commit. Jeśli nie podasz `<ref>`, git użyje miejsca, w którym jesteś teraz zcheckoutowany (`HEAD`).",
|
||||
"Gdzie `<ref>` jest czymkolwiek, co git może odnieść do commita. Jeśli nie podasz `<ref>`, git użyje aktualnie checkoutowanego miejsca (`HEAD`).",
|
||||
"",
|
||||
"Wynik polecenia wygląda następująco:",
|
||||
"",
|
||||
"`<tag>_<numCommits>_g<hash>`",
|
||||
"",
|
||||
"Gdzie `tag` jest najbliższym tagiem przodka w historii, `numCommits` jest liczbą commitów od tego tagu, a `<hash>` jest hashem opisywanego commitu."
|
||||
"`tag` jest znacznikiem najbliższego przodka w historii, `numCommits` jest liczbą commitów od tego znacznika, a `<hash>` jest haszem opisywanego commitu."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1026,14 +1026,14 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Przyjrzyjmy się szybkiemu przykładowi. Dla tego drzewa poniżej:"
|
||||
"Przyjrzyjmy się krótkiemu przykładowi. Dla tego drzewa poniżej:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Polecenie `git describe main` dałoby wynik:",
|
||||
"polecenie `git describe main` dałoby wynik:",
|
||||
"",
|
||||
"`v1_2_gC2`",
|
||||
"",
|
||||
"Gdzie `git describe side` dałoby wynik:",
|
||||
"a `git describe side` dałoby wynik:",
|
||||
"",
|
||||
"`v2_1_gC4`"
|
||||
],
|
||||
|
|
@ -1045,9 +1045,9 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"To w zasadzie wszystko, co jest musisz wiedzieć o `git describe`! Spróbuj opisać kilka miejsc na tym poziomie, aby wyczuć to polecenie.",
|
||||
"To w zasadzie wszystko, co musisz wiedzieć o `git describe`! Spróbuj opisać kilka miejsc na tym poziomie, aby wyczuć to polecenie.",
|
||||
"",
|
||||
"Kiedy będziesz gotowy, po prostu zrób jeden commit, aby ukończyć poziom. Dajemy Ci bonusa :P"
|
||||
"Kiedy zechesz przejść dalej, po prostu zrób jeden commit, aby ukończyć poziom. Masz to w gratisie :P"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ exports.level = {
|
|||
"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",
|
||||
"pl": "Pamiętaj, że znasz już interaktywny rebase oraz cherry-pick",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -645,11 +645,11 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Lokalnie nałożone commity",
|
||||
"",
|
||||
"Oto sytuacja, która często się zdarza podczas pisania kodu: próbuję wytropić błąd, ale jest on dość nieuchwytny. Aby pomóc sobie w mojej pracy detektywistycznej, umieszczam kilka poleceń debugowania i kilka instrukcji print.",
|
||||
"Oto sytuacja, która często się zdarza podczas pisania kodu: próbuję wytropić buga, ale on jest nieuchwytny. Aby pomóc sobie w poszukiwaniach, dodaję kilka poleceń debugowania i kilka instrukcji print.",
|
||||
"",
|
||||
"Wszystkie te polecenia debugowania / drukowania znajdują się w osobnych commitach. W końcu namierzam błąd, naprawiam go i cieszę się!",
|
||||
"",
|
||||
"Jedynym problemem jest to, że teraz muszę przywrócić mój `bugFix` do gałęzi `main`. Jeśli po prostu zrobiłbym fast-foward `main`, wtedy `main` dostałby wszystkie moje deklaracje debugowania, czego bym nie chciał. Musi być na to inny sposób. . ."
|
||||
"Jedynym problemem jest to, że teraz muszę przywrócić mój `bugFix` do gałęzi `main`. Jeśli po prostu zrobiłbym fast-foward `main`, wtedy `main` dostałby wszystkie moje deklaracje debugowania, a tego bym nie chciał. Musi być na to inny sposób. . ."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -657,12 +657,12 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Musimy powiedzieć gitowi, żeby skopiował tylko jeden z commitów. Dokładnie w ten sam sposób jak we wcześniejszych poziomach z przenoszeniem pracy -- używając tych samych komend:",
|
||||
"Musimy powiedzieć Gitowi, żeby skopiował tylko jeden z commitów. Dokładnie w ten sam sposób jak we wcześniejszych poziomach z przenoszeniem pracy -- używając tych samych poleceń:",
|
||||
"",
|
||||
"* `git rebase -i`",
|
||||
"* `git cherry-pick`",
|
||||
"",
|
||||
"Aby osiągnać ten cel."
|
||||
"aby osiągnać ten cel."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -670,7 +670,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Jest to wyższy poziom, więc pozostawimy Ci decyzję, której komendy chcesz użyć, ale aby ukończyć poziom, upewnij się, że `main` otrzyma commit, do którego odwołuje się `bugFix`."
|
||||
"Jest to wyższy poziom, więc pozostawimy ci decyzję, której komendy chcesz użyć, ale aby ukończyć poziom, upewnij się, że `main` otrzyma commit, do którego odwołuje się `bugFix`."
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ exports.level = {
|
|||
"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",
|
||||
"pl": "Pierwsze polecenie to: git rebase -i HEAD~2",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -578,9 +578,9 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Żonglowanie commitami",
|
||||
"",
|
||||
"Oto inna sytuacja, która zdarza się dość często. Masz pewne zmiany (`newImage`) i inny zestaw zmian (`caption`), które są powiązane, więc są one ułożone jeden na drugim w twoim repozytorium (tzw. jeden po drugim).",
|
||||
"Oto inna sytuacja, która zdarza się dość często. Masz pewne zmiany (`newImage`) i inny zestaw zmian (`caption`), które są powiązane, więc są one ułożone jedne na drugim w twoim repozytorium (tzw. jeden po drugim).",
|
||||
"",
|
||||
"Podstępną rzeczą jest to, że czasami trzeba dokonać małej modyfikacji wcześniejszego commitu. W tym przypadku projektant chce, abyśmy zmienili nieco wymiary `newImage`, nawet jeśli ten commit jest daleko w tyle w naszej historii!!!"
|
||||
"Problem polega na tym, że czasami trzeba dokonać małej modyfikacji wcześniejszego commitu. W tym przypadku projektant chce, abyśmy zmienili nieco wymiary `newImage`, mimo że ten commit jest daleko w tyle w naszej historii!!!"
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -593,12 +593,12 @@ exports.level = {
|
|||
"* Zmienimy kolejność commitów tak, aby ten, który chcemy zmienić, był na górze, używając `git rebase -i`.",
|
||||
"* Wykonamy `git commit --amend`, aby dokonać niewielkiej modyfikacji",
|
||||
"* Następnie zmienimy kolejność commitów z powrotem na taką, jaka była poprzednio za pomocą `git rebase -i`.",
|
||||
"* Na koniec przeniesiemy się do tej zaktualizowanej części drzewa, aby zakończyć poziom (w wybrany przez Ciebie sposób)",
|
||||
"* Na koniec przeniesiemy się do tej zaktualizowanej części drzewa, aby ukończyć ten poziom (w wybrany przez ciebie sposób)",
|
||||
"",
|
||||
"Istnieje wiele sposobów na osiągnięcie tego ogólnego celu (widzę, że masz oko na cherry-pick'ing), i zobaczymy więcej z nich później, ale na razie skupmy się na tej technice.",
|
||||
"Na koniec, zwróć uwagę na stan celu - ponieważ przenosimy commit'y dwukrotnie, oba otrzymują apostrof. Dodajemy jeszcze jeden apostrof dla commitu, który zmieniamy, co daje nam ostateczną postać drzewa",
|
||||
"Istnieje wiele sposobów na osiągnięcie tego ogólnego celu (widzę, że masz na oku cherry-pick), i później zobaczymy ich więcej, ale na razie skupmy się na tej technice.",
|
||||
"Na koniec zwróć uwagę na stan celu - ponieważ przenosimy commity dwukrotnie, oba otrzymują apostrof. Dodajemy jeszcze jeden apostrof dla commitu, który zmieniamy, co daje nam ostateczną postać drzewa",
|
||||
"",
|
||||
"To powiedziawszy, mogę teraz porównać poziomy w oparciu o strukturę i względne różnice apostrofów. Tak długo, jak gałąź `main` Twojego drzewa ma taką samą strukturę, rozwiązanie zostanie uznane."
|
||||
"Uwzględniając to, mogę teraz porównać poziomy w oparciu o strukturę i względne różnice apostrofów. Tak długo, jak gałąź `main` twojego drzewa ma taką samą strukturę, rozwiązanie zostanie uznane."
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ exports.level = {
|
|||
"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!",
|
||||
"pl": "Nie zapomnij sforwardować maina do najnowszych zmian!",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -703,9 +703,9 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Żonglowanie commitami #2",
|
||||
"",
|
||||
"*Jeśli nie ukończyłeś Żonglowania commitami #1 (poprzedni poziom), zrób to przed przejściem dalej*",
|
||||
"*Ukończ poprzedni poziom Żonglowania commitami przed przejściem dalej*",
|
||||
"",
|
||||
"Jak widziałeś na ostatnim poziomie, użyliśmy `rebase -i` aby zmienić kolejność commitów. Kiedy commit, który chcieliśmy zmienić, był już na górze, mogliśmy go łatwo zmienić (`--amend`), a następnie przywrócić do odpowiedniej kolejności.",
|
||||
"Na poprzednim poziomie użyliśmy `rebase -i`, aby zmienić kolejność commitów. Kiedy commit, który chcieliśmy zmienić, był już na górze, mogliśmy łatwo to zrobić (`--amend`), a następnie przywrócić do odpowiedniej kolejności.",
|
||||
"",
|
||||
"Jedynym problemem jest to, że dokonuje się wiele zmian w kolejności, co może powodować konflikty podczas rebase'u. Przyjrzyjmy się innej metodzie korzystającej z `git cherry-pick`."
|
||||
]
|
||||
|
|
@ -715,7 +715,7 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Pamiętaj, że git cherry-pick umieści commit z dowolnego miejsca w drzewie na HEAD (tak długo, jak ten commit nie jest przodkiem HEAD).",
|
||||
"Pamiętaj, że git cherry-pick zrzuci commit z dowolnego miejsca drzewa na HEAD (o ile ten commit nie jest przodkiem HEAD).",
|
||||
"",
|
||||
"Oto małe demo na odświeżenie pamięci:"
|
||||
],
|
||||
|
|
@ -730,9 +730,9 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Więc na tym poziomie, osiągnijmy ten sam cel zmiany `C2` raz, ale unikając użycia `rebase -i`. Zostawię Ci to do rozgryzienia! :D",
|
||||
"Więc na tym poziomie osiągnijmy ten sam cel zmiany `C2`, ale unikając użycia `rebase -i`. Zostawię ci to do rozgryzienia! :D",
|
||||
"",
|
||||
"Pamiętaj, że dokładna liczba apostrofów (') na zobowiązaniu nie jest ważna, tylko względne różnice. Na przykład, uznam drzewo, które pasuje do drzewa celu, ale ma wszędzie jeden dodatkowy apostrof."
|
||||
"Pamiętaj, że dokładna liczba apostrofów (') nie jest ważna, tylko względne różnice. Na przykład, uznam drzewo, które pasuje do drzewa celu, ale ma wszędzie jeden dodatkowy apostrof."
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ exports.level = {
|
|||
"vi": "Tag trong Git",
|
||||
"sl_SI": "Git Tagi",
|
||||
"it_IT": "Git Tag",
|
||||
"pl": "Git Tagi",
|
||||
"pl": "Tagi Gita",
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "you can either check out the commit directly or simply checkout the tag!",
|
||||
|
|
@ -828,11 +828,11 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git Tagi",
|
||||
"## Tagi Gita",
|
||||
"",
|
||||
"Jak dowiedziałeś się z poprzednich lekcji, gałęzie są łatwe w przemieszczaniu i często odnoszą się do różnych commitów, w miarę jak praca nad nimi jest kończona. Gałęzie łatwo ulegają mutacjom, często są tymczasowe i zawsze się zmieniają.",
|
||||
"Jak wiesz z poprzednich lekcji, gałęzie łatwo przemieszczać, i w momencie ukończenia pracy nad nimi często odnoszą się do różnych commitów. Gałęzie łatwo ulegają mutacjom, często są tymczasowe i zawsze się zmieniają.",
|
||||
"",
|
||||
"Jeśli tak jest, możesz się zastanawiać, czy istnieje sposób na *permanentne* zaznaczanie punktów historycznych w historii projektu. Czy istnieje jakiś sposób na oznaczenie tych commitów czymś bardziej trwałym niż gałąź, w przypadku takich rzeczy jak duże wydania i duże scalenia/merdże?",
|
||||
"A skoro tak, to możesz się zastanawiać, czy istnieje sposób na *trwałe* zaznaczanie ważnych punktów w historii projektu. Czy istnieje jakiś sposób na oznaczenie tych commitów czymś bardziej trwałym niż gałąź, w przypadku takich rzeczy jak duże wydania i duże scalenia/ merge?",
|
||||
""
|
||||
]
|
||||
}
|
||||
|
|
@ -841,11 +841,11 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Pewnie, że tak! Znaczniki/tagi Git obsługują dokładnie ten przypadek użycia -- (w pewnym sensie) trwale oznaczają pewne commity jako \"kamienie milowe\", do których można się następnie odnieść (po nazwie) jak do gałęzi.",
|
||||
"Pewnie, że tak! Znaczniki/tagi Gita obsługują dokładnie ten przypadek użycia -- (do pewnego stopnia) trwale oznaczają pewne commity jako \"kamienie milowe\", do których można się następnie odnieść (po nazwie) jak do gałęzi.",
|
||||
"",
|
||||
"Co ważniejsze jednak, nigdy się nie przesuwają, gdy tworzone są kolejne commity. Nie można \"checkoutować\" tagu, a następnie zakończyć pracę nad nim (jakby był gałęzią, na której można zapisać nowe zmiany) - tagi istnieją jako kotwice w drzewie commitów, które wyznaczają pewne miejsca.",
|
||||
"Co ważniejsze jednak, nigdy się nie przesuwają, gdy tworzone są kolejne commity. Nie można \"checkoutować\" tagu, a następnie zakończyć pracy nad nim (jakby był gałęzią, na której można zapisać nowe zmiany) - tagi są jak kotwice w drzewie commitów, które wyznaczają pewne miejsca.",
|
||||
"",
|
||||
"Zobaczmy jak tagi wyglądają w praktyce."
|
||||
"Zobaczmy, jak tagi wyglądają w praktyce."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -853,10 +853,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Spróbujmy zrobić tag w `C1`, który jest naszym prototypem w wersji 1."
|
||||
"Spróbujmy zrobić tag w `C1`, który jest prototypem naszej wersji 1."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Otóż to! Całkiem proste. Nazwaliśmy tag `v1` i odwołaliśmy się do commitu `C1` w sposób jawny. Jeśli nie wskażesz konkretnego commitu, git użyje commitu na który wskazuje `HEAD`."
|
||||
"Otóż to! Całkiem proste. Nazwaliśmy tag `v1` i odwołaliśmy się do commitu `C1` w sposób jawny. Jeśli nie wskażesz konkretnego commitu, Git użyje commitu, na który wskazuje `HEAD`."
|
||||
],
|
||||
"command": "git tag v1 C1",
|
||||
"beforeCommand": "git commit"
|
||||
|
|
@ -866,7 +866,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Dla tego poziomu utwórz tagi takie jak w wizualizacji celu, a następnie zchckoutuj `v1`. Zauważ, że przechodzisz do odłączonego stanu `HEAD` - to dlatego, że nie możesz commitować bezpośrednio na tagu `v1`.",
|
||||
"Dla tego poziomu utwórz tagi takie jak w wizualizacji celu, a następnie checkoutuj `v1`. Zauważ, że przechodzisz do odłączonego stanu `HEAD` - to dlatego, że nie możesz commitować bezpośrednio na tagu `v1`.",
|
||||
"",
|
||||
"Na kolejnym poziomie przeanalizujemy bardziej interesujący przypadek użycia tagów."
|
||||
]
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ exports.level = {
|
|||
"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"
|
||||
"pl": "Wprowadzenie do cherry-pick"
|
||||
},
|
||||
"hint": {
|
||||
"fr_FR": "git cherry-pick suivi par les noms de commits",
|
||||
|
|
@ -907,11 +907,11 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Przenoszenie pracy",
|
||||
"",
|
||||
"Do tej pory zajmowaliśmy się podstawami gita - commitowaniem, gałęziami i poruszaniem się w drzewie źródłowym. Tylko te koncepcje wystarczą, aby wykorzystać 90% mocy repozytoriów git i pokryć główne potrzeby deweloperów.",
|
||||
"Do tej pory zajmowaliśmy się podstawami Gita - commitami, gałęziami i poruszaniem się w drzewie źródłowym. Samo to wystarczy, aby wykorzystać 90% mocy repozytoriów Git i zaspokoić główne potrzeby programistów.",
|
||||
"",
|
||||
"Pozostałe 10% może być jednak dość użyteczne podczas niecodziennych zadań (lub gdy o czymś zapomniałeś). Kolejna koncepcja, którą zamierzamy omówić to \"przenoszenie pracy\" - innymi słowy, jest to sposób, w jaki deweloperzy mogą powiedzieć: \"Chcę te zmiany tu i tam\" w precyzyjny, wymowny i elastyczny sposób.",
|
||||
"Pozostałe 10% może być jednak dość użyteczne podczas niecodziennych zadań (lub kiedy wpakujesz się w kłopoty). Kolejny temat, który zamierzamy omówić, to \"przenoszenie pracy\" - innymi słowy, jest to sposób, w jaki programiści mogą powiedzieć: \"Chcę te zmiany tu, a tamte tam\" w precyzyjny, elegancki i elastyczny sposób.",
|
||||
"",
|
||||
"To może wydawać się sporo, ale to prosta koncepcja."
|
||||
"Może się to wydawać skomplikowane, ale tak nie jest."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -919,13 +919,13 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git Cherry-pick",
|
||||
"## Git cherry-pick",
|
||||
"",
|
||||
"Pierwsza komenda w tej serii nazywa się `git cherry-pick`. Przyjmuje ona następującą formę:",
|
||||
"Pierwsze polecenie w tej serii nazywa się `git cherry-pick`. Przyjmuje ono następującą formę:",
|
||||
"",
|
||||
"* `git cherry-pick <Commit1> <Commit2> <...>`",
|
||||
"",
|
||||
"Jest to bardzo prosty sposób określenia jakie zmiany poniżej swojej obecnej lokalizacji (`HEAD`) chciałbyś przenieść. Osobiście uwielbiam `cherry-pick'ing`, ponieważ jest to proste jak budowa cepa.",
|
||||
"Jest to bardzo prosty sposób określenia, że chcesz przenieść zmiany poniżej swojej obecnej lokalizacji (`HEAD`). Osobiście uwielbiam `cherry-pick`, ponieważ działa prosto i skutecznie.",
|
||||
"",
|
||||
"Zobaczmy demo!",
|
||||
""
|
||||
|
|
@ -936,10 +936,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Mamy tutaj repozytorium, gdzie mamy trochę pracy na gałęzi `side`, które chcemy skopiować do gałęzi `main`. Można by to osiągnąć dzięki komendy rebase'owi (którego już się nauczyliśmy), ale zobaczmy, jak działa cherry-pick."
|
||||
"W tym repozytorium mamy trochę pracy na gałęzi `side`, którą chcemy skopiować do gałęzi `main`. Można by to osiągnąć przy użyciu rebase (którego już się nauczyliśmy), ale zobaczmy, jak działa cherry-pick."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"To jest to! Chcieliśmy aby commity `C2` i `C4` i git wziął i dodał do `main`. Bułka z masłem!"
|
||||
"No i fajnie! Chcieliśmy commity `C2` i `C4` i Git zrzucił je nam zaraz pod spód. Bułka z masłem!"
|
||||
],
|
||||
"command": "git cherry-pick C2 C4",
|
||||
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
|
||||
|
|
@ -949,7 +949,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby ukończyć ten poziom, po prostu skopiuj część pracy z trzech pokazanych gałęzi `main`. Commity, które należy skopiować znajdują się na wizualizacji celu.",
|
||||
"Aby ukończyć ten poziom, po prostu skopiuj część pracy z trzech pokazanych gałęzi do `main`. Commity, które należy skopiować, znajdują się na wizualizacji celu.",
|
||||
""
|
||||
]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ exports.level = {
|
|||
'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"
|
||||
"pl": "Odczep sobie HEAD"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Use the label (hash) on the commit for help!",
|
||||
|
|
@ -38,7 +38,7 @@ exports.level = {
|
|||
"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!",
|
||||
"pl": "Użyj nazwy commita (hasza)!",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -1217,7 +1217,7 @@ exports.level = {
|
|||
"",
|
||||
"Zanim przejdziemy do niektórych z bardziej zaawansowanych funkcji Gita, ważne jest, aby zrozumieć różne sposoby poruszania się po drzewie commitów, które reprezentują twój projekt.",
|
||||
"",
|
||||
"Kiedy będziesz już czuć się swobodnie, twoje moce z innymi komendami gitowymi zostaną wzmocnione!",
|
||||
"Kiedy już poczujesz się z tym wygodnie, to i inne komendy Gita nabiorą więcej mocy!",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
|
|
@ -1232,11 +1232,11 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## HEAD",
|
||||
"",
|
||||
"Najpierw musimy porozmawiać o \"HEAD\". HEAD to symboliczna nazwa dla aktualnie zcheckout'owanego commitu - jest to zasadniczo ostatni commit nad, którym pracowałeś.",
|
||||
"Najpierw musimy porozmawiać o \"HEAD\". HEAD to symboliczna nazwa dla aktualnie checkoutowanego (wyciągniętego) commita - jest to zasadniczo commit z najnowszymi zmianami.",
|
||||
"",
|
||||
"HEAD zawsze wskazuje na najnowszy commit, który jest odzwierciedlony w drzewie zmian. Większość poleceń git, które wprowadzają zmiany w drzewie, zaczyna się od zmiany HEAD'a.",
|
||||
"HEAD zawsze wskazuje na najnowszy commit, który jest odzwierciedlony w drzewie zmian. Większość poleceń git, które wprowadzają zmiany w drzewie, zaczyna się od zmiany HEADa.",
|
||||
"",
|
||||
"Normalnie HEAD wskazuje na nazwę gałęzi (jak np. `bugFix`). Kiedy commitujesz zmiany, status gałęzi `bugFix` się zmienia i zmiana ta jest widoczna właśnie poprzez przemieszczenie się HEAD'a."
|
||||
"Normalnie HEAD wskazuje na nazwę gałęzi (jak np. `bugFix`). Kiedy commitujesz zmiany, status gałęzi `bugFix` się zmienia i zmiana ta jest widoczna właśnie poprzez przemieszczenie się HEADa."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1244,7 +1244,7 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Sprawdźmy to w akcji. Pokażemy HEAD przed i po commicie."
|
||||
"Zobaczmy, jak to działa. Pokażemy HEAD przed i po commicie."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Zobacz! HEAD przez cały czas ukrywał się pod naszą gałęzią `main`."
|
||||
|
|
@ -1257,9 +1257,9 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"### Odłączanie HEAD'a",
|
||||
"### Odłączanie HEADa",
|
||||
"",
|
||||
"Odłączenie HEAD'a oznacza po prostu dołączenie go do commita, a nie gałęzi. Tak to wyglądało przed:",
|
||||
"Odłączenie HEADa oznacza po prostu dołączenie go do commita, a nie gałęzi. Tak to wyglądało przed:",
|
||||
"",
|
||||
"HEAD -> main -> C1",
|
||||
""
|
||||
|
|
@ -1277,9 +1277,9 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby ukończyć ten poziom, odłącz HEAD od gałęzi `bugFix` i dołącz go do commita.",
|
||||
"Aby ukończyć ten poziom, odłącz HEADa od gałęzi `bugFix` i dołącz go do commita.",
|
||||
"",
|
||||
"Możesz wybrać konkretnego commita posługując się jego haszem. Hasz każdego commita jest wyświetlany na okręgu, który go reprezentuje."
|
||||
"Możesz wybrać konkretnego commita, posługując się jego haszem. Hasz każdego commita jest wyświetlany na okręgu, który go reprezentuje."
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ exports.level = {
|
|||
"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",
|
||||
"pl": "Wprowadzenie do interaktywnego rebase'a",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -1030,11 +1030,11 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Interaktywny Rebase w Gitcie",
|
||||
"## Interaktywny rebase w Gicie",
|
||||
"",
|
||||
"Cherry-pick'ing jest świetny, gdy wiesz, które commity (_oraz_ znasz ich hasze) chcesz przenieść - trudno jest dyskutować z prostotą, którą zapewnia.",
|
||||
"Cherry-pick jest świetny, gdy wiesz, które commity chcesz przenieść (_oraz_ znasz ich hasze) - trudno jest dyskutować z prostotą, którą zapewnia.",
|
||||
"",
|
||||
"Ale co w sytuacji, gdy nie wiesz, które commity chcesz przenieść? Na szczęście git jest przygotowany również na tą sytuację! Możemy wykorzystać do tego interaktywny rebasing - to najlepszy sposób, aby przejrzeć serię commitów, które zamierzasz rebase'ować.",
|
||||
"Ale co w sytuacji, gdy nie wiesz, które commity chcesz przenieść? Na szczęście Git jest przygotowany również na tę sytuację! Możemy wykorzystać do tego interaktywny rebase - to najlepszy sposób, aby przejrzeć serię commitów, które zamierzasz rebase'ować (czyli: przebazować).",
|
||||
"",
|
||||
"Przejdźmy do szczegółów..."
|
||||
]
|
||||
|
|
@ -1046,9 +1046,9 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"Wszystkie interaktywne znaczniki rebase używają polecenia `rebase` z opcją `-i`.",
|
||||
"",
|
||||
"Jeśli włączysz tę opcję, git otworzy okno, aby pokazać ci, które commity mają być skopiowane poniżej wskazanego celu (np. HEAD'a) do rebase'a. W oknie pokażą się również wiadomości i hasze commitów, co zdecydowanie ułatwia zrozumienie co jest czym.",
|
||||
"Jeśli włączysz tę opcję, Git otworzy okno, aby pokazać ci, które commity mają być skopiowane poniżej wskazanego celu przebazowania (np. HEADa). W oknie pokażą się również wiadomości i hasze commitów, żeby ułatwić ci zrozumienie, co jest czym.",
|
||||
"",
|
||||
"Dla \"prawdziwego\" gita, otwarte okno oznacza otwarcie pliku w edytorze tekstu takim jak np. `vim`. Dla naszych potrzeb, zbudowałem małe okno dialogowe, które zachowuje się tak samo."
|
||||
"Dla \"prawdziwego\" Gita otwarte okno oznacza otwarcie pliku w edytorze tekstu, takim jak np. `vim`. Dla naszych potrzeb zbudowałem małe okno dialogowe, które zachowuje się tak samo."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1056,14 +1056,14 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Kiedy otworzy się okno dialogowe do interaktywnego rebase'a, masz możliwość zrobienia dwóch rzeczy w naszej aplikacji edukacyjnej:",
|
||||
"Kiedy otworzy się okno dialogowe do interaktywnego przeabazowania, masz możliwość zrobienia dwóch rzeczy w naszej aplikacji edukacyjnej:",
|
||||
"",
|
||||
"* Możesz zmienić kolejność commitów poprzez zmianę ich kolejności w oknie (przeciągając je i upuszczając).",
|
||||
"* Możesz zdecydować się na całkowite pominięcie niektórych commitów. Jest to oznaczone przez `pick`. Wpisanie `pick off` oznacza, że nie chcesz uwzględnić tego commitu.",
|
||||
"* Możesz zmienić kolejność commitów, po prostu przeciągając i upuszczając je myszką w oknie.",
|
||||
"* Możesz zdecydować się zachować wszystkie commity lub pominąć niektóre z nich. Jest to oznaczone przez aktywny przycisk `pick`. Wyłączenie przycisku spowoduje pominięciu commitu.",
|
||||
"",
|
||||
"* Warto wspomnieć, że w prawdziwym interaktywnym rebasie możesz zrobić wiele innych rzeczy, takich jak squash (łączenie) commitów, poprawianie wiadomości commitów, a nawet edycja samych commitów. Dla naszych potrzeb jednak skupimy się na tych dwóch operacjach powyżej.",
|
||||
"* Warto wspomnieć, że w prawdziwym interaktywnym rebase'ie możesz zrobić wiele innych rzeczy, takich jak squash (łączenie) commitów, poprawianie wiadomości commitów, a nawet edycja samych commitów. Dla naszych potrzeb jednak wystarczy, że skupimy się na dwóch omówionych operacjach.",
|
||||
"",
|
||||
"Świetnie! Spójrz na przykład."
|
||||
"Świetnie! Spójrzmy na przykład."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1071,10 +1071,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Po naciśnięciu przycisku, pojawi się interaktywne okno rebase'owania. Zmień kolejność niektórych commitów (lub usuń niektóre z nich, a co!) i zobacz wynik!"
|
||||
"Po naciśnięciu przycisku pojawi się interaktywne okno przebazowania. Zmień kolejność niektórych commitów (lub usuń niektóre z nich, a co!) i zobacz wynik!"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Boom! Git skopiował commity w ten sam sposób w jaki podałeś to w oknie."
|
||||
"Tadam! Git skopiował commity w sposób podany w oknie."
|
||||
],
|
||||
"command": "git rebase -i HEAD~4 --aboveAll",
|
||||
"beforeCommand": "git commit; git commit; git commit; git commit"
|
||||
|
|
@ -1084,7 +1084,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby ukończyć ten poziom, zrób interaktywny rebase i osiągnij kolejność pokazaną w wizualizacji celu. Pamiętaj, że zawsze możesz użyć komend `undo` lub `reset` aby naprawić błędy :D"
|
||||
"Aby ukończyć ten poziom, zrób interaktywny rebase i ustaw kolejność pokazaną w wizualizacji celu. Pamiętaj, że zawsze możesz użyć `undo` lub `reset`, aby naprawić błędy :D"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ exports.level = {
|
|||
"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 (^)!",
|
||||
"pl": "Pamiętaj o operatorze wstawienia (^)!",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -1174,11 +1174,11 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Relatywne referencje",
|
||||
"",
|
||||
"Poruszanie się w Gitcie poprzez określanie haszy commitów może być trochę nudne. W prawdziwym świecie nie będziesz miał ładnej wizualizacji drzewa commitów obok swojego terminalu (chyba, że będziesz używać Fork'a lub TortoiseGit'a). Będziesz musiał użyć `git log` aby zobaczyć hasz.",
|
||||
"Poruszanie się w Gicie poprzez określanie haszy commitów może być trochę nudne. W prawdziwym świecie nie zobaczysz ładnej wizualizacji drzewa commitów obok swojego terminala (chyba, że używasz Forka lub TortoiseGita). Musisz użyć `git log`, aby zobaczyć hasze.",
|
||||
"",
|
||||
"Co więcej, hasz jest zazwyczaj o wiele dłuższy w prawdziwym Gitcie. Na przykład, hash commitu, które był na początku poprzedniego poziomu to `fed2da64c0efc5293610bdd892f82a58e8cbc5d8`. Spróbuj to przeczytać!",
|
||||
"Co więcej, hasze są zazwyczaj o wiele dłuższe w prawdziwym Gicie. Na przykład hash commita, który był na początku poprzedniego poziomu, to `fed2da64c0efc5293610bdd892f82a58e8cbc5d8`. Spróbuj to przeczytać!",
|
||||
"",
|
||||
"Plusem jest to, że Git jest sprytny jeżeli chodzi o hasze. Wymaga jedynie podania tylu znaków haszu, aż do momentu, gdy jednoznacznie zidentyfikuje konkretny commit. Dlatego mogę wpisać jedynie `fed2` zamiast długiego łańcucha powyżej."
|
||||
"Plusem jest to, że Git sprytnie radzi sobie z haszami. Wymaga jedynie podania tylu znaków hasza, ile potrzebuje, aby jednoznacznie zidentyfikować konkretny commit. Dlatego mogę wpisać jedynie `fed2` zamiast długiego łańcucha powyżej."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1186,14 +1186,14 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Jak już powiedzieliśmy, wybieranie commitów używając ich hasza nie jest najprzyjemniejszą rzeczą w życiu, dlatego Git ma referencje względne. Są niesamowite!",
|
||||
"Jak już powiedzieliśmy, wybieranie commitów, używając ich hasza, nie jest najprzyjemniejszą rzeczą w życiu, dlatego Git ma referencje względne. Są niesamowite!",
|
||||
"",
|
||||
"Korzystając z referencji względnych, możesz zacząć od miejsca, które zapamiętasz (jak np. gałąź `bugFix` lub `HEAD`) i pracować stamtąd.",
|
||||
"Korzystając z referencji względnych, możesz zacząć od miejsca, które zapamiętasz (jak np. gałąź `bugFix` lub `HEAD`), i pracować stamtąd.",
|
||||
"",
|
||||
"Relatywne commity są potężne, ale pokażemy tu tylko dwie proste sytuacje:",
|
||||
"",
|
||||
"* Poruszanie się wstecz o jeden commit `^`",
|
||||
"* Poruszanie się wstecz o ileś commitów `~<num>`"
|
||||
"* Poruszanie się wstecz o jeden commit za pomocą `^`",
|
||||
"* Poruszanie się wstecz o ileś commitów z `~<num>`"
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1203,14 +1203,14 @@ exports.level = {
|
|||
"beforeMarkdowns": [
|
||||
"Spójrzmy najpierw na operator Karety / daszek (^). Za każdym razem, gdy dodajesz go do referencji względnej, mówisz Gitowi, aby znalazł rodzica określonego commita.",
|
||||
"",
|
||||
"Więc wpisując `main^` mamy na myśli \"pierwszego rodzica z gałęzi `main`\".",
|
||||
"Więc wpisując `main^`, mamy na myśli \"pierwszego rodzica z gałęzi `main`\".",
|
||||
"",
|
||||
"`main^^` to dziadek (przodek drugiego stopnia) gałęzi `main`",
|
||||
"",
|
||||
"Zcheckoutujmy commit powyżej `main`."
|
||||
"checkoutujmy commit powyżej `main`."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Boom! Zrobione. O wiele łatwiej niż wpisując hasz commitu."
|
||||
"Tadam! Gotowe! O wiele łatwiej niż wpisując hasz commita."
|
||||
],
|
||||
"command": "git checkout main^",
|
||||
"beforeCommand": "git commit"
|
||||
|
|
@ -1223,7 +1223,7 @@ exports.level = {
|
|||
"Możesz również odwołać się do `HEAD` jako referencji względnej. Użyjmy tego kilka razy, aby przesunąć się w górę drzewa commitów."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Łatwizna! Możemy podróżować do tyłu w czasie używając `HEAD^`"
|
||||
"Łatwizna! Możemy cofać się w czasie, używając `HEAD^`"
|
||||
],
|
||||
"command": "git checkout C3; git checkout HEAD^; git checkout HEAD^; git checkout HEAD^",
|
||||
"beforeCommand": "git commit; git commit"
|
||||
|
|
@ -1233,9 +1233,9 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby ukończyć ten poziom, zcheckoutuj commit'a-rodzica z gałęzi `bugFix`. To spowoduje odczepienie `HEAD`a.",
|
||||
"Aby ukończyć ten poziom, checkoutuj commita-rodzica z gałęzi `bugFix`. To spowoduje odczepienie `HEADa`.",
|
||||
"",
|
||||
"Możesz wybrać commit'a po haszu jeżeli chcesz, ale spróbuj wykorzystać to czego się nauczyłeś i użyć referencji względnej!"
|
||||
"Możesz wybrać commita po haszu, jeżeli chcesz, ale spróbuj wykorzystać nowe umiejętności i użyć referencji względnej!"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ exports.level = {
|
|||
"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).",
|
||||
"pl": "Aby ukończyć ten poziom, musisz użyć co najmniej jednej bezpośredniej referencji (hasza).",
|
||||
},
|
||||
"name": {
|
||||
"en_US": "Relative Refs #2 (~)",
|
||||
|
|
@ -1068,10 +1068,10 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"### Operator \"~\"",
|
||||
"",
|
||||
"Powiedzmy, że chcesz przejść o wiele poziomów wstecz na drzewie commitów. Wielokrotne wpisywanie `^` może być męczące. Na tą okazję Git ma również operator - tyldę (~).",
|
||||
"Powiedzmy, że chcesz przejść o wiele poziomów wstecz na drzewie commitów. Wielokrotne wpisywanie `^` może być męczące. Na tę okazję Git ma również operator - tyldę (~).",
|
||||
"",
|
||||
"",
|
||||
"Operator tyldy (opcjonalnie) przyjmuje numer porządkowy, który określa liczbę rodziców o ile chcesz się wspiąć. Zobaczmy to w akcji."
|
||||
"Do operatora tyldy możesz (opcjonalnie) dodać numer, który określa, o jaką liczbę rodziców chcesz się cofnąć. Zobaczmy, jak to działa."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1079,10 +1079,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Podajmy liczbę commitów, które chcemy przeskoczyć za `~`."
|
||||
"Podajmy liczbę commitów, które chcemy przeskoczyć, za `~`."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Boom! Tak szybko - referencje względne są czadowe."
|
||||
"Tadam! Ale szybko - referencje względne są czadowe."
|
||||
],
|
||||
"command": "git checkout HEAD~4",
|
||||
"beforeCommand": "git commit; git commit; git commit"
|
||||
|
|
@ -1092,15 +1092,15 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Forsowanie branczy",
|
||||
"### Forsowanie gałęzi",
|
||||
"",
|
||||
"Jesteś teraz ekspertem ds. referencji. *Wykorzystajmy* je do czegoś.",
|
||||
"",
|
||||
"Jednym z najczęstszych sposobów, w jaki korzystam z referencji względnych, są działania na gałęziach. Możesz bezpośrednio przypisać gałąź do commita za pomocą opcji `-f`. Coś w tym stylu:",
|
||||
"Jednym z najczęstszych sposobów, w jaki korzystam z referencji względnych, są działania na gałęziach. Możesz bezpośrednio przypisać gałąź do commita za pomocą opcji `-f`. Na przykład tak:",
|
||||
"",
|
||||
"`git branch -f main HEAD~3`",
|
||||
"",
|
||||
"przenosi (na siłę) gałąź `main` trzy commity wstecz za HEADa."
|
||||
"przenosi (na siłę) gałąź `main` trzy commity wstecz - za HEADa."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1108,10 +1108,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Sprawdźmy poprzednią komendę w akcji."
|
||||
"Zobaczmy, jak działa poprzednie polecenie."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Proszę bardzo! Referencje względne umożliwiły w zwięzły sposób, by odnieść się do `C1`, a forsowanie gałęzi (`-f`) pozwoliło na szybkie przeniesienie gałęzi w to konkretne miejsce."
|
||||
"Proszę bardzo! Referencje względne umożliwiły ci odnieść się w zwięzły sposób do `C1`, a forsowanie gałęzi (`-f`) pozwoliło na szybkie przeniesienie gałęzi w to konkretne miejsce."
|
||||
],
|
||||
"command": "git branch -f main HEAD~3",
|
||||
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
|
||||
|
|
@ -1121,9 +1121,9 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Teraz, gdy poznałeś referencje względne i forsowanie gałęzi w połączeniu, użyj ich do rozwiązania następnego poziomu.",
|
||||
"Teraz, gdy wiesz już, jak połączyć referencje względne i forsowanie gałęzi, użyj ich do rozwiązania następnego poziomu.",
|
||||
"",
|
||||
"Aby ukończyć ten poziom przenieś `HEAD`, `main` oraz `bugFix` do wyświetlonych celów."
|
||||
"Aby ukończyć ten poziom, przenieś `HEAD`, `main` oraz `bugFix` do wskazanych celów."
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ exports.level = {
|
|||
"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",
|
||||
"pl": "Odwracanie zmian w Gicie",
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Notice that revert and reset take different arguments.",
|
||||
|
|
@ -995,9 +995,9 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Odwracanie zmian w Gitcie",
|
||||
"## Odwracanie zmian w Gicie",
|
||||
"",
|
||||
"Istnieje wiele sposobów na odwrócenie zmian w Gicie. Podobnie jak w przypadku commitowania, odwracanie zmian w Gitcie ma zarówno komponent niskopoziomowy (zapisywanie stanów plików lub ich fragmentów), jak i wysokopoziomowy (sposób, w jaki zmiany są faktycznie odwracane). Nasza aplikacja skupi się na tym ostatnim.",
|
||||
"Istnieje wiele sposobów na odwrócenie zmian w Gicie. Podobnie jak w przypadku commitowania, odwracanie zmian w Gicie ma zarówno komponent niskopoziomowy (zapisywanie stanów plików lub ich fragmentów), jak i wysokopoziomowy (sposób, w jaki zmiany są faktycznie odwracane). Nasza aplikacja skupi się na tym ostatnim.",
|
||||
"",
|
||||
"Istnieją dwa podstawowe sposoby na cofnięcie zmian w Gicie - jeden z nich to `git reset`, a drugi `git revert`. Przyjrzymy się każdemu z nich w następnym oknie",
|
||||
""
|
||||
|
|
@ -1010,12 +1010,12 @@ exports.level = {
|
|||
"beforeMarkdowns": [
|
||||
"## Git Reset",
|
||||
"",
|
||||
"`git reset` odwraca zmiany poprzez przesunięcie referencji gałęzi wstecz w czasie do starszego commita. Można myśleć o tym jako \"przepisywaniu historii\", \"resetowanie\" spowoduje cofnięcie gałęzi do tyłu, tak jakby commity powyżej nigdy nie zostały dodane.",
|
||||
"`git reset` odwraca zmiany poprzez przesunięcie referencji gałęzi wstecz w czasie do starszego commita. Można myśleć o tym jako \"przepisywaniu historii\", \"resetowanie\" spowoduje cofnięcie gałęzi, tak jakby commit nigdy nie został dodany.",
|
||||
"",
|
||||
"Sprawdźmy jak to działa:"
|
||||
"Sprawdźmy, jak to działa:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Świetnie! Git przeniósł referencję gałęzi `main` do `C1`; teraz nasze lokalne repozytoriu jest w stanie, jakby commit `C2` nigdy nie powstał."
|
||||
"Nieźle! Git przeniósł referencję gałęzi `main` do `C1`; teraz nasze lokalne repozytorium jest w takim stanie, jakby commita `C2` nigdy nie było."
|
||||
],
|
||||
"command": "git reset HEAD~1",
|
||||
"beforeCommand": "git commit"
|
||||
|
|
@ -1027,14 +1027,14 @@ exports.level = {
|
|||
"beforeMarkdowns": [
|
||||
"## Git Revert",
|
||||
"",
|
||||
"Podczas gdy resetowanie działa świetnie dla lokalnych gałęzi na własnej maszynie, jego metoda \"przepisywania historii\" nie działa dla gałęzi zdalnych, które są używane przez innych.",
|
||||
"Mimo że resetowanie działa świetnie w przypadku lokalnych gałęzi na twoim komputerze, jego metoda \"przepisywania historii\" nie działa dla gałęzi zdalnych, które są używane przez innych.",
|
||||
"",
|
||||
"W celu odwrócenia zmian i *podzielenia się* tymi odwróconymi zmianami z innymi, musimy użyć `git revert`. Zobaczmy to w akcji."
|
||||
"W celu odwrócenia zmian i *podzielenia się* nimi z innymi, musimy użyć `git revert`. Zobaczmy, jak to działa."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Dziwne, nowy commit spadł poniżej zobowiązania, które chcieliśmy odwrócić. To dlatego, że to nowy commit `C2'` wprowadza *zmiany* -- tak się składa, że wprowadza zmiany, które idealnie odwracają commit `C2`.",
|
||||
"Dziwne, nowy commit spadł poniżej tego, który chcieliśmy odwrócić. To dlatego, że ten nowy commit `C2'` wprowadza *zmiany* -- akurat takie, które idealnie odwracają commit `C2`.",
|
||||
"",
|
||||
"Dzięki `git revert`, możesz wypchnąć swoje zmiany, by podzielić się nimi z innymi."
|
||||
"Dzięki `git revert` możesz wypchnąć swoje zmiany, by podzielić się nimi z innymi."
|
||||
],
|
||||
"command": "git revert HEAD",
|
||||
"beforeCommand": "git commit"
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ exports.level = {
|
|||
"vi": "Rebase hơn 9000 lần",
|
||||
"sl_SI": "Več kot 9000 Rebaseov",
|
||||
"it_IT": "Rebasing livello 8000",
|
||||
"pl" : "Rebase ponad 9000 razy"
|
||||
"pl": "Rebase ponad 8000 razy"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember, the most efficient way might be to only update main at the end...",
|
||||
|
|
@ -44,7 +44,7 @@ exports.level = {
|
|||
"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..."
|
||||
"pl": "Pamiętaj, że najskuteczniejszym sposobem może być aktualizacja `main` dopiero na samym końcu..."
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -322,13 +322,13 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Rebase Wielu Gałęzi",
|
||||
"### Rebase wielu gałęzi",
|
||||
"",
|
||||
"Człowieku, mamy tu wiele gałęzi! Przeniesiemy wszystkie prace z tych gałęzi na `main`.",
|
||||
"Człowieku, ależ tu pełno gałęzi! Przenieśmy wszystkie prace z tych gałęzi na `main`.",
|
||||
"",
|
||||
"Kierownictwo nieco bardziej utrudnia temat -- chcą, aby wszystkie commity były w odpowiedniej kolejności. Oznacza to, że nasze końcowe drzewo powinno mieć `C7'` na dole, `C6'` powyżej, i tak dalej.",
|
||||
"Kierownictwo trochę utrudnia sprawę -- chcą, aby wszystkie commity były w odpowiedniej kolejności. Oznacza to, że nasze końcowe drzewo powinno mieć `C7'` na dole, `C6'` powyżej i tak dalej.",
|
||||
"",
|
||||
"Jeśli po drodze namieszasz, nie krępuj się użyć `reset`, aby zacząć od nowa. Przeanalizuj nasze rozwiązanie i sprawdź, czy dasz radę to zrobić używając mniej poleceń!"
|
||||
"Jeśli po drodze namieszasz, nie krępuj się użyć `reset`, aby zacząć od nowa. Przeanalizuj nasze rozwiązanie i sprawdź, czy dasz radę to zrobić, używając mniejszej liczby poleceń!"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ exports.level = {
|
|||
"vi": "Nhánh rối như canh hẹ",
|
||||
"sl_SI": "Špageti iz Branchev",
|
||||
"it_IT": "Rami spaghettificati",
|
||||
"pl": "Gałęziowe Spaghetti",
|
||||
"pl": "Spaghetti gałęzi",
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Make sure to do everything in the proper order! Branch one first, then two, then three",
|
||||
|
|
@ -350,15 +350,15 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Gałęziowe Spaghetti",
|
||||
"## Spaghetti gałęzi",
|
||||
"",
|
||||
"W mordę jeża! Na tym poziomie mamy całkiem spory cel do osiągnięcia..",
|
||||
"Łałałiła! Na tym poziomie mamy poważny cel do osiągnięcia..",
|
||||
"",
|
||||
"Mamy tutaj gałąź `main`, która jest kilka commitów przed gałęziami `one` `two` i `three`. Z jakiegoś powodu, musimy zaktualizować te trzy inne gałęzie zmodyfikowanymi wersjami ostatnich kilku commitów na main.",
|
||||
"Mamy tutaj gałąź `main`, która jest kilka commitów przed gałęziami `one`, `two` i `three`. Z jakiegoś powodu musimy zaktualizować te trzy inne gałęzie zmodyfikowanymi wersjami ostatnich kilku commitów na main.",
|
||||
"",
|
||||
"Gałąź `one` wymaga zmiany kolejności i usunięcia `C5`. `two` potrzebuje wyłącznie zmiany kolejności, a `three` potrzebuje tylko jednego commitu!",
|
||||
"Gałąź `one` wymaga zmiany kolejności i usunięcia `C5`. `two` potrzebuje wyłącznie zmiany kolejności, a `three` potrzebuje tylko przeniesienia jednego commitu!",
|
||||
"",
|
||||
"Zastanów się, jak rozwiązać to zadanie -- upewnij się i sprawdź nasze rozwiązanie po wykonaniu zadania za pomocą `show solution`. "
|
||||
"Samodzielnie zastanów się, jak rozwiązać to zadanie -- po wykonaniu go koniecznie sprawdź nasze rozwiązanie za pomocą `show solution`. "
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -900,17 +900,17 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Zdalny git",
|
||||
"## Zdalny Git",
|
||||
"",
|
||||
"Zdalne repozytoria nie są w rzeczywistości takie skomplikowane. W dzisiejszym świecie przetwarzania w chmurze łatwo jest pomyśleć, że za zdalnym gitem kryje się wiele magii, ale w rzeczywistości są to tylko kopie repozytorium na innym komputerze. Zwykle możesz komunikować się z innym komputerem przez Internet, co umożliwia przesyłanie commitów tam i z powrotem. ",
|
||||
"Zdalne repozytoria nie są w rzeczywistości bardzo skomplikowane. W dzisiejszym, działającym w chmurze, świecie łatwo jest uznać, że za zdalnym Gitem kryje jakaś wielka magia, ale w rzeczywistości są to tylko kopie twojego repozytorium na innym komputerze. Zazwyczaj możesz połączyć się z nim przez internet, co umożliwia przesyłanie commitów tam i z powrotem. ",
|
||||
"",
|
||||
"Mówiąc to, zdalne repozytoria mają kilka świetnych właściwości:",
|
||||
"Ale oczywiście zdalne repozytoria mają kilka świetnych właściwości:",
|
||||
"",
|
||||
"- Przede wszystkim zdalne repozytoria służą jako świetna kopia zapasowa! Lokalne repozytoria git mają możliwość przywracania plików do poprzedniego stanu (jak wiesz), ale wszystkie te informacje są przechowywane lokalnie. Mając kopie repozytorium git na innych komputerach, możesz stracić wszystkie swoje dane lokalne i kontynuować pracę od miejsca, w którym przerwałeś.",
|
||||
"- Przede wszystkim zdalne repozytoria służą jako świetna kopia zapasowa! Lokalne repozytoria Git (jak już wiesz) mają możliwość przywracania plików do poprzedniego stanu, ale wszystkie te informacje są przechowywane lokalnie. Mając kopie repozytorium Git na innych komputerach, nawet jeśli stracisz wszystkie swoje dane lokalne, i tak możesz kontynuować pracę od tego samego miejsca.",
|
||||
"",
|
||||
"- Co ważniejsze, zdalne repozytoria sprawiają, że kodowanie jest społeczne! Teraz gdy kopia twojego projektu jest umieszczona gdzie indziej, twoi znajomi mogą bardzo łatwo wnieść wkład do twojego projektu (lub pobrać najnowsze zmiany).",
|
||||
"- Co ważniejsze, zdalne repozytoria sprawiają, że kodowanie jest społeczne! Teraz, gdy kopia twojego projektu jest umieszczona gdzie indziej, twoi znajomi mogą bardzo łatwo wnieść swój wkład do twojego projektu (lub pobrać najnowsze zmiany).",
|
||||
"",
|
||||
"Bardzo popularne stało się korzystanie ze stron internetowych, które wizualizują aktywność wokół zdalnych repozytoriów (takich jak [GitHub](https://github.com/) lub [Phabricator](http://phabricator.org/)), ale zdalne repozytoria _zawsze_ służą jako podstawa tych narzędzi. Dlatego ważne jest, aby je zrozumieć!"
|
||||
"Bardzo popularne stało się korzystanie ze stron internetowych, które wizualizują aktywność w zdalnych repozytoriach (takich jak [GitHub](https://github.com/) lub [Phabricator](http://phabricator.org/)), ale podstawą tych narzędzi _zawsze_ są zdalne repozytoria. Dlatego ważne jest, aby je zrozumieć!"
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -920,9 +920,9 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Polecenia do tworzenia zdalnych repozytoriów",
|
||||
"",
|
||||
"Do tego momentu Learn Git Branching skupiało się na nauczaniu podstaw pracy z repozytoriami _lokalnymi_ (branch, merge, rebase itp.). Jednak teraz, gdy chcemy dowiedzieć się więcej o pracy ze zdalnym repozytorium, potrzebujemy polecenia, aby skonfigurować środowisko dla tych lekcji. Tym poleceniem będzie `git clone`.",
|
||||
"Do tego momentu kurs Learn Git Branching skupiał się na nauczaniu podstaw pracy z repozytoriami _lokalnymi_ (branch, merge, rebase itp.). Jednak teraz, gdy chcemy dowiedzieć się więcej o pracy ze zdalnym repozytorium, potrzebujemy polecenia, aby skonfigurować środowisko tych lekcji. Tym poleceniem będzie `git clone`.",
|
||||
"",
|
||||
"Technicznie rzecz biorąc, `git clone` w prawdziwym świecie jest poleceniem, którego będziesz używać do tworzenia _lokalnych_ kopii zdalnych repozytoriów (na przykład z github). Używamy tego polecenia nieco inaczej w Learn Git Branching -- `git clone` faktycznie tworzy zdalne repozytorium z lokalnego. Jasne, jest to technicznie odwrotne znaczenie prawdziwego polecenia, ale pomaga zbudować połączenie między klonowaniem a pracą zdalnego repozytorium, więc na razie uruchommy to.",
|
||||
"Technicznie rzecz biorąc, `git clone` w prawdziwym świecie jest poleceniem, którego będziesz używać do tworzenia _lokalnych_ kopii zdalnych repozytoriów (na przykład z github). Używamy tego polecenia nieco inaczej w Learn Git Branching -- `git clone` faktycznie tworzy zdalne repozytorium z lokalnego. Jasne, jest to technicznie odwrotne znaczenie prawdziwego polecenia, ale pomaga zrozumieć zależność między klonowaniem a pracą na zdalnym repozytorium, więc na razie zobaczmy, jak to wygląda w działaniu.",
|
||||
""
|
||||
]
|
||||
}
|
||||
|
|
@ -935,7 +935,7 @@ exports.level = {
|
|||
""
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Tu jest! Teraz mamy zdalne repozytorium naszego projektu. Wygląda dość podobnie, z wyjątkiem pewnych zmian wizualnych, aby rozróżnienie było widoczne -- na kolejnych poziomach zobaczysz, jak udostępniamy pracę w tych repozytoriach."
|
||||
"No i jest! Teraz mamy zdalne repozytorium naszego projektu. Wygląda dość podobnie, z wyjątkiem pewnych wizualnych zmian pomagających odróżnić je od lokalnego -- na kolejnych poziomach zobaczysz, jak udostępniamy pracę w tych repozytoriach."
|
||||
],
|
||||
"command": "git clone",
|
||||
"beforeCommand": ""
|
||||
|
|
@ -945,7 +945,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby ukończyć ten poziom po prostu wpisz `git clone` na swoim repozytorium. Prawdziwa nauka przyjdzie w następnych lekcjach."
|
||||
"Aby ukończyć ten poziom, po prostu wpisz `git clone` na swoim repozytorium. Czas na prawdziwą naukę przyjdzie w kolejnych lekcjach."
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ exports.level = {
|
|||
"ko": "가장할 커밋의 갯수를 조절할 수 있습니다.",
|
||||
"vi": "Nhớ rằng bạn có thể chỉ định số lượng commit để giả lập.",
|
||||
"sl_SI": "Spomni se, da lahko določiš število lažnih commitov.",
|
||||
"pl" : "pamiętaj, że możesz określić liczbę commitów do podrobienia",
|
||||
"pl": "Pamiętaj, że możesz określić liczbę symulowanych commitów",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -859,11 +859,11 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Symulacja pracy zespołowej",
|
||||
"",
|
||||
"Więc tutaj jest trudna rzecz -- na potrzeby niektórych z nadchodzących lekcji, musimy nauczyć Cię jak ściągać zmiany, które zostały wprowadzone na zdalnej gałęzi przez innych.",
|
||||
"Pora na małe oszustwo -- na potrzeby niektórych z nadchodzących lekcji musimy nauczyć cię, jak ściągać (pull) zmiany, które zostały wprowadzone na zdalnej gałęzi przez innych.",
|
||||
"",
|
||||
"Oznacza to, że musimy zasadniczo \"udawać\", że gałąź zdalna została zaktualizowana przez jednego z twoich współpracowników / przyjaciół / współtwórców, na określonej gałęzi lub określonej liczbie commitów.",
|
||||
"W zasadzie oznacza to, że musimy \"udawać\", że zdalne repozytorium zostało zaktualizowane przez jednego z twoich współpracowników / przyjaciół / współtwórców na jakiejś gałęzi lub kilku commitach.",
|
||||
"",
|
||||
"Aby to zrobić, wprowadziliśmy trafnie nazwaną komendę `git fakeTeamwork`! Jest to dość oczywiste, zobaczmy demo. . ."
|
||||
"Aby to zrobić, wprowadziliśmy polecenie `git fakeTeamwork`! Po polsku byłoby to symulujPracę :D -- zobaczmy, jak to działa..."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -871,7 +871,7 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Domyślnym zachowaniem `fakeTeamwork` jest po prostu umieszczenie commitu na gałęzi main."
|
||||
"Domyślnym zachowaniem `fakeTeamwork` jest po prostu wrzucenie commita na gałąź main."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Proszę bardzo - zdalny serwer został zaktualizowany o nowy commit, a my jeszcze go nie pobraliśmy, ponieważ nie uruchomiliśmy `git fetch`."
|
||||
|
|
@ -887,7 +887,7 @@ exports.level = {
|
|||
"Możesz również określić liczbę commitów lub gałąź poprzez dołączenie ich do polecenia."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Za pomocą jednej komendy symulujemy, że kolega z zespołu wypycha trzy commity do gałęzi `foo` na naszej gałęzi zdalnej."
|
||||
"Jednym poleceniem symulujemy, że kolega z zespołu wypycha trzy commity do gałęzi `foo` na zdalnym repozytorium."
|
||||
],
|
||||
"command": "git fakeTeamwork foo 3",
|
||||
"beforeCommand": "git branch foo; git clone"
|
||||
|
|
@ -897,9 +897,9 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Nadchodzące poziomy będą dość trudne, więc prosimy Cię o większe niż zazwyczaj skupienie na tym poziomie.",
|
||||
"Kolejne poziomy będą dość trudne, więc tym razem twoje zadanie też jest bardziej wymagające.",
|
||||
"",
|
||||
"Nie bój się, stwórz zdalną gałąź (używając `git clone`), podrób kilka zmian na zdalnej gałęzi, zcommituj swoje zmiany, a następnie ściągnij te zmiany. To jak kilka lekcji w jednej!"
|
||||
"Nie bój się, stwórz zdalne repozytorium (używając `git clone`), zasymuluj na nim kilka zmian i zatwierdź je, a następnie ściągnij (pull) je. To jak kilka lekcji w jednej!"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ exports.level = {
|
|||
"ko": "Git Fetch",
|
||||
"vi": "Git Fetch",
|
||||
"sl_SI": "Git Fetch",
|
||||
"pl" : "Git Fetch"
|
||||
"pl": "Git fetch"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "just run git fetch!",
|
||||
|
|
@ -1140,13 +1140,13 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git Fetch",
|
||||
"## Git fetch",
|
||||
"",
|
||||
"Praca z zdalnymi gitami tak naprawdę sprowadza się do przesyłania danych _do_ i _z_ innych repozytoriów. Tak długo jak możemy przesyłać zatwierdzenia tam i z powrotem, możemy udostępniać wszelkiego rodzaju aktualizacje śledzone przez git (a tym samym dzielić się pracą, nowymi plikami, pomysłami, listami miłosnymi itp.).",
|
||||
"Praca ze zdalnymi Gitami tak naprawdę sprowadza się do przesyłania danych _do_ i _z_ innych repozytoriów. Tak długo jak możemy przesyłać zatwierdzenia tam i z powrotem, możemy udostępniać wszelkiego rodzaju aktualizacje śledzone przez Git (a tym samym dzielić się pracą, nowymi plikami, pomysłami, listami miłosnymi itp.).",
|
||||
"",
|
||||
"W tej lekcji nauczymy się, jak pobierać dane _z_ zdalnego repozytorium -- polecenie to nosi nazwę `git fetch`.",
|
||||
"W tej lekcji nauczymy się, jak pobierać dane _ze_ zdalnego repozytorium -- polecenie to nosi nazwę `git fetch`.",
|
||||
"",
|
||||
"Zauważysz, że gdy aktualizujemy naszą reprezentację zdalnego repozytorium, nasze _zdalne_ gałęzie zostaną zaktualizowane, aby odzwierciedlić tę nową reprezentację. Wiąże się to z poprzednią lekcją dotyczącą zdalnych gałęzi."
|
||||
"Zauważysz, że gdy aktualizujemy reprezentację zdalnego repozytorium, nasze _zdalne_ gałęzie zostaną zaktualizowane, aby odzwierciedlić tę nową reprezentację. Wiąże się to z poprzednią lekcją dotyczącą zdalnych gałęzi."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1154,10 +1154,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Zanim przejdziemy do szczegółów polecenia `git fetch`, zobaczmy, jak działa! Tutaj mamy zdalne repozytorium, które zawiera dwa commity, których nie ma w naszym lokalnym repozytorium."
|
||||
"Zanim przejdziemy do szczegółów polecenia `git fetch`, zobaczmy, jak działa! Mamy tu zdalne repozytorium, zawierające dwa commity, których nie ma w naszym lokalnym repozytorium."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"No to jedziemy! Commity `C2` i `C3` zostały pobrane do naszego lokalnego repozytorium, a nasza zdalna gałąż `o/main` została zaktualizowana, aby to odzwierciedlić."
|
||||
"No to jedziemy! Commity `C2` i `C3` zostały pobrane do naszego lokalnego repozytorium, a zdalna gałąź `o/main` została zaktualizowana, aby to odzwierciedlić."
|
||||
],
|
||||
"command": "git fetch",
|
||||
"beforeCommand": "git clone; git fakeTeamwork 2"
|
||||
|
|
@ -1169,16 +1169,16 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"### Co robi fetch",
|
||||
"",
|
||||
"`git fetch` wykonuje dwie rzeczy. Są to:",
|
||||
"`git fetch` wykonuje dwie rzeczy:",
|
||||
"",
|
||||
"* pobiera commity, które są w zdalnym repozytorium, ale których brakuje w naszym lokalnym repozytorium i...",
|
||||
"* aktualizuje miejsce, które wskazują nasze zdalne gałęzie (na przykład `o/main`)",
|
||||
"* aktualizuje miejsca, które wskazują nasze zdalne gałęzie (na przykład `o/main`)",
|
||||
"",
|
||||
"`git fetch` zasadniczo synchronizuje _lokalną_ reprezentację zdalnego repozytorium z tym jak w _rzeczywistości_ wygląda zdalne repozytorium (w danej chwili).",
|
||||
"`git fetch` zasadniczo synchronizuje _lokalną_ reprezentację zdalnego repozytorium z tym, jak w _rzeczywistości_ zdalne repozytorium wygląda (w danej chwili).",
|
||||
"",
|
||||
"Jak pamiętasz z poprzedniej lekcji, powiedzieliśmy, że zdalne gałęzie odzwierciedlają stan zdalnych repozytoriów od czasu, gdy ostatnio komunikowałeś się z tymi repozytoriami. `git fetch` to sposób, w jaki rozmiawiasz z tymi repozytoriami! Mamy nadzieję, że związek między zdalnymi gałęziami a `git fetch` jest teraz widoczny.",
|
||||
"Jak pamiętasz z poprzedniej lekcji, powiedzieliśmy, że zdalne gałęzie odzwierciedlają stan zdalnych repozytoriów od czasu ostatniej komunikacji nimi. `git fetch` to sposób, w jaki rozmiawiasz z tymi repozytoriami! Mamy nadzieję, że związek między zdalnymi gałęziami a `git fetch` jest teraz jasny.",
|
||||
"",
|
||||
"`git fetch` zwykle komunikuje się z zdalnym repozytorium przez Internet (za pośrednictwem protokołu takiego jak `http://` lub `git://`).",
|
||||
"`git fetch` zwykle komunikuje się ze zdalnym repozytorium przez internet (za pośrednictwem protokołu takiego jak `http://` lub `git://`).",
|
||||
""
|
||||
]
|
||||
}
|
||||
|
|
@ -1189,11 +1189,11 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"### Czego fetch nie robi",
|
||||
"",
|
||||
"Jednak `git fetch` nie zmienia nic w _twoim_ stanie lokalnym Nie zakutalizuje twjej gałęzi `main` ani nie zmieni niczego w wyglądzie twojego systemu plików.",
|
||||
"Zauważ, że `git fetch` nie zmienia nic w _twoim_ stanie lokalnym. Nie zaktualizuje twjej gałęzi `main` ani nie zmieni niczego w wyglądzie twojego systemu plików.",
|
||||
"",
|
||||
"Jest to ważne, żeby to zrozumieć, ponieważ wielu programistów uważa, że uruchomienie `git fetch` spowoduje, że ich lokalna praca będzie odzwierciedlać stan zdalny. Może pobrać wszystkie niezbędne do tego dane, ale _nie zmienia_ żadnego z plików lokalnych. Do tego kroku przejdziemy w następnych lekcjach :D",
|
||||
"Zrozumienie tego to ważna sprawa! Wielu programistów uważa, że uruchomienie `git fetch` spowoduje, że ich lokalna praca będzie odzwierciedlać stan zdalny. Mimo że `git fetch` pobiera wszystkie niezbędne do tego dane, _nie zmienia_ żadnego z plików lokalnych. Poleceń, które służą właśnie do tego celu, nauczymy się później. :D",
|
||||
"",
|
||||
"Więc, na koniec dnia, możesz myśleć o `git fetch` jako o kroku pobierania."
|
||||
"Dlatego, podsumowując to wszystko, możesz myśleć o `git fetch` jako pobieraniu."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -1201,7 +1201,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby ukończyć poziom po prostu użyj polecenia `git fetch` i pobierz wszystkie commity!"
|
||||
"Aby ukończyć ten poziom, po prostu użyj polecenia `git fetch` i pobierz wszystkie commity!"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ exports.level = {
|
|||
"ko": "Fetch의 인자들",
|
||||
"uk": "Аргументи для fetch",
|
||||
"vi": "Tham số fetch",
|
||||
"sl_SI": "Fetch argumenti"
|
||||
"sl_SI": "Fetch argumenti",
|
||||
"pl": "Argumenty fetch"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Pay attention how the commit ids may have swapped! You can read slides again with \"help level\"",
|
||||
|
|
@ -34,7 +35,8 @@ exports.level = {
|
|||
"ko": "커밋 ID가 바뀔수도있으니 주의하세요! \"help level\"을 입력하면 슬라이드들을 다시 읽어볼수 있습니다.",
|
||||
"uk": "Зверни увагу на те, що номери комітів можуть змінюватися! Слайди уроку можна переглянути ще раз командою \"help level\"",
|
||||
"vi": "Lưu ý id của các commit bị tráo đổi, bạn có thể dùng \"help level\" để đọc lại hội thoại",
|
||||
"sl_SI": "Bodi pozoren kako so se commit id-ji morda zamenjali! Ponovno lahko prebereš navodila z \"help level\"."
|
||||
"sl_SI": "Bodi pozoren kako so se commit id-ji morda zamenjali! Ponovno lahko prebereš navodila z \"help level\".",
|
||||
"pl": "Zauważ, że identyfikatory commitów mogły zostać zamienione! Slajdy możesz przeczytać jeszcze raz po wpisaniu: \"help level\""
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -1896,6 +1898,129 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Argumenty git fetch",
|
||||
"",
|
||||
"No to właśnie nauczyliśmy się o argumentach git push, o tym fajnym parametrze `<place>`, a nawet o refspec z dwukropkiem (`<źródło>:<cel>`). Czy możemy tę samą wiedzę zastosować też przy `git fetch`?",
|
||||
"",
|
||||
"No ba... Argumenty `git fetch` są w gruncie rzeczy *bardzo, bardzo* podobne do tych z `git push`. To ta sama idea, tyle że zastosowana w odwrotną stronę (przecież nie wysyłasz commitów, tylko je pobierasz).",
|
||||
"",
|
||||
"Powtórzmy krok po kroku, na czym to polega..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Parametr `<place>` (miejsce)",
|
||||
"",
|
||||
"Jeśli w git fetch określisz miejsce, tak jak w tym poleceniu:",
|
||||
"",
|
||||
"`git fetch origin foo`",
|
||||
"",
|
||||
"Git przejdzie do gałęzi `foo` w zdalnym repozytorium, weźmie wszystkie commity, których brakuje lokalnie, i zrzuci je nam na lokalną gałąź `o/foo`.",
|
||||
"",
|
||||
"Zobaczmy, jak to działa (tylko dla odświeżenia pamięci)."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Określając miejsce..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"pobraliśmy tylko commity z `foo` i umieściliśmy je na `o/foo`."
|
||||
],
|
||||
"command": "git fetch origin foo",
|
||||
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Może się zastanawiasz, dlaczego Git zrzucił te commity na zdalną gałąź `o/foo`, a nie tylko na lokalną gałąź `foo`? Wydawało się, że parametr `<place>` to miejsce istniejące zarówno lokalnie, jak i na zdalnym repozytorium.",
|
||||
"",
|
||||
"Cóż... Git robi w tym miejscu bardzo wyjątkowy wyjątek, bo wie, że możesz mieć na gałęzi `foo` pracę, w której nie chcesz namieszać!!! Łączy się to z wcześniejszą lekcją o `git fetch`. To polecenie nie aktualizuje twoich lokalnych gałęzi - ono tylko pobiera commity (a ty możesz je sobie obejrzeć i scalić później).",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"\"No to co się w takim razie stanie, jeśli samodzielnie określę źródło i cel za pomocą `<source>:<destination>`?\"",
|
||||
"",
|
||||
"Jeśli naprawdę czujesz wewnętrzną potrzebę, żeby robić fetch *bezpośrednio* na lokalną gałąź, to proszę bardzo, możesz wykorzystać refspec z dwukropkiem. Nie możesz tylko ściągnąć przy użyciu fetch commitów na aktualnie wybraną za pomocą checkout gałąź. Poza tym Git pozwoli ci zrobić, co chcesz.",
|
||||
"",
|
||||
"Jest jednak jeden haczyk -- `<źródło>` to teraz *zdalne* miejsce, a `<cel>` jest *lokalnym* miejscem, na które trafią commity. To dokładne przeciwieństwo git push, i to ma sens, skoro przenosimy teraz dane w odwrotnym kierunku!",
|
||||
"",
|
||||
"No ale w praktyce mało kto tak robi. Tłumaczę to głównie po to, żeby uzmysłowić ci, że `fetch` i `push` są dość podobne, tylko działają w odwrotne strony."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Zobaczmy, jak to szaleństwo działa:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Nieźle! Spójrz. Git zinterpretował `foo~1` jako miejsce na origin i pobrał z niego commity do `bar` (czyli lokalną gałąź). Zauważ, że ani `foo`, ani `o/foo` nie zostały zaktualizowane, ponieważ określiliśmy cel."
|
||||
],
|
||||
"command": "git fetch origin foo~1:bar",
|
||||
"beforeCommand": "git branch foo; git clone; git branch bar; git fakeTeamwork foo 2"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"A co, jeśli cel nie istnieje przed wykonaniem polecenia? Spójrzmy jeszcze na ostatni slajd, na którym `bar` na początku nie ma."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Widzisz, to działa DOKŁADNIE jak git push. Git stworzył lokalnie cel przed wykonaniem fetch, dokładnie tak samo jak zrobiłby to na zdalnym repozytorium przed zrobieniem push (gdyby cel tam nie istniał)."
|
||||
],
|
||||
"command": "git fetch origin foo~1:bar",
|
||||
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Bez argumentów?",
|
||||
"",
|
||||
"Jeśli `git fetch` nie dostanie żadnych argumentów, to po prostu ściągnie wszystkie commity ze zdalnego repozytorium do wszystkich zdalnych gałęzi..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Niby proste, ale warto to zobaczyć chociaż raz."
|
||||
],
|
||||
"command": "git fetch",
|
||||
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Dobra, dość gadania! Żeby ukończyć ten poziom, użyj fetch tylko do commitów określonych w wizualizacji celu. Pokombinuj trochę z tymi poleceniami!",
|
||||
"",
|
||||
"Dla obu poleceń fetch musisz określić źródło i cel. Przyjrzyj się dokładnie wizualizacji celu; identyfikatory mogą być zamienione miejscami!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ exports.level = {
|
|||
"ko": "순서는 goal을 참고하세요",
|
||||
"vi": "kiểm tra kỹ thứ tự trên mô hình mục tiêu",
|
||||
"sl_SI": "Preveri vrstni red iz ciljne vizualizacije.",
|
||||
"pl": "sprawdź, jak wygląda kolejność z wizualizacji bramki",
|
||||
"pl": "Przyjrzyj się kolejności na wizualizacji celu",
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -2192,9 +2192,9 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Rozbieżna praca",
|
||||
"",
|
||||
"Do tej pory widzieliśmy jak `pull` pobiera commity od innych i jak `push` wysyła nasze własne zmiany. Wydaje się to całkiem proste, więc jak ludzie mogą być tak zdezorientowani?",
|
||||
"Widzieliśmy wcześniej, jak `pull` pobiera commity od innych i jak `push` wysyła nasze własne zmiany. Wydaje się to całkiem proste, więc jak ludzie mogą być tak zdezorientowani?",
|
||||
"",
|
||||
"Trudność pojawia się, gdy historia repozytorium *rozbiega się*. Zanim omówimy szczegóły tego rozwiązania, zobaczmy przykład..",
|
||||
"Trudności pojawiają się, gdy historia repozytorium zaczyna się *rozbiegać*. Zanim omówimy szczegóły tego rozwiązania, zobaczmy przykład...",
|
||||
""
|
||||
]
|
||||
}
|
||||
|
|
@ -2203,11 +2203,11 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Wyobraźmy sobie, że klonujemy repozytorium w poniedziałek i zaczynamy pracować nad dodatkową funkcjonalnością. W piątek jesteśmy gotowi aby opublikować swoje zmiany -- ale o nie! Twoi współpracownicy napisali w ciągu tygodnia mnóstwo kodu, który sprawił, że Twoja funkcjonalność stała się nieaktualna (i przestarzała). Opublikowali również te poprawki we wspólnym zdalnym repozytorium, więc teraz *twoja* praca jest oparta na *starej* wersji projektu, która nie jest już aktualna.",
|
||||
"Wyobraźmy sobie, że klonujesz repozytorium w poniedziałek i zaczynasz pracować nad dodatkową funkcjonalnością. W piątek chcesz opublikować swoje zmiany -- ale, o nie! Współpracownicy napisali w ciągu tygodnia mnóstwo kodu, który sprawił, że twoja praca stała się nieaktualna (przestarzała). Opublikowali również te poprawki we wspólnym zdalnym repozytorium, więc teraz *twoja* praca jest oparta na *starej* wersji projektu, która nie jest już aktualna.",
|
||||
"",
|
||||
"W tym przypadku, komenda `git push` jest niejednoznaczna. Jeśli uruchomisz `git push`, czy git powinien zmienić zdalne repozytorium z powrotem na takie, jakie było w poniedziałek? Czy powinien on próbować dodać twój kod, nie usuwając jednocześnie nowego kodu? Czy też powinien on całkowicie zignorować Twoje zmiany, ponieważ są one całkowicie nieaktualne?",
|
||||
"W tym przypadku komenda `git push` jest niejednoznaczna. Jeśli uruchomisz `git push`: czy Git powinien zmienić zdalne repozytorium z powrotem na takie, jakie było w poniedziałek? Czy powinien próbować dodać twój kod, nie usuwając jednocześnie nowego kodu? Czy też ma całkowicie zignorować twoje zmiany, ponieważ są one zupełnie przestarzałe?",
|
||||
"",
|
||||
"Ponieważ w tej sytuacji jest tak wiele niejasności (gdzie historia się rozbiegła), git nie pozwala ci na `push` twoich zmian. W rzeczywistości zmusza Cię do połączenia najnowszego stanu remota, zanim będziesz mógł udostępnić swoją pracę."
|
||||
"Ponieważ w tej sytuacji (gdzie historia się rozbiegła) jest tak wiele niejasności, Git nie pozwala ci na `push` twoich zmian. W rzeczywistości zmusza cię do połączenia najnowszego stanu remote'a, zanim pozwoli ci udostępnić swoją pracę."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -2215,10 +2215,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Dosyć gadania! Zobaczmy tę sytuację w działaniu."
|
||||
"Dość gadania! Zobaczmy tę sytuację w działaniu."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Spójrz, nic się nie zmieniło, ponieważ polecenie nie powiodło się. Polecenie `git push` nie powiedzie się, ponieważ twój najnowszy commit `C3` jest oparty na zdalnym `C1`. Zdalny został jednak zaktualizowany do `C2`, więc git odrzuca twojego pusha."
|
||||
"Spójrz, nic się nie zmieniło, ponieważ wykonanie polecenia nie powiodło się. Polecenie `git push` nie powiedzie się, ponieważ twój najnowszy commit `C3` jest oparty na zdalnym `C1`. Zdalny został jednak zaktualizowany do `C2`, więc Git odrzuca twojego pusha."
|
||||
],
|
||||
"command": "git push",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
|
|
@ -2228,7 +2228,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Jak rozwiążesz tę sytuację? To proste, wszystko co musisz zrobić, to oprzeć swoją pracę na najnowszej wersji remota.",
|
||||
"Jak rozwiążesz tę sytuację? To proste. Wszystko, co musisz zrobić, to oprzeć swoją pracę na najnowszej wersji remote'a.",
|
||||
"",
|
||||
"Jest kilka sposobów, aby to zrobić, ale najprostszym jest przeniesienie pracy poprzez rebase. Zobaczmy, jak to wygląda."
|
||||
]
|
||||
|
|
@ -2238,10 +2238,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Teraz, jeśli zamiast tego zrobimy rebase przed wypchnięciem..."
|
||||
"Zróbmy teraz inaczej: rebase przed wypchnięciem..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Boom! Zaktualizowaliśmy naszą lokalną reprezentację remota za pomocą `git fetch`, zmieniliśmy naszą pracę, aby odzwierciedlić nowe zmiany na remotcie, a następnie wypchnęliśmy je za pomocą `git push`."
|
||||
"Tadam! Zaktualizowaliśmy naszą lokalną reprezentację remote'a za pomocą `git fetch`, przebazowaliśmy naszą pracę, aby odzwierciedlić nowe zmiany na zdalnej gałęzi, a następnie wypchnęliśmy je za pomocą `git push`."
|
||||
],
|
||||
"command": "git fetch; git rebase o/main; git push",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
|
|
@ -2251,11 +2251,11 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Czy istnieją inne sposoby na aktualizację naszej pracy, gdy zdalne repozytorium zostało zaktualizowane? Oczywiście! Spróbujmy rozwiązać to z użyciem `merge`.",
|
||||
"Czy istnieją inne sposoby na aktualizację naszej pracy, gdy zdalne repozytorium zostało zaktualizowane? Oczywiście! Spróbujmy rozwiązać to również z użyciem `merge`.",
|
||||
"",
|
||||
"Chociaż `git merge` nie przenosi twojej pracy (a zamiast tego po prostu tworzy commit scalający), jest to sposób na powiedzenie gitowi, że włączyłeś wszystkie zmiany z remota. Dzieje się tak dlatego, że zdalna gałąź jest teraz *przodkiem* twojej własnej gałęzi, co oznacza, że twój commit odzwierciedla wszystkie commity w zdalnej gałęzi.",
|
||||
"Chociaż `git merge` nie przenosi twojej pracy (a zamiast tego po prostu tworzy commit scalający), jest to sposób na powiedzenie Gitowi, że dołączasz wszystkie zmiany z remote'a. Dzieje się tak dlatego, że zdalna gałąź jest teraz *przodkiem* twojej własnej gałęzi, co oznacza, że twój commit odzwierciedla wszystkie commity w zdalnej gałęzi.",
|
||||
"",
|
||||
"Sprawdźmy jak to wygląda..."
|
||||
"Zobaczmy, jak to wygląda..."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -2263,10 +2263,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Teraz jeżeli zmergujemy zamiast rebasować..."
|
||||
"A jeśli użyjemy `merge` zamiast `rebase`..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Boom! Zaktualizowaliśmy naszą lokalną reprezentację remota za pomocą `git fetch`, git *zmergował* nową pracę do naszej pracy (aby odzwierciedlić nowe zmiany na remotcie), a następnie wypchnął je za pomocą `git push`."
|
||||
"Tadam! Zaktualizowaliśmy naszą lokalną reprezentację remote'a za pomocą `git fetch`, git dołączył (*merge*) nową pracę do naszej pracy (aby odzwierciedlić nowe zmiany na zdalnej gałęzi), a następnie wypchnął je za pomocą `git push`."
|
||||
],
|
||||
"command": "git fetch; git merge o/main; git push",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
|
|
@ -2276,11 +2276,11 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Wspaniale! Czy jest jakiś sposób, abym mógł to zrobić bez wpisywania tylu komend?",
|
||||
"Wspaniale! Czy jest jakiś sposób, żeby zrobić to bez wpisywania tylu komend?",
|
||||
"",
|
||||
"Oczywiście -- znasz już `git pull ` - jest po prostu skrótem dla fetch i merge. `git pull --rebase` jest bardzo wygodnym skrótem od fetch i rebase!",
|
||||
"Oczywiście -- znasz już `git pull ` - jest po prostu skrótem dla fetch i merge. `git pull --rebase` jest bardzo wygodnym skrótem dla fetch i rebase!",
|
||||
"",
|
||||
"Zobaczmy te skrócone komendy w pracy."
|
||||
"Zobaczmy, jak działają te skrócone polecenia."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -2291,7 +2291,7 @@ exports.level = {
|
|||
"Na początku z `--rebase`..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Tak samo jak wcześniej! Tylko sporo krócej."
|
||||
"Tak samo jak wcześniej! Tylko o wiele krócej."
|
||||
],
|
||||
"command": "git pull --rebase; git push",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
|
|
@ -2314,14 +2314,14 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Ten flow pracy fetchowania, rebase/merge i push jest dość powszechny. W kolejnych lekcjach zajmiemy się bardziej skomplikowanymi wersjami tych flow. Na razie wypróbujmy to czego się nauczyliśmy.",
|
||||
"Ta kolejność fetchowania, rebase/merge i push jest dość powszechna. W kolejnych lekcjach zajmiemy się bardziej skomplikowanymi możliwościami . Na razie wypróbujmy to, czego się nauczyliśmy.",
|
||||
"",
|
||||
"Aby rozwiązać ten poziom, wykonaj następujące kroki:",
|
||||
"Aby ukończyć ten poziom, wykonaj następujące kroki:",
|
||||
"",
|
||||
"* Sklonuj swoje repozytorium",
|
||||
"* Sfałszuj trochę pracy zespołowej (1 commit)",
|
||||
"* Zcommituj trochę swojej pracy (1 commit)",
|
||||
"* Opublikuj swoją pracę korzystając z *rebase*"
|
||||
"* Zasymuluj pracę zespołową (1 commit)",
|
||||
"* Scommituj własną pracę (1 commit)",
|
||||
"* Opublikuj swoją pracę, korzystając z *rebase*"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,8 @@ exports.level = {
|
|||
"ko": "로컬 저장소의 main 브랜치로부터 feature 브랜치를 만드세요. 그리고 o/main과 같아질 수 있도록 로컬 저장소의 main 브랜치를 reset 하세요.",
|
||||
"sl_SI": "Naredi feature branch iz lokalnega masterja preden ga ponastaviš, da bo enak kot origin main.",
|
||||
"es_AR": "Crea la rama feature desde la rama main en local antes de restablecerlo para que sea el mismo que la rama main de origen.",
|
||||
"ja": "mainブランチをoriginのmainと同じ状態になるようにリセットする前に、ローカルのmainからfeatureブランチを作成します。"
|
||||
"ja": "mainブランチをoriginのmainと同じ状態になるようにリセットする前に、ローカルのmainからfeatureブランチを作成します。",
|
||||
"pl": "Stwórz boczną gałąź tematyczną (feature) z lokalnego main, a późnej zsynchronizuj ją z main na origin"
|
||||
},
|
||||
"name": {
|
||||
"en_US": "Locked Main",
|
||||
|
|
@ -30,7 +31,8 @@ exports.level = {
|
|||
"ko": "잠겨버린 main 브랜치",
|
||||
"sl_SI": "Zaklenjen Main",
|
||||
"es_AR": "Main bloqueado",
|
||||
"ja": "ロックされたmain"
|
||||
"ja": "ロックされたmain",
|
||||
"pl": "Zablokowany main"
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -564,5 +566,45 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Remote odrzuca!",
|
||||
"",
|
||||
"Jeśli pracujesz w dużym zespole, to może się zdarzyć, że main będzie zablokowany i przed scaleniem zmian trzeba będzie zrobić pull request. Jeśli commitujesz bezpośrednio do lokalnego main i spróbujesz zrobić push, to możesz dostać wiadomość podobną do tej:",
|
||||
"",
|
||||
"```",
|
||||
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
|
||||
"```"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Skąd to odrzucenie?",
|
||||
"",
|
||||
"Remote odrzuca pushowanie twoich commitów bezpośrednio do main ze względu na regułę wymagającą korzystania z pull requestów.",
|
||||
"",
|
||||
"Twoim zamiarem było najpierw stworzyć gałąź, a potem wypchnąć ją do zdalnego repozytorium i zrobić pull request, ale zamiast tego commitujesz bezpośrednio do main. Dlatego masz problem i nie możesz wypchnąć swoich zmian."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Rozwiązanie",
|
||||
"",
|
||||
"Stwórz inną gałąź, nazywaną często boczną albo tematyczną, a po angielsku: feature (funkcyjną), i wypchnij ją do remote. Zresetuj również swój main, tak aby był zsynchronizowany ze zdalnym repozytorium. Jeśli tego nie zrobisz, to możesz mieć problem następnym razem, kiedy zrobisz pull, a czyjś commit będzie miał konflikt z twoim."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ exports.level = {
|
|||
"ko": "원격 작업과 merge하기",
|
||||
"uk": "Мердж з віддаленим репозиторієм",
|
||||
"vi": "Hợp nhất nhánh từ xa",
|
||||
"sl_SI": "Merganje z oddaljenim repozitorijem"
|
||||
"sl_SI": "Merganje z oddaljenim repozitorijem",
|
||||
"pl": "Scalanie z remote"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Pay attention to the goal tree!",
|
||||
|
|
@ -34,7 +35,8 @@ exports.level = {
|
|||
"ko": "goal을 잘 살펴보세요!",
|
||||
"uk": "Уважно подивись як має виглядати результат!",
|
||||
"vi": "Hãy để ý đến cây mục tiêu!",
|
||||
"sl_SI": "Poglej si ciljno drevo!"
|
||||
"sl_SI": "Poglej si ciljno drevo!",
|
||||
"pl": "Zwróć uwagę, jak wygląda docelowe drzewo!"
|
||||
},
|
||||
"compareOnlyMain": true,
|
||||
"startDialog": {
|
||||
|
|
@ -712,6 +714,51 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Dlaczego nie merge?",
|
||||
"",
|
||||
"Aby wypchnąć nowe wersje, musisz tylko *nanieść* najnowsze zmiany ze zdalnego repozytorium. A to znaczy, że możesz zrobić albo rebase, *albo* merge gałęzi w zdalnym repozytorium (np. `o/main`).",
|
||||
"",
|
||||
"Skoro można to zrobić na oba sposoby, to dlaczego lekcje skupiały się do tej pory na przebazowaniu? Dlaczego `merge` nie jest lubianym poleceniem przy pracy na zdalnych repo?",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Wśród osób zajmujących się programowaniem toczą się spory, co jest lepsze: merge czy rebase. Oto ogólne za i przeciw rebase'owania:",
|
||||
"",
|
||||
"Za:",
|
||||
"",
|
||||
"* Przebazowanie sprawi, że twoje drzewo commitów będzie wyglądać bardzo czysto, ponieważ wszystko znajdzie się w jednej linii",
|
||||
"",
|
||||
"Przeciw:",
|
||||
"",
|
||||
"* Rebase zmienia (pozornie) historię drzewa commitów.",
|
||||
"",
|
||||
"Na przykład: commit `C1` można przebazować *za* `C3`. Pozornie będzie to wyglądać tak, jakby praca na `C1'` została wykonana później niż na `C3`, a w rzeczywistości było zupełnie odwrotnie.",
|
||||
"",
|
||||
"Część osób ceni sobie oryginalną historię i dlatego woli merdżować. Inni (w tym ja) wolą mieć czyste drzewo commitów i dlatego używają rebase. To po prostu kwestia osobistych preferencji :D"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Na tym poziomie spróbujemy rozwiązać zadanie z poprzedniego, ale tym razem użyjemy *merge*. Może się to wydawać lekko pogmatwane, ale dobrze pokazuje tę metodę."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ exports.level = {
|
|||
"ko": "Git pull",
|
||||
"vi": "Git pull",
|
||||
"sl_SI": "Git Pull",
|
||||
"pl": "Git Pull",
|
||||
"pl": "Git pull",
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Just run git pull!",
|
||||
|
|
@ -932,16 +932,16 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"## Git Pull",
|
||||
"",
|
||||
"Teraz, gdy widzieliśmy jak pobierać dane ze zdalnego repozytorium za pomocą `git fetch`, zaktualizujmy naszą pracę, aby odzwierciedlić te zmiany!",
|
||||
"Teraz, gdy zobaczyliśmy, jak pobierać dane ze zdalnego repozytorium za pomocą `git fetch`, zaktualizujmy naszą pracę, aby odzwierciedlić te zmiany!",
|
||||
"",
|
||||
"Istnieje wiele sposobów, aby to zrobić - kiedy masz już nowe commity dostępne lokalnie, możesz je włączyć tak, jakby były zwykłymi commitami na innych gałęziach. Oznacza to, że możesz wykonywać polecenia takie jak:",
|
||||
"Istnieje wiele sposobów, aby to zrobić - kiedy masz już nowe commity dostępne lokalnie, możesz je dołączyć tak, jakby były zwykłymi commitami na innych gałęziach. Oznacza to, że możesz wykonywać polecenia takie jak:",
|
||||
"",
|
||||
"* `git cherry-pick o/main`",
|
||||
"* `git rebase o/main`",
|
||||
"* `git merge o/main`",
|
||||
"* itd., itd.",
|
||||
"",
|
||||
"W rzeczywistości flow pracy polegające na *pobieraniu* zdalnych zmian, a następnie *połączeniu* ich jest tak powszechny, że git faktycznie zapewnia polecenie, które robi obie te rzeczy naraz! Tą komendą jest `git pull`."
|
||||
"W rzeczywistości kolejność działań polegająca na *pobieraniu* zdalnych zmian (fetch), a następnie *łączeniu* ich (merge), jest tak powszechna, że sam Git zapewnia polecenie, które robi obie te rzeczy naraz! Jest to `git pull`."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -952,7 +952,7 @@ exports.level = {
|
|||
"Zobaczmy najpierw `fetch` i `merge` wykonywane jedno po drugim."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Boom -- pobraliśmy `C3` za pomocą `fetch`, a następnie połączyliśmy tę pracę za pomocą `git merge o/main`. Teraz nasza gałąź `main` odzwierciedla nową pracę z remote (w tym przypadku o nazwie `origin`)"
|
||||
"Tadam -- pobraliśmy `C3` za pomocą `fetch`, a następnie połączyliśmy tę pracę za pomocą `git merge o/main`. Teraz nasza gałąź `main` odzwierciedla nową pracę z remote (w tym przypadku o nazwie `origin`)"
|
||||
],
|
||||
"command": "git fetch; git merge o/main",
|
||||
"beforeCommand": "git clone; git commit; git fakeTeamwork"
|
||||
|
|
@ -965,7 +965,7 @@ exports.level = {
|
|||
"Co by się stało, gdybyśmy zamiast tego użyli `git pull`?"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Dokładnie to samo! To powinno wyjaśnić, że `git pull` jest w zasadzie skrótem do `git fetch`, po którym następuje scalenie gałęzi, która została właśnie pobrana."
|
||||
"Dokładnie to samo! Chyba bardzo wyraźnie widać, że `git pull` to w zasadzie dwa w jednym: `git fetch`, po którym następuje scalenie przed chwilą pobranej gałęzi."
|
||||
],
|
||||
"command": "git pull",
|
||||
"beforeCommand": "git clone; git commit; git fakeTeamwork"
|
||||
|
|
@ -975,9 +975,9 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Szczegóły działania `git pull` poznamy później (w tym opcje i argumenty), ale na razie wypróbujmy je na tym poziomie.",
|
||||
"W szczegóły `git pull` zagłębimy się później (również w opcje i argumenty), ale na tym poziomie po prostu wypróbujmy, jak działa.",
|
||||
"",
|
||||
"Pamiętaj -- możesz rozwiązać ten poziom używając tylko `fetch` i `merge`, ale będzie Cię to kosztowało dodatkową komendę :P"
|
||||
"Pamiętaj -- możesz rozwiązać ten poziom, używając tylko `fetch` i `merge`, ale będzie cię to kosztowało dodatkowe polecenie :P"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ exports.level = {
|
|||
"ko": "pull 인자들",
|
||||
"uk": "Аргументи pull",
|
||||
"vi": "Tham số pull",
|
||||
"sl_SI": "Pull argumenti"
|
||||
"sl_SI": "Pull argumenti",
|
||||
"pl": "Argumenty pull"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember that you can create new local branches with fetch/pull arguments",
|
||||
|
|
@ -34,7 +35,8 @@ exports.level = {
|
|||
"ko": "fetch/pull 과 인자들로 새 로컬 브랜치를 생성할수 있다는것을 기억하세요.",
|
||||
"uk": "Пам'ятай, що ти можеш створювати нові гілки, використовуючи fetch/pull з аргументами",
|
||||
"vi": "Nhớ rằng,bạn có thể tạo nhánh cục bộ mới với tham số của fetch/pull",
|
||||
"sl_SI": "Zapomni si, da lahko ustvariš nove lokalne branche s fetch/pull argumenti."
|
||||
"sl_SI": "Zapomni si, da lahko ustvariš nove lokalne branche s fetch/pull argumenti.",
|
||||
"pl": "Pamiętaj, że za pomocą argumentów fetch/pull możesz tworzyć nowe lokalne gałęzie"
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -1155,6 +1157,80 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Argumenty git pull",
|
||||
"",
|
||||
"Teraz, kiedy wiesz już właściwie *wszystko*, co można wiedzieć o argumentach `git fetch` oraz `git push`, naprawdę nie zostało już prawie nic do omówienia przy `git pull` :)",
|
||||
"",
|
||||
"To dlatego, że w zasadzie git pull to *naprawdę* tylko skrót polecenia fetch i scalania wszystkiego, co zostało nim pobrane. Możesz to sobie wyobrazić jako uruchomienie git fetch z określonymi *tymi samymi* argumentami, a potem scalenie pobranych commitów *tam*, dokąd trafiły.",
|
||||
"",
|
||||
"I działa to w ten sposób, nawet jeśli określisz kompletnie szalone argumenty. Zobaczmy kilka przykładów:"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Oto kilka równoważnych poleceń w Gicie:",
|
||||
"",
|
||||
"`git pull origin foo` nie różni się od:",
|
||||
"",
|
||||
"`git fetch origin foo; git merge o/foo`",
|
||||
"",
|
||||
"A...",
|
||||
"",
|
||||
"`git pull origin bar~1:bugFix` daje taki sam efekt jak:",
|
||||
"",
|
||||
"`git fetch origin bar~1:bugFix; git merge bugFix`",
|
||||
"",
|
||||
"Widzisz? git pull to naprawdę tylko skrót dla fetch + merge i jedyne, co się liczy dla git pull, to gdzie trafią commity (argument `celu`, który Git zinterpretuje sobie, wykonując fetch).",
|
||||
"",
|
||||
"Zobaczmy demo:"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Jeśli określimy dla fetch miejsce, to wszystko potoczy się tak jak wcześniej, ale scalimy wszystko, co zostało pobrane przez fetch."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Zobacz! Określając `main`, pobraliśmy commity do `o/main` tak jak zawsze. Potem scaliliśmy `o/main` z aktualnie wybranym miejscem, którym *nie* jest lokalna gałąź `main`. Właśnie z tego powodu może mieć sens wykonanie git pull wiele razy (z tymi samymi argumentami) z różnych lokalizacji, aby zaktualizować wiele gałęzi."
|
||||
],
|
||||
"command": "git pull origin main",
|
||||
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Czy w przypadku źródła i celu będzie tak samo? Jasne, że tak! Zobaczmy:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"No nieźle, jedno polecenie, a tyle się dzieje. Stworzyliśmy nową lokalną gałąź `foo`, pobraliśmy commity ze zdalnej gałęzi `main` do `foo`, a potem jeszcze scaliliśmy ją z aktualnie wybraną gałęzią `bar`. Grubo ponad osiem tysięcy!"
|
||||
],
|
||||
"command": "git pull origin main:foo",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Oki, żeby ukończyć poziom, doprowadź drzewo do takiego stanu jak na wizualizacji. Musisz pobrać parę commitów, stworzyć kilka gałęzi i scalić je z innymi, ale nie powinno to wymagać zbyt wielu poleceń :P"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ exports.level = {
|
|||
"ko": "Git push",
|
||||
"vi": "Git push",
|
||||
"sl_SI": "Git Push",
|
||||
"pl": "Git Push"
|
||||
"pl": "Git push"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember you have to clone before you can push!",
|
||||
|
|
@ -685,19 +685,19 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git Push",
|
||||
"## Git push",
|
||||
"",
|
||||
"Ok, więc pobraliśmy zmiany ze zdalnego repozytorium i włączyliśmy je do naszej pracy lokalnie. To wspaniale i w ogóle... ale jak mamy się podzielić _naszą_ wspaniałą pracą z wszystkimi innymi?",
|
||||
"Ok, pobraliśmy zmiany ze zdalnego repozytorium i włączyliśmy je do naszej pracy lokalnie. Wszystko fajnie, ale... jak mamy się podzielić _naszą_ wspaniałą pracą ze wszystkimi innymi?",
|
||||
"",
|
||||
"Cóż, sposób przesyłania współdzielonej pracy jest przeciwieństwem pobierania współdzielonej pracy. A co jest przeciwieństwem `git pull`? `git push`!",
|
||||
"Cóż, wysyłanie współdzielonej pracy jest przeciwieństwem pobierania współdzielonej pracy. A co jest przeciwieństwem `git pull`? `git push`!",
|
||||
"",
|
||||
"Polecenie `git push` jest odpowiedzialne za przesłanie i aktualizację _naszych_ zmian na wybranego remote'a, aby zawierał nowe commity. Gdy `git push` zostanie ukończony, wszyscy twoi przyjaciele będą mogli pobrać twoją pracę z serwera zdalnego.",
|
||||
"Polecenie `git push` odpowiada za przesłanie i aktualizację _naszych_ zmian na wybranego remote'a, aby zawierał nowe commity. Gdy `git push` zostanie ukończony, wszyscy twoi przyjaciele będą mogli pobrać twoją pracę z serwera zdalnego.",
|
||||
"",
|
||||
"Możesz myśleć o `git push` jako o komendzie do \"publikowania\" swojej pracy. Ma on wiele szczegółów, które wkrótce omówimy, ale zacznijmy od małych kroczków...",
|
||||
"Możesz myśleć o `git push` jak o poleceniu do \"publikowania\" swojej pracy. Ma ono wiele szczegółów, które wkrótce omówimy, ale zacznijmy od małych kroczków...",
|
||||
"",
|
||||
"*uwaga -- zachowanie `git push` bez argumentów różni się w zależności od jednego z ustawień git o nazwie `push. default`. Domyślna wartość tego ustawienia zależy od wersji git, której używasz. W naszych lekcjach będziemy używać wartości `upstream`. Nie jest to wielka sprawa, ale warto sprawdzić swoje ustawienia przed wprowadzeniem ich do własnych projektów.*",
|
||||
"*uwaga -- zachowanie `git push` bez argumentów różni się w zależności od jednego z ustawień Git o nazwie `push.default`. Domyślna wartość tego ustawienia zależy od wersji Git, której używasz. W naszych lekcjach będziemy używać wartości `upstream`. Nie jest to wielka sprawa, ale warto sprawdzić swoje ustawienia przed użyciem `push` we własnych projektach.*",
|
||||
"",
|
||||
"*uwaga 2 -- odpowiednik gałęzi na zdalnym repozytorium będziemy nazywać remotem. Nazwa ta jest wykorzystywana w branży, dlatego będziemy się jej trzymać, aby nie wprowadzać zawiłego nazewnictwa*"
|
||||
"*uwaga 2 -- odpowiednik gałęzi na zdalnym repozytorium będziemy nazywać remote'em. Nazwa ta jest wykorzystywana w Polsce, dlatego będziemy jej używać, aby nie wprowadzać zawiłego nazewnictwa*"
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -708,7 +708,7 @@ exports.level = {
|
|||
"Tutaj mamy kilka zmian, których nie ma remote. Załadujmy je!"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"No i proszę -- remote otrzymał commit `C2`, gałąź `main` na zdalnym repozytorium została zaktualizowana do `C2`, a nasze *własne* odzwierciedlenie zdalnego (`o/main`) również zostało zaktualizowane. Wszystko jest zsynchronizowane!"
|
||||
"No i proszę -- remote otrzymał commit `C2`, gałąź `main` na zdalnym repozytorium została zaktualizowana do `C2`. Nasze *własne* odzwierciedlenie zdalnego (`o/main`) również zostało zaktualizowane. Wszystko jest zsynchronizowane!"
|
||||
],
|
||||
"command": "git push",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
|
|
@ -718,7 +718,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby zakończyć ten poziom, po prostu podziel się dwoma nowymi commitami z innymi użytkownikami repozytorium. Przygotuj się jednak na coraz trudniejsze lekcje!"
|
||||
"Aby zakończyć ten poziom, wystarczy, że podzielisz się dwoma nowymi commitami z innymi użytkownikami repozytorium. Ale zapnij pasy i przygotuj się na ostrą jazdę na kolejnych lekcjach!"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,8 @@ exports.level = {
|
|||
"ko": "git push의 인자들",
|
||||
"uk": "Аргументи git push",
|
||||
"vi": "Tham số git push",
|
||||
"sl_SI": "Git push argumenti"
|
||||
"sl_SI": "Git push argumenti",
|
||||
"pl": "Argumenty git push"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "You can always look at the last slide of the dialog with \"objective\"",
|
||||
|
|
@ -38,7 +39,8 @@ exports.level = {
|
|||
"ko": "대화창의 마지막 슬라이드를 \"objective\"로 다시 볼 수 있습니다.",
|
||||
"uk": "Завжди можна подивитися останній слайд діалогу за допомогою \"objective\"",
|
||||
"vi": "Bạn có thể sử dụng \"objective\" để đọc trang cuối của cửa sổ hộp thoại",
|
||||
"sl_SI": "Vedno lahko pogledaš zadnji dialog z \"objective\"."
|
||||
"sl_SI": "Vedno lahko pogledaš zadnji dialog z \"objective\".",
|
||||
"pl": "Możesz wpisać \"objective\", żeby zobaczyć ostatni slajd z każdego poziomu"
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -1144,6 +1146,81 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Argumenty push",
|
||||
"",
|
||||
"Świetnie! Teraz, kiedy wiesz już, jak działa śledzenie zdalnych gałęzi, możemy zacząć zgłębiać tajemnice pracy z git push, fetch i pull. Zmierzymy się z tymi poleceniami po kolei, ale idea działania każdego z nich jest bardzo podobna.",
|
||||
"",
|
||||
"Najpierw spójrzmy na `git push`. Z lekcji o remote tracking wiesz, że Git określa zdalne repozytorium *oraz* gałąź docelową dzięki właściwościom aktualnie wybranej gałęzi (\"śledzącej\" zdalną). Tak to działa, jeśli nie określisz żadnych argumentów, ale git push może też przyjąć opcjonalnie następujące argumenty:",
|
||||
"",
|
||||
"`git push <remote> <place>`",
|
||||
"",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Pytasz, czego dotyczy parametr `<place>`? Zaraz zajmiemy się tym konkretnie, ale najpierw przykład. Polecenie Gita:",
|
||||
"",
|
||||
"`git push origin main`",
|
||||
"",
|
||||
"to, mówiąc po ludzku:",
|
||||
"",
|
||||
"*Przejdź do gałęzi o nazwie \"main\" w moim repozytorium, weź wszystkie commity, a potem idź do gałęzi \"main\" na zdalnym repozytorium, które nazywa się \"origin\". Umieść na tej gałęzi wszystkie commity, których tam jeszcze nie ma, i daj znać, jak skończysz.*",
|
||||
"",
|
||||
"Wpisując `main` w miejscu argumentu \"place\" (miejsce), powiedzieliśmy Gitowi, *skąd ma wziąć* commity i *gdzie je umieścić*. To w zasadzie właśnie \"miejsce\", czyli \"lokalizacja\" do zsynchronizowania na obu repozytoriach.",
|
||||
"",
|
||||
"Pamiętaj, że skoro powiedzieliśmy Gitowi wszystko, co musi wiedzieć (podając oba argumenty), będzie kompletnie ignorować, jakie miejsce mamy aktualnie wybrane!"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Spójrzmy na przykład określający argumenty. Zwróć uwagę na wybrany commit (checkout)."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"No i proszę! Zaktualizowaliśmy `main` na zdalnym repozytorium, ponieważ określiliśmy argumenty."
|
||||
],
|
||||
"command": "git checkout C0; git push origin main",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"A gdybyśmy nie określili argumentów? Co by się stało?"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Polecenie (jak widzisz) nie działa, ponieważ `HEAD` nie jest wybrany na gałęzi śledzącej."
|
||||
],
|
||||
"command": "git checkout C0; git push",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Oki, na tym poziomie uaktualnijmy zarówno `foo`, jak i `main` na zdalnym repozytorium. Haczyk polega na tym, że zablokowaliśmy na tym poziomie `git checkout`!",
|
||||
"",
|
||||
"*Uwaga: Zdalne gałęzie mają przedrostek `o/`, ponieważ pełna nazwa `origin/` nie mieści się w naszym interfejsie. Nie przejmuj się tym... ",
|
||||
"po prostu użyj `origin` jako nazwy zdalnego repozytorium.*"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ exports.level = {
|
|||
"ko": "git push 인자 -- 확장판!",
|
||||
"uk": "Розширені аргументи git push!",
|
||||
"vi": "Tham số git push -- bản mở rộng!",
|
||||
"sl_SI": "Git push argumenti -- Razširjeni!"
|
||||
"sl_SI": "Git push argumenti -- Razširjeni!",
|
||||
"pl": "Argumenty git push -- Głębiej!"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember you can admit defeat and type in \"show solution\" :P",
|
||||
|
|
@ -34,7 +35,8 @@ exports.level = {
|
|||
"ko": "혹시 아세요? 패배를 인정하고 \"show solution\"을 입력할 수 있다는 걸요 :P",
|
||||
"uk": "Пам'ятай, ти завжди можеш визнати поразку і підглянути рішення командою \"show solution\" :P",
|
||||
"vi": "Nhớ rằng, bạn có thể thừa nhận thất bại và gõ \"show solution\" :P",
|
||||
"sl_SI": "Vedno se lahko predaš in napišeš \"show solution\". :P"
|
||||
"sl_SI": "Vedno se lahko predaš in napišeš \"show solution\". :P",
|
||||
"pl": "Pamiętaj, że możesz się poddać i zobaczyć gotowe rozwiązanie, wpisując \"show solution\" :P"
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -1096,6 +1098,76 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Szczegóły argumentu `<place>`",
|
||||
"",
|
||||
"Przypomnij sobie, że na poprzedniej lekcji określając `main` jako argument miejsca dla polecenia git push, wybraliśmy zarówno *źródło*, z którego mają pochodzić commity, jak i *cel*, do którego mają trafić.",
|
||||
"",
|
||||
"No i może zastanawiasz się teraz -- co by było, gdybyśmy chcieli, żeby źródło i cel były różne od siebie? Co, gdybyśmy chcieli wypchać commity z lokalnej gałęzi `foo` do zdalnej gałęzi `bar`?",
|
||||
"",
|
||||
"Cóż... niestety w Gicie nie da się tego zrobić... Żart! Jasne, że się da :) Git jest bardzo, bardzo elastyczny (może aż za bardzo).",
|
||||
"",
|
||||
"Zobaczmy, jak bardzo, na następnym slajdzie..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby określić zarówno źródło, jak i cel dla `<place>`, po prostu połącz je dwukropkiem:",
|
||||
"",
|
||||
"`git push origin <source>:<destination>`",
|
||||
"",
|
||||
"To nic innego jak refspec z dwukropkiem. Refspec to tylko wymyślny termin oznaczający lokalizację, którą Git potrafi zidentyfikować (na przykład gałąź `foo` albo po prostu `HEAD~1`).",
|
||||
"",
|
||||
"Kiedy już zaczniesz określać niezależnie źródła i cele, to możesz trochę zaszaleć na zdalnych repozytoriach. Zobaczmy demo!"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Pamiętaj, że `source` (źródło) to dowolna lokalizacja, którą Git zrozumie:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Łaaał! Niezły odlot, ale jest w tym poleceniu jakiś sens -- Git zinterpretował `foo^` jako konkretną lokalizację, wrzucił tam wszystkie commity, jakich brakowało jeszcze w zdalnym repo, i na koniec zaktualizował cel."
|
||||
],
|
||||
"command": "git push origin foo^:main",
|
||||
"beforeCommand": "git clone; go -b foo; git commit; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"A co, jeśli miejsce, do którego chcesz zrobić push, nie istnieje? Żaden problem! Wybierz tylko nazwę dla gałęzi, a Git stworzy ją dla ciebie w zdalnym repozytorium."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Pięknie! Całkiem sprytne! :D"
|
||||
],
|
||||
"command": "git push origin main:newBranch",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Na tym poziomie postaraj się uzyskać drzewo takie jak na wizualizacji, i pamiętaj o formacie:",
|
||||
"",
|
||||
"`<źródło>:<cel>`"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ exports.level = {
|
|||
"ko": "명령어를 undo와 reset으로 되돌릴 수 있다는 것을 잊지마세요",
|
||||
"uk": "Пам'ятай, ти в будь-який момент можеш використовувати команди undo або reset",
|
||||
"vi": "Nhớ rằng bạn luôn luôn có thể hoàn tác hoặc soạn lại câu lệnh ",
|
||||
"sl_SI": "Vedno lahko razveljaviš ukaz ali ponastaviš stopnjo."
|
||||
"sl_SI": "Vedno lahko razveljaviš ukaz ali ponastaviš stopnjo.",
|
||||
"pl": "Pamiętaj, że zawsze możesz skorzystać z poleceń undo i reset"
|
||||
},
|
||||
"name": {
|
||||
"en_US": "Push Main!",
|
||||
|
|
@ -34,7 +35,8 @@ exports.level = {
|
|||
"ko": "Push Main!",
|
||||
"uk": "Push Maйстер!",
|
||||
"vi": "Push Main!",
|
||||
"sl_SI": "Push Main!"
|
||||
"sl_SI": "Push Main!",
|
||||
"pl": "Wypychanie dla wytrwałych!"
|
||||
},
|
||||
"compareOnlyMainHashAgnostic": true,
|
||||
"startDialog": {
|
||||
|
|
@ -832,6 +834,59 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Scalanie gałęzi feature",
|
||||
"",
|
||||
"Teraz, kiedy fetch, pull ani push nie mają już przed tobą tajemnic, sprawdźmy, jak poradzisz sobie z inną kolejnością działań.",
|
||||
"",
|
||||
"W dużych projektach często pracuje się na gałęziach tematycznych (zazwyczaj nazywanych `feature`), a nie na `main`, i scala się je dopiero po ukończeniu pracy. To sytuacja zbliżona do tej z poprzedniej lekcji (gałęzie boczne wypychaliśmy do remote), ale tu dodamy jeszcze jeden krok.",
|
||||
"",
|
||||
"Niektórzy używają push i pull, tylko będąc na gałęzi `main` - dzięki temu `main` zawsze odzwierciedla to, co jest na zdalnej gałęzi (`o/main`).",
|
||||
"",
|
||||
"Dlatego tym razem połączymy dwie rzeczy:",
|
||||
"",
|
||||
"* integrację pracy na gałęzi `feature` z `main` oraz",
|
||||
"* push i pull ze zdalnego repozytorium"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Przypomnijmy sobie w skrócie, jak uaktualnić `main` i wypchnąć naszą pracę."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Wykonaliśmy dwa polecenia, które:",
|
||||
"",
|
||||
"* przebazowały naszą pracę ponad nowymi commitami ze zdalnego repozytorium oraz",
|
||||
"* opublikowały naszą pracę na remote"
|
||||
],
|
||||
"command": "git pull --rebase; git push",
|
||||
"beforeCommand": "git clone; git commit; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Ten poziom jest dość ciężki: oto ogólny zarys problemu do rozwiązania:",
|
||||
"",
|
||||
"* Mamy trzy boczne gałęzie: `side1`, `side2` i `side3`",
|
||||
"* Każdą z nich chcemy kolejno wypchnąć do zdalnego repozytorium",
|
||||
"* Zdalne repo było w tym czasie zmieniane, więc te zmiany również musimy nanieść",
|
||||
"",
|
||||
":O Ciężka sprawa... Powodzenia! Ukończenie tego poziomu to duży krok naprzód."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -960,15 +960,15 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Zdalne gałęzie git",
|
||||
"## Zdalne gałęzie Git",
|
||||
"",
|
||||
"Teraz gdy widziałeś już działanie `git clone`, przyjrzyjmy się temu, co faktycznie się zmieniło.",
|
||||
"Teraz, gdy zobaczyliśmy już, jak działa `git clone`, przyjrzyjmy się temu, co faktycznie się zmieniło.",
|
||||
"",
|
||||
"Pierwszą rzeczą, jaką mogłeś zauważyć, jest to, że w naszym lokalnym repozytorium pojawiła się nowa gałąź o nazwie `o/main`. Ten typ gałęzi nazywany jest gałęzią _zdalną_; gałęzie zdalne mają specjalne właściwości, ponieważ służą do wyjątkowego celu.",
|
||||
"Pierwszą rzeczą, która mogła ci się rzucić w oczy, jest to, że w naszym lokalnym repozytorium pojawiła się nowa gałąź o nazwie `o/main`. Ten typ gałęzi nazywany jest gałęzią _zdalną_. Gałęzie zdalne mają specjalne właściwości, ponieważ służą do wyjątkowego celu.",
|
||||
"",
|
||||
"Zdalne gałęzie odzwierciedlają _stan_ zdalnych repozytoriów (od czasu ostatniej rozmowy z tymi zdalnymi repozytoriami). Pomagają zrozumieć różnicę między pracą lokalną a pracą publiczną -- krytyczny krok, który należy wykonać przed udostępnieniem swojej pracy innym.",
|
||||
"Zdalne gałęzie odzwierciedlają _stan_ zdalnych repozytoriów (od czasu ostatniej komunikacji z nimi). Pomagają zrozumieć różnicę między pracą lokalną a dostępną publicznie -- to niezwykle ważna sprawa przed udostępnieniem swojej pracy innym.",
|
||||
"",
|
||||
"Zdalne gałęzie mają specjalną właściwość, że kiedy je sprawdzasz, jesteś wprowadzany w odłączony tryb `HEAD`. Git robi to celowo, ponieważ nie możesz pracować bezpośrednio na tych gałęziach; musisz pracować w innym miejscu, a następnie dzielić się swoją pracą zdalnie (po czym twoje zdalne gałęzie zostaną zaktualizowane)."
|
||||
"Zdalne gałęzie mają specjalną właściwość. Kiedy je checkoutujesz, Git wprowdza cię w tryb odłączonego `HEADa`. Robi to celowo, ponieważ nie możesz pracować bezpośrednio na tych gałęziach; musisz pracować w innym miejscu, a następnie udostępnić swoją pracę zdalnie (i wtedy twoje zdalne gałęzie zostaną zaktualizowane)."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -978,17 +978,17 @@ exports.level = {
|
|||
"markdowns": [
|
||||
"### Czym jest `o/`?",
|
||||
"",
|
||||
"Możesz się zastanawiać, do czego służy początkowy znak `o/` w zdalnych gałęziach. Otóż, zdalne gałęzie również mają (wymaganą) konwencję nazewnictwa -- są wyświetlane w formacie:",
|
||||
"Możesz się zastanawiać, do czego służy początkowy znak `o/` w zdalnych gałęziach. Otóż zdalne gałęzie również mają (wymaganą) konwencję nazewnictwa -- są wyświetlane w formacie:",
|
||||
"",
|
||||
"* `<remote name>/<branch name>`",
|
||||
"",
|
||||
"Więc jeśli spojrzysz na gałąź o nazwie `o/main`, nazwą gałęzi (branch name) jest `main` a nazwą zdalną (remote name) jest `o`.",
|
||||
"Więc jeśli spojrzysz na gałąź o nazwie `o/main`, nazwą gałęzi (branch name) jest `main`, a nazwą zdalną (remote name) jest `o`.",
|
||||
"",
|
||||
"Większość deweloperów w rzeczywistości nazywa główne zdalne gałęzie `origin`, nie `o`. Jest to tak powszechne, że git w rzeczywistości ustawia zdalną nazwę na `origin` kiedy wykonujesz `git clone` na repozytorium.",
|
||||
"Większość programistów w rzeczywistości nazywa główną (main) zdalną gałąź `origin`, a nie `o`. Jest to tak powszechne, że Git w praktyce sam ustawia zdalną nazwę na `origin`, kiedy wykonujesz `git clone` na repozytorium.",
|
||||
"",
|
||||
"Niestety pełna nazwa `origin` nie zmieści się w naszym interfejsie, więc używamy `o` jako skrótu :( Pamiętaj więc, że kiedy używasz prawdziwego gita twoja zdalna nazwa najprawdopodobniej brzmi `origin`!",
|
||||
"Niestety pełna nazwa `origin` nie zmieści się w naszym interfejsie, więc używamy `o` jako skrótu :( Pamiętaj więc, że kiedy używasz prawdziwego Gita, twoja zdalna nazwa najprawdopodobniej brzmi `origin`!",
|
||||
"",
|
||||
"To dużo do przyswojenia, więc zobaczmy to wszystko w akcji."
|
||||
"To dużo do przyswojenia, więc przyjrzyjmy się, jak to wszystko działa."
|
||||
]
|
||||
}
|
||||
},
|
||||
|
|
@ -996,10 +996,10 @@ exports.level = {
|
|||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Sprawdźmy zdalną gałąź i zobaczmy co się stanie."
|
||||
"Wyciągnijmy (check out) zdalną gałąź i zobaczmy, co się stanie."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Jak widzisz git przełączył nas w odłączony tryb `HEAD` i nie zaktualizował `o/main` kiedy dodaliśmy nowy commit. Jest tak ponieważ `o/main` aktualizuje się tylko, gdy aktualizujesz go ze zdalnym repozytorium."
|
||||
"Jak widzisz, git przełączył nas w tryb odłączonego `HEADa` i nie zaktualizował `o/main`, kiedy dodaliśmy nowy commit. Dzieje się tak, ponieważ `o/main` zaktualizuje się tylko przy aktualizacji zdalnego repozytorium."
|
||||
],
|
||||
"command": "git checkout o/main; git commit",
|
||||
"beforeCommand": "git clone"
|
||||
|
|
@ -1009,7 +1009,7 @@ exports.level = {
|
|||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Aby ukończyć ten poziom, zacommituj raz z `main` i raz, po przełączeniu się, z `o/main`. Pomoże to zrozumieć, jak zachowują się zdalne gałęzie i jak są wykorzystywane w celu odzwierciedlenia zdalnego repozytorium."
|
||||
"Aby ukończyć ten poziom, zrób jeden commit z `main` i drugi, po przełączeniu się (check out) na `o/main`. Pomoże ci to zrozumieć różnice w zachowaniu zdalnych gałęzi i zapamiętać, że aktualizują się wyłącznie, aby odzwierciedlić stan zdalnego repozytorium."
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,7 +23,8 @@ exports.level = {
|
|||
"ko": "Source가 없다",
|
||||
"uk": "Нема джерела",
|
||||
"vi": "Không có nguồn",
|
||||
"sl_SI": "Izvor Ničesar"
|
||||
"sl_SI": "Izvor Ničesar",
|
||||
"pl": "Źródło nicości"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "The branch command is disabled for this level so you'll have to use fetch!",
|
||||
|
|
@ -40,7 +41,8 @@ exports.level = {
|
|||
"ko": "branch 명령이 비활성화 되어있습니다. fetch를 사용해야 되요!",
|
||||
"uk": "Команда branch недоступна на цьому уроці, користуйся командою fetch!",
|
||||
"vi": "Lệnh branch đã bị vô hiệu hóa ở cấp độ này nên bạn sẽ phải dùng fetch!",
|
||||
"sl_SI": "Ukaz za branchanje je v tej stopnji onemogočen, zato boš moral uporabiti fetch!"
|
||||
"sl_SI": "Ukaz za branchanje je v tej stopnji onemogočen, zato boš moral uporabiti fetch!",
|
||||
"pl": "Polecenie branch jest zablokowane na tym poziomie, musisz skorzystać z fetch!"
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -841,6 +843,59 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Osobliwości `<source>`",
|
||||
"",
|
||||
"Git pozwala wykorzystać parametr `<source>` (źródło) na dwa osobliwe sposoby. Oba są dziwaczne dlatego, że - technicznie rzecz biorąc - możesz określić \"nic\" jako poprawne `źródło` zarówno dla git push, jak i git fetch. Tę \"nicość\" określasz za pomocą pustego argumentu:",
|
||||
"",
|
||||
"* `git push origin :side`",
|
||||
"* `git fetch origin :bugFix`",
|
||||
"",
|
||||
"Zobaczmy, co z tego wyniknie..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Co daje wypchnięcie \"nicości\" na zdalną gałąź? Usuwa ją!"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Oto właśnie usunęliśmy skutecznie gałąź `foo` na zdalnym repozytorium, wypychając do niej ideę \"nicości\". To nawet ma jakiś sens..."
|
||||
],
|
||||
"command": "git push origin :foo",
|
||||
"beforeCommand": "git clone; git push origin main:foo"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Natomiast ściągnięcie \"nicości\" za pomocą fetch do lokalnego miejsca tworzy nową gałąź."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Osobliwe i dziwaczne, ale nic nie poradzisz... Git tak ma!"
|
||||
],
|
||||
"command": "git fetch origin :bar",
|
||||
"beforeCommand": "git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"To jest krótki poziom -- żeby go ukończyć, po prostu usuń jedną zdalną gałąź i stwórz jedną nową, używając `git fetch`!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -17,7 +17,8 @@ exports.level = {
|
|||
"ko": "원격 저장소 추적하기",
|
||||
"uk": "Слідкуємо за віддаленим репозиторієм",
|
||||
"vi": "Theo dõi từ xa",
|
||||
"sl_SI": "Sledenje Oddaljenega Repota"
|
||||
"sl_SI": "Sledenje Oddaljenega Repota",
|
||||
"pl": "Śledzenie zdalnych repo"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember there are two ways to set remote tracking!",
|
||||
|
|
@ -34,7 +35,8 @@ exports.level = {
|
|||
"ko": "원격 추적하기를 설정하는데에는 두가지 방법이 있습니다!",
|
||||
"uk": "Пам'ятай, є два способи слідкувати за віддаленим репозиорієм!",
|
||||
"vi": "Hãy nhớ rằng, có 2 cách để thiết lập theo dõi từ xa!",
|
||||
"sl_SI": "Spomni se, da obstajata dva načina za sledenje oddaljenega repota."
|
||||
"sl_SI": "Spomni se, da obstajata dva načina za sledenje oddaljenega repota.",
|
||||
"pl": "Pamiętaj, zdalne repo można śledzić na dwa sposoby!"
|
||||
},
|
||||
"startDialog": {
|
||||
"en_US": {
|
||||
|
|
@ -1927,6 +1929,124 @@ exports.level = {
|
|||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pl": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Gałęzie śledzące",
|
||||
"",
|
||||
"Może ci się wydawać od kilku lekcji, że Git jakoś \"magicznie\" wie, że gałąź `main` jest powiązana z `o/main`. Co prawda nazwy tych gałęzi są podobne i, logicznie rzecz biorąc, `main` na zdalnym repo można skojarzyć z lokalną gałęzią `main`, ale na dwóch przykładach pokażemy, jak to działa w rzeczywistości:",
|
||||
"",
|
||||
"* Podczas operacji pull commity są pobierane do `o/main`, a następnie za pomocą *merge* scalane z gałęzią `main`. Na podstawie tego połączenia określa się pośrednio cel scalania.",
|
||||
"* Podczas operacji push praca z gałęzi `main` jest wypychana do zdalnej gałęzi `main` (lokalnie reprezentowanej przez `o/main`). *Cel* polecenia push jest określony przez połączenie pomiędzy `main` a `o/main`.",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Remote tracking",
|
||||
"",
|
||||
"Żeby nie przedłużać: połączenie pomiędzy `main` i `o/main` da się wyjaśnić po prostu jedną z właściwości gałęzi: \"remote tracking\". Gałąź `main` ma ustawione śledzenie gałęzi `o/main` -- a to oznacza, że dla operacji merge i push określony jest domyślny cel.",
|
||||
"",
|
||||
"Może się zastanawiasz, jak to się stało, że `main` ma już ustawione śledzenie, skoro nie robiliśmy tego żadnym poleceniem. Otóż, kiedy klonujesz repozytorium w Gicie, ta właściwość jest ustawiana za ciebie automatycznie. ",
|
||||
"",
|
||||
"Przy klonowaniu Git tworzy zdalną gałąź dla każdej z gałęzi zdalnego repozytorium (czyli gałęzie takie jak `o/main`). Następnie tworzy lokalną gałąź, która śledzi aktualnie aktywną gałąź na zdalnym repo - czyli najczęściej `main`.",
|
||||
"",
|
||||
"Po zakończeniu klonowania lokalnie masz tylko jedną gałąź (żeby nie zawracać sobie niepotrzebnie głowy), ale możesz zobaczyć wszystkie gałęzie na zdalnym repozytorium (jeśli aż tak cię to ciekawi). To idealne dwa w jednym!",
|
||||
"",
|
||||
"A przy okazji to wyjaśnia, dlaczego przy klonowaniu możesz zobaczyć:",
|
||||
"",
|
||||
" local branch \"main\" set to track remote branch \"o/main\""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### A czy mogę to określić samodzielnie?",
|
||||
"",
|
||||
"Jasne, że tak! Możesz kazać dowolnej gałęzi śledzić `o/main`, i w takim wypadku będzie miała taki sam domyślny cel operacji push i merge co `main`. To znaczy, że możesz zrobić `git push` na gałęzi o nazwie `totallyNotMain`, a twoja praca i tak zostanie wypchnięta do gałęzi `main` w zdalnym repozytorium!",
|
||||
"",
|
||||
"Są dwa sposoby ustawienia tej właściwości. Pierwszym jest checkout nowej gałęzi wykorzystujący zdalną gałąź jako określoną referencję. Polecenie",
|
||||
"",
|
||||
"`git checkout -b totallyNotMain o/main`",
|
||||
"",
|
||||
"tworzy nową gałąź o nazwie `totallyNotMain` i każe jej śledzić `o/main`."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Dość gadania, pora zobaczyć, jak to działa! Będziemy checkoutować nową gałąź o nazwie `foo` i każemy jej śledzić `main` na zdalnym repozytorium."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Jak widzisz, użyliśmy domyślnego celu scalania `o/main`, żeby zaktualizować gałąź `foo`. Zwróć uwagę, że `main` się nie aktualizuje!!!"
|
||||
],
|
||||
"command": "git checkout -b foo o/main; git pull",
|
||||
"beforeCommand": "git clone; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Dotyczy to również git push."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Tadam! Wypchnęliśmy naszą pracę do `main` na `remote`, mimo że nasza gałąź nazywała się zupełnie inaczej."
|
||||
],
|
||||
"command": "git checkout -b foo o/main; git commit; git push",
|
||||
"beforeCommand": "git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Sposób #2",
|
||||
"",
|
||||
"Inny sposób na ustawienie remote tracking na branchu to po prostu użycie opcji `git branch -u`. Polecenie",
|
||||
"",
|
||||
"`git branch -u o/main foo`",
|
||||
"",
|
||||
"spowoduje, że gałąź `foo` będzie śledzić `o/main`. Jeśli aktualnie wybraną gałęzią jest `foo`, to możesz nawet pominąć jej nazwę:",
|
||||
"",
|
||||
"`git branch -u o/main`",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Spójrzmy jeszcze szybko, jak to wygląda w praktyce..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Tak samo jak poprzednio, tylko wyraźniej, widać to w poleceniu. Pięknie!"
|
||||
],
|
||||
"command": "git branch -u o/main foo; git commit; git push",
|
||||
"beforeCommand": "git clone; git checkout -b foo"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Oki! Na tym poziomie wypchnijmy (push) pracę do gałęzi `main` na zdalnym repozytorium, *nie* checkoutując `main` lokalnie. Wymyśl samodzielnie, jak to zrobić. To przecież zaawansowana część kursu :P"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue