mirror/pcottle.learnGitBranching
1
0
Fork 0
mirror of https://github.com/pcottle/learnGitBranching.git synced 2025-07-13 08:04:27 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #1 from pcottle/master

Browse source 
Getting latest changes
This commit is contained in:
vinothmdev 2021-01-02 12:48:47 -05:00 • committed by GitHub
commit c428d4a2af
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
64 changed files with 3611 additions and 2021 deletions
Download patch file Download diff file Expand all files Collapse all files

3
.gitignore vendored
View file

@ -12,6 +12,9 @@ index.html
# Vim swaps
*.sw*
# sed backups
*.bak
# Annoying mac stuff
.DS_STORE

3
README.md
View file

@ -133,6 +133,7 @@ Alternatively, you can also build and run the app in a pre-configured online wor
<a href="https://github.com/tym-network"><img src="https://avatars1.githubusercontent.com/u/2879545?v=4" title="tym-network" width="80" height="80"></a>
<a href="https://github.com/zhyu"><img src="https://avatars1.githubusercontent.com/u/1728523?v=4" title="zhyu" width="80" height="80"></a>
<a href="https://github.com/mgarciaisaia"><img src="https://avatars1.githubusercontent.com/u/1190974?v=4" title="mgarciaisaia" width="80" height="80"></a>
<a href="https://github.com/olsza"><img src="https://avatars1.githubusercontent.com/u/12556170?v=4" title="Olsza" width="80" height="80"></a>
[//]: contributor-faces
@ -161,7 +162,9 @@ And the following heroes for assisting in translating:
* Vasil Kulakov ("coyl") & Lyubov Agadjanyan ("shayenblue")
* Aliaksei Berkau ("alexeiberkov")
* Mizunashi Mana ("mizunashi-mana")
* Olsza
Also huge shoutout for everyone who has put up a pull request that was pulled! Check out the 30+ contributors we have in the [Contributors View](https://github.com/pcottle/learnGitBranching/graphs/contributors)
And everyone who has reported an issue that was successfully closed!

4
__tests__/base.js
View file

@ -33,7 +33,9 @@ var expectLevelAsync = function(headless, levelBlob) {
}
return headless.sendCommand(command).then(function() {
expect(compareLevelTree(headless, levelBlob)).toBeTruthy();
expect(compareLevelTree(headless, levelBlob)).toBeTruthy(
'Level "' + levelBlob['name']['en_US'] + '" should get solved'
);
});
};

14
__tests__/git.spec.js
View file

@ -60,6 +60,13 @@ describe('Git', function() {
);
});
it('Switches', function() {
return expectTreeAsync(
'git switch -c side',
'{"branches":{"master":{"target":"C1","id":"master"},"side":{"target":"C1","id":"side"}},"commits":{"C0":{"parents":[],"id":"C0","rootCommit":true},"C1":{"parents":["C0"],"id":"C1"}},"HEAD":{"target":"side","id":"HEAD"}}'
);
});
it('Rebases', function() {
return expectTreeAsync(
'gc; git checkout -b side C1; gc; git rebase master',
@ -172,6 +179,13 @@ describe('Git', function() {
);
});
it('switches after a rebase ', function() {
return expectTreeAsync(
'git commit; git switch -c bugFix C1; git commit; git rebase master;git switch master',
'%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22master%22%7D%2C%22bugFix%22%3A%7B%22target%22%3A%22C3%27%22%2C%22id%22%3A%22bugFix%22%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C3%27%22%3A%7B%22parents%22%3A%5B%22C2%22%5D%2C%22id%22%3A%22C3%27%22%7D%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%7D'
);
});
it('checks out after an interactive rebase', function() {
return expectTreeAsync(
'git commit; git checkout -b bugFix C1; git commit; git rebase -i master --interactive-test;git checkout master',

16
__tests__/levels.spec.js
View file

@ -1,14 +1,14 @@
var base = require('./base');
describe('GitEngine Levels', function() {
it('solves levels', function() {
var sequences = require('../src/levels/index').levelSequences;
Object.keys(sequences).forEach(function(sequenceKey) {
var levels = sequences[sequenceKey];
Object.keys(levels).forEach(function(index) {
var levelBlob = levels[index];
var sequences = require('../src/levels/index').levelSequences;
Object.keys(sequences).forEach(function(sequenceKey) {
var levels = sequences[sequenceKey];
Object.keys(levels).forEach(function(index) {
var levelBlob = levels[index];
it('solves level ' + levelBlob['name']['en_US'] + ' in sequence ' + sequenceKey, function() {
base.expectLevelSolved(levelBlob);
}.bind(this));
});
});
}.bind(this));
});
});

4
__tests__/remote.spec.js
View file

@ -369,8 +369,8 @@ describe('Git Remotes', function() {
it('pulls with rebase correctly in weird situation with no rebase to do', function() {
return expectTreeAsync(
'git checkout -b side; git commit; git checkout master; git commit; git commit; git merge side; git commit; git clone; git checkout -b main master^^^; git rebase side; git rebase main master; git push;git pull --rebase',
'%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C6%22%2C%22id%22%3A%22master%22%2C%22remoteTrackingBranchID%22%3A%22o/master%22%7D%2C%22side%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22side%22%2C%22remoteTrackingBranchID%22%3A%22o/side%22%7D%2C%22o/master%22%3A%7B%22target%22%3A%22C6%22%2C%22id%22%3A%22o/master%22%2C%22remoteTrackingBranchID%22%3Anull%7D%2C%22o/side%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22o/side%22%2C%22remoteTrackingBranchID%22%3Anull%7D%2C%22main%22%3A%7B%22target%22%3A%22C3%27%22%2C%22id%22%3A%22main%22%2C%22remoteTrackingBranchID%22%3Anull%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C4%22%3A%7B%22parents%22%3A%5B%22C3%22%5D%2C%22id%22%3A%22C4%22%7D%2C%22C5%22%3A%7B%22parents%22%3A%5B%22C2%22%2C%22C4%22%5D%2C%22id%22%3A%22C5%22%7D%2C%22C6%22%3A%7B%22parents%22%3A%5B%22C5%22%5D%2C%22id%22%3A%22C6%22%7D%2C%22C3%27%22%3A%7B%22parents%22%3A%5B%22C2%22%5D%2C%22id%22%3A%22C3%27%22%7D%2C%22C4%27%22%3A%7B%22parents%22%3A%5B%22C3%27%22%5D%2C%22id%22%3A%22C4%27%22%7D%2C%22C6%27%22%3A%7B%22parents%22%3A%5B%22C4%27%22%5D%2C%22id%22%3A%22C6%27%22%7D%7D%2C%22tags%22%3A%7B%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%2C%22originTree%22%3A%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C6%22%2C%22id%22%3A%22master%22%2C%22remoteTrackingBranchID%22%3Anull%7D%2C%22side%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22side%22%2C%22remoteTrackingBranchID%22%3Anull%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C4%22%3A%7B%22parents%22%3A%5B%22C3%22%5D%2C%22id%22%3A%22C4%22%7D%2C%22C5%22%3A%7B%22parents%22%3A%5B%22C2%22%2C%22C4%22%5D%2C%22id%22%3A%22C5%22%7D%2C%22C6%22%3A%7B%22parents%22%3A%5B%22C5%22%5D%2C%22id%22%3A%22C6%22%7D%7D%2C%22tags%22%3A%7B%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%7D%7D'
'git checkout -b side; git commit; git checkout master; git commit; git commit; git merge side; git commit; git clone; git checkout -b otherMain master^^^; git rebase side; git rebase otherMain master; git push;git pull --rebase',
'%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C6%22%2C%22id%22%3A%22master%22%2C%22remoteTrackingBranchID%22%3A%22o/master%22%7D%2C%22side%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22side%22%2C%22remoteTrackingBranchID%22%3A%22o/side%22%7D%2C%22o/master%22%3A%7B%22target%22%3A%22C6%22%2C%22id%22%3A%22o/master%22%2C%22remoteTrackingBranchID%22%3Anull%7D%2C%22o/side%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22o/side%22%2C%22remoteTrackingBranchID%22%3Anull%7D%2C%22otherMain%22%3A%7B%22target%22%3A%22C3%27%22%2C%22id%22%3A%22otherMain%22%2C%22remoteTrackingBranchID%22%3Anull%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C4%22%3A%7B%22parents%22%3A%5B%22C3%22%5D%2C%22id%22%3A%22C4%22%7D%2C%22C5%22%3A%7B%22parents%22%3A%5B%22C2%22%2C%22C4%22%5D%2C%22id%22%3A%22C5%22%7D%2C%22C6%22%3A%7B%22parents%22%3A%5B%22C5%22%5D%2C%22id%22%3A%22C6%22%7D%2C%22C3%27%22%3A%7B%22parents%22%3A%5B%22C2%22%5D%2C%22id%22%3A%22C3%27%22%7D%2C%22C4%27%22%3A%7B%22parents%22%3A%5B%22C3%27%22%5D%2C%22id%22%3A%22C4%27%22%7D%2C%22C6%27%22%3A%7B%22parents%22%3A%5B%22C4%27%22%5D%2C%22id%22%3A%22C6%27%22%7D%7D%2C%22tags%22%3A%7B%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%2C%22originTree%22%3A%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C6%22%2C%22id%22%3A%22master%22%2C%22remoteTrackingBranchID%22%3Anull%7D%2C%22side%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22side%22%2C%22remoteTrackingBranchID%22%3Anull%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C4%22%3A%7B%22parents%22%3A%5B%22C3%22%5D%2C%22id%22%3A%22C4%22%7D%2C%22C5%22%3A%7B%22parents%22%3A%5B%22C2%22%2C%22C4%22%5D%2C%22id%22%3A%22C5%22%7D%2C%22C6%22%3A%7B%22parents%22%3A%5B%22C5%22%5D%2C%22id%22%3A%22C6%22%7D%7D%2C%22tags%22%3A%7B%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%7D%7D'
);
});

BIN
assets/forkme_right_darkblue_121621.png
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 5.2 KiB

2
gulpfile.js
View file

@ -163,7 +163,7 @@ var gitDeployMergeMaster = function(done) {
};
var gitDeployPushOrigin = function(done) {
execSync('git commit -am "rebuild for prod" && ' +
execSync('git commit -am "rebuild for prod"; ' +
'git push origin gh-pages && ' +
'git branch -f trunk gh-pages && ' +
'git checkout master'

20
src/js/dialogs/confirmShowSolution.js
View file

@ -49,6 +49,16 @@ exports.dialog = {
]
}
}],
'es_MX': [{
type: 'ModalAlert',
options: {
markdowns: [
'## ¿Estás seguro de que quieres ver la solución?',
'',
'¡Creo en ti! ¡Yo sé que puedes!'
]
}
}],
'es_ES': [{
type: 'ModalAlert',
options: {
@ -144,6 +154,16 @@ exports.dialog = {
'Verjamem vate! Maš ti to! Ali pač ne?'
]
}
}],
'pl': [{
type: 'ModalAlert',
options: {
markdowns: [
'## Czy na pewno chcesz zobaczyć rozwiązanie?',
'',
'Wierzę w Ciebie! Możesz to zrobić'
]
}
}]
};

38
src/js/dialogs/levelBuilder.js
View file

@ -94,6 +94,25 @@ exports.dialog = {
]
}
}],
'es_MX': [{
type: 'ModalAlert',
options: {
markdowns: [
'## ¡Bienvenido al constructor de niveles!',
'',
'Estos son los pasos principales:',
'',
' * Preparar el entorno inicial usando comandos de Git',
' * Definir el árbol inicial con ```define start```',
' * Introducir la serie de comandos de git que representan la solución óptima',
' * Crear el árbol objetivo con ```define goal```. El objetivo también determina la solución',
' * Opcionalmente, crea pistas con ```define hint```',
' * Dale un nombre con ```define name```',
' * Opcionalmente, crea un mensaje inicial con ```edit dialog```',
' * ¡Introduce el comando ```finish``` para obtener tu nivel en formato JSON!'
]
}
}],
'es_ES': [{
type: 'ModalAlert',
options: {
@ -286,4 +305,23 @@ exports.dialog = {
]
}
}],
'pl': [{
type: 'ModalAlert',
options: {
markdowns: [
'## Witamy w kreatorze poziomów!',
'',
'Oto główne kroki:',
'',
' * Przygotuj środowisko początkowe za pomocą poleceń GIT-a',
' * Zdefiniuj drzewo początkowe za pomocą ```define start```',
' * Wprowadź serię poleceń GIT-a, które tworzą (optymalne) rozwiązanie',
' * Utwórz drzewo celów za pomocą ```define goal```. Określenie celu określa również rozwiązanie',
' * Opcjonalnie utwórz podpowiedzi (wskazówkę) za pomocą ```define hint```',
' * Nadaj nazwę za pomocą ```define name```',
' * Opcjonalnie, utwórz wiadomość początkową za pomocą ```edit dialog```',
' * Wpisz polecenie ```finish```, aby wyświetlić swój poziom w JSON!'
]
}
}],
};

24
src/js/dialogs/nextLevel.js
View file

@ -67,6 +67,17 @@ exports.dialog = {
]
}
}],
'es_MX': [{
type: 'ModalAlert',
options: {
markdowns: [
'## ¡Buen trabajo!',
'',
'Resolviste el nivel en *{numCommands}* comandos; ',
'nuestra mejor solución usa: {best}.'
]
}
}],
'es_ES': [{
type: 'ModalAlert',
options: {
@ -165,5 +176,16 @@ exports.dialog = {
'naša rešitev uporabi {best}.'
]
}
}]
}],
'pl': [{
type: 'ModalAlert',
options: {
markdowns: [
'## Dobra robota!!',
'',
'Rozwiązałeś poziom używając *{numCommands}* poleceń/ia; ',
'nasze rozwiązanie składa się z {best}.'
]
}
}],
};

126
src/js/dialogs/sandbox.js
View file

@ -18,7 +18,14 @@ exports.dialog = {
'',
'PS: Want to go straight to a sandbox next time?',
'Try out ',
'[this special link](https://pcottle.github.io/learnGitBranching/?NODEMO)'
'[this special link](https://pcottle.github.io/learnGitBranching/?NODEMO)',
'',
'PPS: GitHub (and the industry at large) is moving to naming the default branch as `main` instead of `master` ',
'with [more details available here](https://github.com/github/renaming). In order to accommodate this change in ',
'a backwards-compatible way, these two names will be considered aliases of each other, with `main` being ',
'the preferred one to display. We\'ve made a best-effort attempt to update all of the level content, but ',
'there will be a long-tail of areas we have missed. Please submit a PR (or open an issue) if you spot any ',
'egregious ones, and thanks for helping move away from biased terminology.'
]
}
}],
@ -78,6 +85,62 @@ exports.dialog = {
]
}
}],
'es_MX': [{
type: 'ModalAlert',
options: {
markdowns: [
'## ¡Bienvenid@ a Learn Git Branching!',
'',
'Esta aplicación está diseñada para ayudar a los principantes',
'a manejar los poderosos conceptos que hay detrás del trabajo',
'con ramas (branches) en Git. Esperamos que disfrutes la aplicación',
'y tal vez incluso ¡que aprendas algo!',
'',
'# ¡Demo!',
'',
'Si no viste la demo, mirala en ésta dirección:',
'',
'[https://pcottle.github.io/learnGitBranching/?demo](https://pcottle.github.io/learnGitBranching/?demo)',
'',
'¿Harto de este mensaje? Agregale `?NODEMO` a la URL para dejar de verlo, como en éste link:',
'',
'[https://pcottle.github.io/learnGitBranching/?NODEMO](?NODEMO)'
]
}
}, {
type: 'ModalAlert',
options: {
markdowns: [
'## Comandos de git',
'',
'Tienes una gran variedad de comandos de git en este sandbox. He aquí una lista de los incluidos:',
'',
' * commit',
' * branch',
' * checkout',
' * cherry-pick',
' * reset',
' * revert',
' * rebase',
' * merge'
]
}
}, {
type: 'ModalAlert',
options: {
markdowns: [
'## ¡Comparte!',
'',
'Comparte tus árboles con tus amigos usando `export tree` e `import tree`',
'',
'¿Tienes una buena lección que compartir? Prueba construyendo un nivel con `build level` o prueba el nivel de un amigo con `import level`',
'',
'Para ver todos los comandos disponibles, prueba `show commands`. Hay algunos muy prácticos como `undo` y `reset`',
'',
'Por ahora, arranquemos con los `levels`...'
]
}
}],
'es_ES': [{
type: 'ModalAlert',
options: {
@ -508,7 +571,7 @@ exports.dialog = {
markdowns: [
'## Commandes Git',
'',
'Il existe une large variété de commandes git disponibles dans le mode bac à sable. Sont inclues :',
'Il existe une large variété de commandes git disponibles dans le mode bac à sable. Sont incluses :',
'',
' * commit',
' * branch',
@ -659,4 +722,63 @@ exports.dialog = {
]
}
}],
'pl': [{
type: 'ModalAlert',
options: {
markdowns: [
'## Witaj w Learn Git Branching!',
'',
'Celem tej aplikacji jest zilustrowanie rozległych i złożonych relacji pomiędzy procesami związanymi z pracą z GIT-em.',
'Mam nadzieję, że ci się to spodoba i może nawet się czegoś nauczysz!',
'"Learn Git Branching" to najbardziej wizualny i interaktywny sposób na naukę GIT-a w sieci.',
'Będziesz miał do czynienia z ekscytującymi poziomami wraz z pokazaniem krok po kroku potężnych funkcji, a może nawet z odrobiną zabawy po drodze.',
'',
'Jeśli jesteś początkujący, po prostu zacznij od pierwszego poziomu.',
'Jeśli znasz już podstawy GIT-a, wypróbuj niektóre z naszych późniejszych, bardziej wymagających poziomów.',
'',
'# Demo!',
'',
'Jeśli nie widziałeś tej demonstracji, możesz ją obejrzeć tutaj:',
'',
'[https://pcottle.github.io/learnGitBranching/?demo](https://pcottle.github.io/learnGitBranching/?demo)',
'',
'Masz dość tego okna? Dodaj `?NODEMO` do adresu URL, aby się go pozbyć, w ten sposób:',
'',
'[https://pcottle.github.io/learnGitBranching/?NODEMO](?NODEMO)'
]
}
}, {
type: 'ModalAlert',
options: {
markdowns: [
'## Komendy GIT-a',
'',
'W trybie piaskownicy dostępna jest duża liczba poleceń GIT. Między innymi',
'',
' * commit',
' * branch',
' * checkout',
' * cherry-pick',
' * reset',
' * revert',
' * rebase',
' * merge'
]
}
}, {
type: 'ModalAlert',
options: {
markdowns: [
'## Dzielenie się jest Fajne!',
'',
'Podziel się tymi drzewami GIT-a z przyjaciółmi, wpisując `export tree` oraz `import tree`.',
'',
'Czy masz coś, co warto wiedzieć o GIT-cie? Spróbuj zbudować swój poziom wpisując `build level` lub spróbuj poziomu znajomego wpisując `import level`',
'',
'Aby zobaczyć wszystkie polecenia, wpisz `show commands`. Pod spodem są "małe skarby" jak `undo`(cofnij) i `reset`',
'',
'Na razie zacznijmy od wpisania `levels`...'
]
}
}],
};

54
src/js/git/commands.js
View file

@ -253,7 +253,7 @@ var commandConfig = {
source = firstArg;
assertIsBranch(engine.origin, source);
// get o/master locally if master is specified
destination = engine.origin.refs[source].getPrefixedID();
destination = engine.origin.resolveID(source).getPrefixedID();
} else {
// can't be detached
if (engine.getDetachedHead()) {
@ -394,7 +394,7 @@ var commandConfig = {
source = firstArg;
assertIsBranch(engine.origin, source);
// get o/master locally if master is specified
destination = engine.origin.refs[source].getPrefixedID();
destination = engine.origin.resolveID(source).getPrefixedID();
}
if (source) { // empty string fails this check
assertIsRef(engine.origin, source);
@ -447,8 +447,8 @@ var commandConfig = {
assertIsRemoteBranch(engine, remoteBranch);
assertIsBranch(engine, branch);
engine.setLocalToTrackRemote(
engine.refs[branch],
engine.refs[remoteBranch]
engine.resolveID(branch),
engine.resolveID(remoteBranch)
);
return;
}
@ -743,7 +743,7 @@ var commandConfig = {
var refspecParts = firstArg.split(':');
source = refspecParts[0];
destination = validateBranchName(engine, refspecParts[1]);
if (source === "" && !engine.origin.refs[destination]) {
if (source === "" && !engine.origin.resolveID(destination)) {
throw new GitError({
msg: intl.todo(
'cannot delete branch ' + options.destination + ' which doesnt exist'
@ -770,7 +770,7 @@ var commandConfig = {
sourceObj.getRemoteTrackingBranchID()) {
assertBranchIsRemoteTracking(engine, source);
var remoteBranch = sourceObj.getRemoteTrackingBranchID();
destination = engine.refs[remoteBranch].getBaseID();
destination = engine.resolveID(remoteBranch).getBaseID();
} else {
destination = validateBranchName(engine, source);
}
@ -855,6 +855,48 @@ var commandConfig = {
command.twoArgsImpliedHead(generalArgs);
engine.tag(generalArgs[0], generalArgs[1]);
}
},
switch: {
sc: /^(gsw|git sw)($|\s)/,
regex: /^git +switch($|\s)/,
options: [
'-c',
'-'
],
execute: function(engine, command) {
var generalArgs = command.getGeneralArgs();
var commandOptions = command.getOptionsMap();
var args = null;
if (commandOptions['-c']) {
// the user is really trying to just make a
// branch and then switch to it. so first:
args = commandOptions['-c'].concat(generalArgs);
command.twoArgsImpliedHead(args, '-c');
var validId = engine.validateBranchName(args[0]);
engine.branch(validId, args[1]);
engine.checkout(validId);
return;
}
if (commandOptions['-']) {
// get the heads last location
var lastPlace = engine.HEAD.get('lastLastTarget');
if (!lastPlace) {
throw new GitError({
msg: intl.str('git-result-nothing')
});
}
engine.HEAD.set('target', lastPlace);
return;
}
command.validateArgBounds(generalArgs, 1, 1);
engine.checkout(engine.crappyUnescape(generalArgs[0]));
}
}
};

63
src/js/git/index.js
View file

@ -381,7 +381,7 @@ GitEngine.prototype.makeOrigin = function(treeString) {
};
GitEngine.prototype.makeRemoteBranchIfNeeded = function(branchName) {
if (this.refs[ORIGIN_PREFIX + branchName]) {
if (this.doesRefExist(ORIGIN_PREFIX + branchName)) {
return;
}
// if its not a branch on origin then bounce
@ -394,7 +394,7 @@ GitEngine.prototype.makeRemoteBranchIfNeeded = function(branchName) {
};
GitEngine.prototype.makeBranchIfNeeded = function(branchName) {
if (this.refs[branchName]) {
if (this.doesRefExist(branchName)) {
return;
}
var where = this.findCommonAncestorForRemote(
@ -405,7 +405,7 @@ GitEngine.prototype.makeBranchIfNeeded = function(branchName) {
};
GitEngine.prototype.makeRemoteBranchForRemote = function(branchName) {
var target = this.origin.refs[branchName].get('target');
var target = this.origin.resolveID(branchName).get('target');
var originTarget = this.findCommonAncestorWithRemote(
target.get('id')
);
@ -668,7 +668,7 @@ GitEngine.prototype.validateBranchName = function(name) {
GitEngine.prototype.validateAndMakeBranch = function(id, target) {
id = this.validateBranchName(id);
if (this.refs[id]) {
if (this.doesRefExist(id)) {
throw new GitError({
msg: intl.str(
'bad-branch-name',
@ -695,8 +695,14 @@ GitEngine.prototype.validateAndMakeTag = function(id, target) {
};
GitEngine.prototype.makeBranch = function(id, target) {
// all main branches are stored as master under the hood
if (id.match(/\bmain\b/)) {
id = id.replace(/\bmain\b/, 'master');
}
if (this.refs[id]) {
throw new Error('woah already have that');
var err = new Error();
throw new Error('woah already have that ref ' + id + ' ' + err.stack);
}
var branch = new Branch({
@ -1065,14 +1071,15 @@ GitEngine.prototype.push = function(options) {
return;
}
var sourceBranch = this.refs[options.source];
var sourceBranch = this.resolveID(options.source);
if (sourceBranch && sourceBranch.attributes.type === 'tag') {
throw new GitError({
msg: intl.todo('Tags are not allowed as sources for pushing'),
});
}
if (!this.origin.refs[options.destination]) {
if (!this.origin.doesRefExist(options.destination)) {
console.warn('ref', options.destination);
this.makeBranchOnOriginAndTrack(
options.destination,
this.getCommitFromRef(sourceBranch)
@ -1083,7 +1090,7 @@ GitEngine.prototype.push = function(options) {
this.animationFactory.playRefreshAnimation(this.origin.gitVisuals);
this.animationFactory.playRefreshAnimation(this.gitVisuals);
}
var branchOnRemote = this.origin.refs[options.destination];
var branchOnRemote = this.origin.resolveID(options.destination);
var sourceLocation = this.resolveID(options.source || 'HEAD');
// first check if this is even allowed by checking the sync between
@ -1184,7 +1191,7 @@ GitEngine.prototype.push = function(options) {
// HAX HAX update master and remote tracking for master
chain = chain.then(function() {
var localCommit = this.getCommitFromRef(sourceLocation);
this.setTargetLocation(this.refs[ORIGIN_PREFIX + options.destination], localCommit);
this.setTargetLocation(this.resolveID(ORIGIN_PREFIX + options.destination), localCommit);
return this.animationFactory.playRefreshAnimation(this.gitVisuals);
}.bind(this));
@ -1313,7 +1320,7 @@ GitEngine.prototype.fetchCore = function(sourceDestPairs, options) {
// need to get the parents first. since we order by depth, we know
// the dependencies are there already
var parents = parentIDs.map(function(parentID) {
return this.refs[parentID];
return this.resolveID(parentID);
}, this);
return this.makeCommit(parents, id);
}.bind(this);
@ -1345,7 +1352,7 @@ GitEngine.prototype.fetchCore = function(sourceDestPairs, options) {
chain = chain.then(function() {
return this.animationFactory.playHighlightPromiseAnimation(
this.origin.refs[commitJSON.id],
this.origin.resolveID(commitJSON.id),
localBranch
);
}.bind(this));
@ -1361,7 +1368,7 @@ GitEngine.prototype.fetchCore = function(sourceDestPairs, options) {
chain = chain.then(function() {
// update all the destinations
sourceDestPairs.forEach(function (pair) {
var ours = this.refs[pair.destination];
var ours = this.resolveID(pair.destination);
var theirCommitID = this.origin.getCommitFromRef(pair.source).get('id');
// by definition we just made the commit with this id,
// so we can grab it now
@ -1400,7 +1407,7 @@ GitEngine.prototype.pull = function(options) {
return;
}
var destBranch = this.refs[options.destination];
var destBranch = this.resolveID(options.destination);
// then either rebase or merge
if (options.isRebase) {
this.pullFinishWithRebase(pendingFetch, localBranch, destBranch);
@ -1611,7 +1618,8 @@ GitEngine.prototype.resolveName = function(someRef) {
GitEngine.prototype.resolveID = function(idOrTarget) {
if (idOrTarget === null || idOrTarget === undefined) {
throw new Error('Don\'t call this with null / undefined');
var err = new Error();
throw new Error('Don\'t call this with null / undefined: ' + err.stack);
}
if (typeof idOrTarget !== 'string') {
@ -1652,8 +1660,20 @@ GitEngine.prototype.resolveRelativeRef = function(commit, relative) {
return commit;
};
GitEngine.prototype.doesRefExist = function(ref) {
if (ref.match(/\bmain\b/)) {
ref = ref.replace(/\bmain\b/, 'master');
}
return !!this.refs[ref]
};
GitEngine.prototype.resolveStringRef = function(ref) {
ref = this.crappyUnescape(ref);
if (ref.match(/\bmain\b/)) {
ref = ref.replace(/\bmain\b/, 'master');
}
if (this.refs[ref]) {
return this.refs[ref];
}
@ -2501,7 +2521,7 @@ GitEngine.prototype.checkout = function(idOrTarget) {
GitEngine.prototype.forceBranch = function(branchName, where) {
branchName = this.crappyUnescape(branchName);
// if branchname doesn't exist...
if (!this.refs[branchName]) {
if (!this.doesRefExist(branchName)) {
this.branch(branchName, where);
}
@ -2922,30 +2942,27 @@ var Commit = Backbone.Model.extend({
},
getLogEntry: function() {
// for now we are just joining all these things with newlines which
// will get placed by paragraph tags. Not really a fan of this, but
// it's better than making an entire template and all that jazz
return [
'Author: ' + this.get('author'),
'Date: ' + this.get('createTime'),
'<br/>',
'',
this.get('commitMessage'),
'<br/>',
'',
'Commit: ' + this.get('id')
].join('\n' ) + '\n';
].join('<br/>') + '\n';
},
getShowEntry: function() {
// same deal as above, show log entry and some fake changes
return [
this.getLogEntry(),
this.getLogEntry().replace('\n', ''),
'diff --git a/bigGameResults.html b/bigGameResults.html',
'--- bigGameResults.html',
'+++ bigGameResults.html',
'@@ 13,27 @@ Winner, Score',
'- Stanfurd, 14-7',
'+ Cal, 21-14'
].join('\n') + '\n';
].join('<br/>') + '\n';
},
validateAtInit: function() {

403
src/js/intl/strings.js
View file

File diff suppressed because it is too large Load diff

2
src/js/level/builder.js
View file

@ -54,7 +54,7 @@ var LevelBuilder = Level.extend({
// if we are editing a level our behavior is a bit different
var editLevelJSON;
if (options.editLevel) {
LevelStore.getLevel(options.editLevel);
editLevelJSON = LevelStore.getLevel(options.editLevel);
options.level = editLevelJSON;
}

15
src/js/models/commandModel.js
View file

@ -3,6 +3,7 @@ var Backbone = require('backbone');
var Errors = require('../util/errors');
var ParseWaterfall = require('../level/parseWaterfall').ParseWaterfall;
var LevelStore = require('../stores/LevelStore');
var intl = require('../intl');
var CommandProcessError = Errors.CommandProcessError;
@ -267,8 +268,18 @@ var Command = Backbone.Model.extend({
},
parseAll: function() {
var str = this.get('rawStr');
var results = this.get('parseWaterfall').parseAll(str);
var rawInput = this.get('rawStr');
const aliasMap = LevelStore.getAliasMap();
for (var i = 0; i<Object.keys(aliasMap).length; i++) {
var alias = Object.keys(aliasMap)[i];
var searcher = new RegExp(alias + "(\\s|$)", "g");
if (searcher.test(rawInput)) {
rawInput = rawInput.replace(searcher, aliasMap[alias] + ' ');
break;
}
}
var results = this.get('parseWaterfall').parseAll(rawInput);
if (!results) {
// nothing parsed successfully

22
src/js/react_views/IntlHelperBarView.jsx
View file

@ -66,6 +66,12 @@ class IntlHelperBarView extends React.Component{
onClick: function() {
this.fireCommand('locale es_AR; levels');
}.bind(this)
}, {
text: 'mexicano',
testID: 'mexican',
onClick: function() {
this.fireCommand('locale es_MX; levels');
}.bind(this)
}, {
text: 'português',
testID: 'portuguese',
@ -108,17 +114,23 @@ class IntlHelperBarView extends React.Component{
onClick: function() {
this.fireCommand('locale gl; levels');
}.bind(this)
}, {
icon: 'signout',
onClick: function() {
this.props.onExit();
}.bind(this)
}, {
text: 'Slovensko',
testID: 'slovenian',
onClick: function() {
this.fireCommand('locale sl_SI; levels');
}.bind(this)
}, {
text: 'Polski',
testID: 'polish',
onClick: function() {
this.fireCommand('locale pl; levels');
}.bind(this)
}, {
icon: 'signout',
onClick: function() {
this.props.onExit();
}.bind(this)
}
];
}

16
src/js/sandbox/commands.js
View file

@ -8,6 +8,7 @@ var Errors = require('../util/errors');
var CommandProcessError = Errors.CommandProcessError;
var LocaleStore = require('../stores/LocaleStore');
var LocaleActions = require('../actions/LocaleActions');
var LevelStore = require('../stores/LevelStore');
var GlobalStateStore = require('../stores/GlobalStateStore');
var GlobalStateActions = require('../actions/GlobalStateActions');
var GitError = Errors.GitError;
@ -50,6 +51,21 @@ var instantCommands = [
msg: lines.join('\n')
});
}],
[/^alias (\w+)="(.+)"$/, function(bits) {
const alias = bits[1];
const expansion = bits[2];
LevelStore.addToAliasMap(alias, expansion);
throw new CommandResult({
msg: 'Set alias "'+alias+'" to "'+expansion+'"',
});
}],
[/^unalias (\w+)$/, function(bits) {
const alias = bits[1];
LevelStore.removeFromAliasMap(alias);
throw new CommandResult({
msg: 'Removed alias "'+alias+'"',
});
}],
[/^locale (\w+)$/, function(bits) {
LocaleActions.changeLocale(bits[1]);
throw new CommandResult({

25
src/js/stores/LevelStore.js
View file

@ -9,6 +9,7 @@ var util = require('../util');
var ActionTypes = AppConstants.ActionTypes;
var SOLVED_MAP_STORAGE_KEY = 'solvedMap';
var ALIAS_STORAGE_KEY = 'aliasMap';
var _levelMap = {};
var _solvedMap = {};
@ -55,6 +56,26 @@ function _syncToStorage() {
}
}
function getAliasMap() {
try {
return JSON.parse(localStorage.getItem(ALIAS_STORAGE_KEY) || '{}') || {};
} catch (e) {
return {};
}
}
function addToAliasMap(alias, expansion) {
const aliasMap = getAliasMap();
aliasMap[alias] = expansion;
localStorage.setItem(ALIAS_STORAGE_KEY, JSON.stringify(aliasMap));
}
function removeFromAliasMap(alias) {
const aliasMap = getAliasMap();
delete aliasMap[alias];
localStorage.setItem(ALIAS_STORAGE_KEY, JSON.stringify(aliasMap));
}
var validateLevel = function(level) {
level = level || {};
var requiredFields = [
@ -108,6 +129,10 @@ var LevelStore = Object.assign(
EventEmitter.prototype,
AppConstants.StoreSubscribePrototype,
{
getAliasMap: getAliasMap,
addToAliasMap: addToAliasMap,
removeFromAliasMap: removeFromAliasMap,
getSequenceToLevels: function() {
return levelSequences;
},

4
src/js/stores/LocaleStore.js
View file

@ -22,13 +22,15 @@ var langLocaleMap = {
ru: 'ru_RU',
uk: 'uk',
vi: 'vi',
sl: 'sl_SI'
sl: 'sl_SI',
pl: 'pl'
};
var headerLocaleMap = {
'zh-CN': 'zh_CN',
'zh-TW': 'zh_TW',
'pt-BR': 'pt_BR',
'es-MX': 'es_MX',
'es-ES': 'es_ES',
'sl-SI': 'sl_SI'
};

4
src/js/views/index.js
View file

@ -139,8 +139,8 @@ var ConfirmCancelView = ResolveRejectBase.extend({
this.destination = options.destination;
this.deferred = options.deferred || Q.defer();
this.JSON = {
confirm: options.confirm || 'Confirm',
cancel: options.cancel || 'Cancel'
confirm: options.confirm || intl.str('confirm-button'),
cancel: options.cancel || intl.str('cancel-button')
};
this.render();

2
src/js/visuals/index.js
View file

@ -240,7 +240,7 @@ GitVisuals.prototype.finishAnimation = function(speed) {
opacity: 0,
'font-weight': 500,
'font-size': '32pt',
'font-family': 'Monaco, Courier, font-monospace',
'font-family': 'Menlo, Monaco, Consolas, \'Droid Sans Mono\', monospace',
stroke: '#000',
'stroke-width': 2,
fill: '#000'

5
src/js/visuals/visBranch.js
View file

@ -357,6 +357,9 @@ var VisBranch = VisBase.extend({
if (name === 'HEAD' && isHg) {
name = '.';
}
if (name.match(/\bmaster\b/)) {
name = name.replace(/\bmaster\b/, 'main');
}
var after = (selected && !this.getIsInOrigin() && !isRemote) ? '*' : '';
return name + after;
@ -410,7 +413,7 @@ var VisBranch = VisBase.extend({
var text = paper.text(textPos.x, textPos.y, String(name));
text.attr({
'font-size': 14,
'font-family': 'Monaco, Courier, font-monospace',
'font-family': 'Menlo, Monaco, Consolas, \'Droid Sans Mono\', monospace',
opacity: this.getTextOpacity()
});
this.set('text', text);

2
src/js/visuals/visNode.js
View file

@ -451,7 +451,7 @@ var VisNode = VisBase.extend({
text.attr({
'font-size': this.getFontSize(this.get('id')),
'font-weight': 'bold',
'font-family': 'Monaco, Courier, font-monospace',
'font-family': 'Menlo, Monaco, Consolas, \'Droid Sans Mono\', monospace',
opacity: this.getOpacity()
});

2
src/js/visuals/visTag.js
View file

@ -254,7 +254,7 @@ var VisTag = VisBase.extend({
var text = paper.text(textPos.x, textPos.y, String(name));
text.attr({
'font-size': 14,
'font-family': 'Monaco, Courier, font-monospace',
'font-family': 'Menlo, Monaco, Consolas, \'Droid Sans Mono\', monospace',
opacity: this.getTextOpacity(),
'text-anchor': 'start'
});

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

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C7\",\"id\":\"master\"},\"bugWork\":{\"target\":\"C2\",\"id\":\"bugWork\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C2\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C4\",\"C5\"],\"id\":\"C6\"},\"C7\":{\"parents\":[\"C6\"],\"id\":\"C7\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}",
"solutionCommand": "git branch bugWork master^^2^",
"solutionCommand": "git branch bugWork main^^2^",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C7\",\"id\":\"master\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C2\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C4\",\"C5\"],\"id\":\"C6\"},\"C7\":{\"parents\":[\"C6\"],\"id\":\"C7\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}",
"name": {
"en_US": "Multiple parents",
@ -9,6 +9,7 @@ exports.level = {
"de_DE": "Mehrere Vorgänger",
"ja" : "複数の親",
"es_AR": "Múltiples padres",
"es_MX": "Múltiples padres",
"es_ES": "Múltiples padres",
"pt_BR": "Múltiplos pais",
"gl" : "Múltiples pais",
@ -26,6 +27,7 @@ exports.level = {
'fr_FR': 'Utilisez "git branch bugWork" avec un commit pour créer une référence manquante',
"zh_CN": "使用 `git branch bugWork` 加上一个目标提交记录来创建消失的引用。",
"es_AR": "Usá `git branch bugWork` sobre algún commit para crear la referencia faltante",
"es_MX": "Use `git branch bugWork` sobre algún commit para crear la referencia faltante",
"es_ES": "Usa `git branch bugWork` sobre algún commit para crear la referencia que falta",
"pt_BR": "Use `git branch bugWork` com um commit alvo para criar a referência que falta",
"gl" : "Usa `git branch bugWork` sobre calquera commit para crear a referencia que falta",
@ -60,15 +62,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Here we have a merge commit. If we checkout `master^` without the modifier, we will follow the first parent after the merge commit. ",
"Here we have a merge commit. If we checkout `main^` without the modifier, we will follow the first parent after the merge commit. ",
"",
"(*In our visuals, the first parent is positioned directly above the merge commit.*)"
],
"afterMarkdowns": [
"Easy -- this is what we are all used to."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -80,8 +82,8 @@ exports.level = {
"afterMarkdowns": [
"See? We followed the other parent upwards."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -94,7 +96,7 @@ exports.level = {
"Lightning fast!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -107,7 +109,7 @@ exports.level = {
"The same movement as before, but all in one command."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -147,15 +149,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Hier sehen wir einen Merge-Commit. Wenn wir einen Checkout von `master^` ohne Zahl machen, wird Git auf den ersten Vorgänger des Commits zurückgehen. ",
"Hier sehen wir einen Merge-Commit. Wenn wir einen Checkout von `main^` ohne Zahl machen, wird Git auf den ersten Vorgänger des Commits zurückgehen. ",
"",
"*(In unserer Darstellung befindet sich der erste Vorgänger direkt über dem Merge-Commit.)*"
],
"afterMarkdowns": [
"Simpel -- so kennen wir das."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -167,8 +169,8 @@ exports.level = {
"afterMarkdowns": [
"Gesehen? Wir gehen zu dem anderen Vorgänger zurück."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -181,7 +183,7 @@ exports.level = {
"Bämm!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -194,7 +196,7 @@ exports.level = {
"Gleicher Ablauf wie zuvor, nur alles in einem Befehl."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -234,15 +236,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Nous avons un commit/merge. Si nous faisons checkout `master^` sans le symbole, on obtient le premier parent suivant ce commit. ",
"Nous avons un commit/merge. Si nous faisons checkout `main^` sans le symbole, on obtient le premier parent suivant ce commit. ",
"",
"(*Dans notre vue, le premier parent se situe juste au dessus du merge.*)"
],
"afterMarkdowns": [
"Facile -- C\'est ce que nous faisons tout le temps."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -254,8 +256,8 @@ exports.level = {
"afterMarkdowns": [
"Vous voyez ? Nous suivons le second parent."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -268,7 +270,7 @@ exports.level = {
"Boum, vitesse du tonnerre !"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -281,7 +283,7 @@ exports.level = {
"Le même résultat, mais en une seule commande."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -321,15 +323,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"这里有一个合并提交记录。如果不加数字修改符直接检出 `master^`，会回到第一个父提交记录。",
"这里有一个合并提交记录。如果不加数字修改符直接检出 `main^`，会回到第一个父提交记录。",
"",
"(*在我们的图示中，第一个父提交记录是指合并提交记录正上方的那个提交记录。*)"
],
"afterMarkdowns": [
"这正是我们都已经习惯的方法。"
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -341,8 +343,8 @@ exports.level = {
"afterMarkdowns": [
"看见了吧？我们回到了另外一个父提交上。"
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -355,7 +357,7 @@ exports.level = {
"快若闪电！"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -368,7 +370,7 @@ exports.level = {
"和前面的结果一样，但只用了一条命令。"
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -408,15 +410,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Acá tenemos un commit de merge. Si hacemos checkout de `master^`, sin modificadores, vamos a seguir al primer padre después del commit de merge. ",
"Acá tenemos un commit de merge. Si hacemos checkout de `main^`, sin modificadores, vamos a seguir al primer padre después del commit de merge. ",
"",
"(*En nuestras visualizaciones, el primer padre se ubica directamente arriba del commit de merge.*)"
],
"afterMarkdowns": [
"Fácil -- esto es a lo que estamos acostumbrados."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -428,8 +430,8 @@ exports.level = {
"afterMarkdowns": [
"¿Ves? Seguimos al otro padre hacia arriba."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -442,7 +444,7 @@ exports.level = {
"¡Rapidísimo!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -455,7 +457,7 @@ exports.level = {
"El mismo movimiento que antes, pero todo en uno."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -472,6 +474,93 @@ exports.level = {
}
]
},
"es_MX": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"### Especificando los padres",
"",
"Como el modificador de `~`, `^` también acepta un número opcional después de él.",
"",
"En lugar de especificar cuántas generaciones hacia atrás ir (como `~`), el modificador de `^` especifica por cuál de las referencias padres seguir en un commit de merge. Recuerda que un commit de merge tiene múltiples padres, por lo que el camino a seguir es ambiguo.",
"",
"Git normalmente sigue el \"primer\" padre de un commit de merge, pero especificando un número junto con `^` cambia este comportamiento predefinido.",
"",
"Demasiada charla, veámoslo en acción.",
""
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Acá tenemos un commit de merge. Si hacemos checkout de `main^`, sin modificadores, vamos a seguir al primer padre después del commit de merge. ",
"",
"(*En nuestras visualizaciones, el primer padre se ubica directamente arriba del commit de merge.*)"
],
"afterMarkdowns": [
"Fácil -- esto es a lo que estamos acostumbrados."
],
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ahora tratemos de especificar el segundo padre, en cambio..."
],
"afterMarkdowns": [
"¿Ves? Seguimos al otro padre hacia arriba."
],
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Los modificadores de `^` y `~` son muy poderosos a la hora de movernos en un árbol:"
],
"afterMarkdowns": [
"¡Rapidísimo!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Más loco aún, ¡Éstos modificadores pueden encadenarse entre sí! Mira esto:"
],
"afterMarkdowns": [
"El mismo movimiento que antes, pero todo en uno."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"### Pongámoslo en práctica",
"",
"Para completar este nivel, crea una nueva rama en la ubicación indicada.",
"",
"Obviamente sería muy fácil especificar el commit directamente (algo como `C6`), pero te reto a usar los modificadores de los que estuvimos hablando, mejor."
]
}
}
]
},
"es_ES": {
"childViews": [
{
@ -495,15 +584,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Aquí tenemos un commit de merge. Si hacemos checkout de `master^`, sin modificadores, vamos a seguir al primer padre después del commit de merge. ",
"Aquí tenemos un commit de merge. Si hacemos checkout de `main^`, sin modificadores, vamos a seguir al primer padre después del commit de merge. ",
"",
"(*En nuestras visualizaciones, el primer padre se ubica directamente arriba del commit de merge.*)"
],
"afterMarkdowns": [
"Fácil -- esto es a lo que estamos acostumbrados."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -515,8 +604,8 @@ exports.level = {
"afterMarkdowns": [
"¿Ves? Seguimos al otro padre hacia arriba."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -529,7 +618,7 @@ exports.level = {
"¡Rapidísimo!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -542,7 +631,7 @@ exports.level = {
"El mismo movimiento que antes, pero todo en uno."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -582,15 +671,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Aqui temos um commit de merge. Se fizermos checkout em `master^` sem especificar um número, vamos seguir o primeiro pai acima do commit de merge. ",
"Aqui temos um commit de merge. Se fizermos checkout em `main^` sem especificar um número, vamos seguir o primeiro pai acima do commit de merge. ",
"",
"(*Em nossa visualização, o primeiro pai é aquele diretamente acima do commit de merge.*)"
],
"afterMarkdowns": [
"Fácil -- isso é aquilo com o que já estamos acostumados."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -602,8 +691,8 @@ exports.level = {
"afterMarkdowns": [
"Viu? Subimos para o outro pai."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -616,7 +705,7 @@ exports.level = {
"Rápido como a luz!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -629,7 +718,7 @@ exports.level = {
"O mesmo movimento que o anterior, mas tudo em um único comando."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -670,15 +759,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Aquí temos un commit do merge. Se fixéramos checkout en `master^` sen especificar un número, imos seguir ó primeiro pai enriba do commit do merge. ",
"Aquí temos un commit do merge. Se fixéramos checkout en `main^` sen especificar un número, imos seguir ó primeiro pai enriba do commit do merge. ",
"",
"(*Na nosa vista, o primeiro pai é aquel directamente enriba do commit do merge.*)"
],
"afterMarkdowns": [
"Sinxelo, eso é aquelo co que xa estamos acostumados."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -690,8 +779,8 @@ exports.level = {
"afterMarkdowns": [
"¿Viches? Subimos para o outro pai."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -704,7 +793,7 @@ exports.level = {
"Rápido coma a luz!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -717,7 +806,7 @@ exports.level = {
"O mesmo movemento feito antes, pero feito nun só comando."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -757,15 +846,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"這裡有一個 merge commit。如果後面不加數字的話會直接切換到`master^`，也就是說會回到第一個 parent commit。",
"這裡有一個 merge commit。如果後面不加數字的話會直接切換到`main^`，也就是說會回到第一個 parent commit。",
"",
"(*在我們的圖示中，第一個 parent commit 是指 merge commit 正上方的那一個 parent commit。*)"
],
"afterMarkdowns": [
"簡單吧！這就是預設的情況。"
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -777,8 +866,8 @@ exports.level = {
"afterMarkdowns": [
"看到了嗎？我們回到了第二個 parent commit。"
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -791,7 +880,7 @@ exports.level = {
"簡直就像是電光石火！"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -804,7 +893,7 @@ exports.level = {
"和前面的結果一樣，但只用了一條指令。"
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -844,15 +933,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Вот мерджевый коммит. Если мы перейдём на `master^` без номера, то попадём на первого родителя.",
"Вот мерджевый коммит. Если мы перейдём на `main^` без номера, то попадём на первого родителя.",
"",
"(*На нашей визуализации первый родитель находится прямо над коммитом*)"
],
"afterMarkdowns": [
"Просто - прямо как мы любим."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -864,8 +953,8 @@ exports.level = {
"afterMarkdowns": [
"Вот. Мы на втором родительском коммите."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -878,7 +967,7 @@ exports.level = {
"Быстро как Флэш!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -891,7 +980,7 @@ exports.level = {
"Сделаем то же самое, что перед этим, только в одну команду."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -931,15 +1020,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"ここに、マージコミットがあります。もし、指定無しに`master^`でチェックアウトした場合、私たちは一番目の親に移動することになります。",
"ここに、マージコミットがあります。もし、指定無しに`main^`でチェックアウトした場合、私たちは一番目の親に移動することになります。",
"",
"(*私たちのツリーでは、一番目の親はマージコミットのちょうど上に位置しています。*)"
],
"afterMarkdowns": [
"簡単ですね -- これがデフォルトの動作になります。"
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -951,8 +1040,8 @@ exports.level = {
"afterMarkdowns": [
"見ましたか？私たちは他の親に移ることができました。"
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -965,7 +1054,7 @@ exports.level = {
"超高速ですね！"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -978,7 +1067,7 @@ exports.level = {
"前と同じ移動ですが、なんと一つのコマンドでできています。"
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -1018,15 +1107,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"여기 병합된 커밋이 있습니다. 우리가 `master`를 수식없이 체크아웃한다면 병합된 커밋의 첫 부모를 따라 올라갈 것입니다. ",
"여기 병합된 커밋이 있습니다. 우리가 `main`를 수식없이 체크아웃한다면 병합된 커밋의 첫 부모를 따라 올라갈 것입니다. ",
"",
"(*화면에서는 첫 부모는 병합된 커밋 바로 위에 위치해 있습니다.*)"
],
"afterMarkdowns": [
"간단하죠 -- 우리한테 익숙한 모습입니다."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -1038,8 +1127,8 @@ exports.level = {
"afterMarkdowns": [
"보이나요? 다른 부모를 선택해 올라갔습니다."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -1052,7 +1141,7 @@ exports.level = {
"빛처럼 빠르게 말이죠!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -1065,7 +1154,7 @@ exports.level = {
"앞과 같은 움직임이지만 하나의 명령으로 표현되었습니다."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -1105,15 +1194,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ось ми маємо мерджевий коміт. Якщо зробимо checkout `master^` без числа, ми потрапимо на першого з предків ",
"Ось ми маємо мерджевий коміт. Якщо зробимо checkout `main^` без числа, ми потрапимо на першого з предків ",
"",
"(*В нашій візуалізації перший предок знаходиться прямо над мерджевим комітом*)"
],
"afterMarkdowns": [
"Легко -- те до чого ми всі звикли."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -1125,8 +1214,8 @@ exports.level = {
"afterMarkdowns": [
"Бачиш? Ми перейшли до другого батька вверх."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -1139,7 +1228,7 @@ exports.level = {
"Супер швидко!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -1152,7 +1241,7 @@ exports.level = {
"Те саме, що й перед цим, але однією командою."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -1192,15 +1281,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ở đây ta có 1 commit merge. Nếu ta dùng lệnh `master^` mà không bổ nghĩa cho nó, ta sẽ đi ngược lên commit cha đầu tiên của merge commit. ",
"Ở đây ta có 1 commit merge. Nếu ta dùng lệnh `main^` mà không bổ nghĩa cho nó, ta sẽ đi ngược lên commit cha đầu tiên của merge commit. ",
"",
"(*Trong hình minh họa bên trái thì commit cha đầu tiên được xếp hẳng hàng ngay phía trên của commit merge.*)"
],
"afterMarkdowns": [
"Dễ dàng -- đó là cách mà ta thường làm."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -1212,8 +1301,8 @@ exports.level = {
"afterMarkdowns": [
"Thấy chứ? Ta đã leo lên commit cha khác lúc trước."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -1226,7 +1315,7 @@ exports.level = {
"Nhanh như chớp!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -1239,7 +1328,7 @@ exports.level = {
"Cùng con đường như lúc trước, nhưng chỉ cần 1 dòng lệnh."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -1279,15 +1368,15 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Tukaj imamo merge commit. Če checkoutamo `master^` brez modifikatorjev, bomo sledili prvem staršu po merge commitu. ",
"Tukaj imamo merge commit. Če checkoutamo `main^` brez modifikatorjev, bomo sledili prvem staršu po merge commitu. ",
"",
"(* V naši vizualizaciji, je postavljen prvi starš direktno nad merge commitom.)"
],
"afterMarkdowns": [
"Enostavno -- tega smo vsi navajeni."
],
"command": "git checkout master^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -1299,8 +1388,8 @@ exports.level = {
"afterMarkdowns": [
"Vidiš? Sledili smo drugemu staršu navzgor."
],
"command": "git checkout master^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout master; git merge C2"
"command": "git checkout main^2",
"beforeCommand": "git checkout HEAD^; git commit; git checkout main; git merge C2"
}
},
{
@ -1313,7 +1402,7 @@ exports.level = {
"Bliskovito!"
],
"command": "git checkout HEAD~; git checkout HEAD^2; git checkout HEAD~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{
@ -1326,7 +1415,7 @@ exports.level = {
"Isto gibanje kot prej, ampak vse z enim ukazom."
],
"command": "git checkout HEAD~^2~2",
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout master; git merge C5; git commit"
"beforeCommand": "git commit; git checkout C0; git commit; git commit; git commit; git checkout main; git merge C5; git commit"
}
},
{

56
src/levels/index.js
View file

@ -60,6 +60,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : 'まずはここから',
'fr_FR': 'Séquence d\'introduction',
'es_AR': 'Secuencia introductoria',
'es_MX': 'Secuencia introductoria',
'es_ES': 'Secuencia introductoria',
'pt_BR': 'Sequência introdutória',
'gl' : 'Secuencia introductoria',
@ -69,7 +70,8 @@ var sequenceInfo = exports.sequenceInfo = {
'ru_RU': 'Введение',
'uk' : 'Вступ',
'vi' : 'Giới thiệu chuỗi luyện tập',
'sl_SI': 'Uvodno Zaporedje'
'sl_SI': 'Uvodno Zaporedje',
'pl' : 'Sekwencja wprowadzająca'
},
about: {
'en_US': 'A nicely paced introduction to the majority of git commands',
@ -77,6 +79,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : 'gitの基本的なコマンド群をほどよいペースで学ぶ',
'fr_FR': 'Une introduction en douceur à la majorité des commandes git',
'es_AR': 'Una breve introducción a la mayoría de los comandos de git',
'es_MX': 'Una breve introducción a la mayoría de los comandos de git',
'es_ES': 'Una breve introducción a la mayoría de los comandos de git',
'pt_BR': 'Uma breve introdução à maioria dos comandos do git',
'gl' : 'Unha breve introducción á maioría dos comandos de git',
@ -86,7 +89,8 @@ var sequenceInfo = exports.sequenceInfo = {
'ru_RU': 'Хорошо подобранное введение в основные команды git',
'uk' : 'Гарно підібране введення в основні команди git',
'vi' : 'Từng bước làm quen với phần lớn lệnh điều khiển git',
'sl_SI': 'Prijeten uvod v git ukaze'
'sl_SI': 'Prijeten uvod v git ukaze',
'pl' : 'Krótkie wprowadzenie do większości poleceń GIT-a'
}
},
rampup: {
@ -96,6 +100,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : '次のレベルに進もう',
'fr_FR': 'Montée en puissance',
'es_AR': 'Acelerando',
'es_MX': 'Acelerando',
'es_ES': 'Acelerando',
'pt_BR': 'Acelerando',
'gl' : 'Alixeirando',
@ -105,7 +110,8 @@ var sequenceInfo = exports.sequenceInfo = {
'uk' : 'Їдемо далі',
'ko' : '다음 단계로',
'vi' : 'Tăng tốc',
'sl_SI': 'Prva Stopnička'
'sl_SI': 'Prva Stopnička',
'pl' : 'Rozkręcenie'
},
about: {
'en_US': 'The next serving of 100% git awesomes-ness. Hope you\'re hungry',
@ -113,6 +119,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : '更にgitの素晴らしさを堪能しよう',
'fr_FR': 'Le prochain excellent plat de pur git. J\'espère que vous êtes affamés',
'es_AR': 'La próxima porción de 100% maravillas git. Espero que estés hambriento',
'es_MX': 'La próxima ración de git. Espero que estés hambriento',
'es_ES': 'La próxima ración de git. Espero que estés hambriento',
'pt_BR': 'A próxima porção de maravilhas do git. Faminto?',
'gl' : 'A próxima porción das marabillas de git. Agardo que estés esfameado',
@ -122,7 +129,8 @@ var sequenceInfo = exports.sequenceInfo = {
'uk' : 'Наступна порція абсолютної git-дивини. Сподіваюсь, ви зголодніли',
'ko' : 'git은 아주 멋져요. 왜 멋진지 알려드립니다',
'vi' : 'Tận hưởng khẩu phần tuyệt hảo của git. Hi vọng bạn còn đói.',
'sl_SI': 'Naslednja porcija git izjemnosti. Upam, da si lačen'
'sl_SI': 'Naslednja porcija git izjemnosti. Upam, da si lačen',
'pl' : 'Następna porcja GIT-a jest niesamowita. Mam nadzieję, że jesteś głodny'
}
},
remote: {
@ -133,6 +141,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : 'Push及びPullコマンド -- Gitリモート',
'fr_FR': 'Push & Pull -- dépôts gits distants !',
'es_AR': 'Push & Pull -- Git Remotes!',
'es_MX': 'Push & Pull -- Repositorios remotos en Git (Git Remotes)!',
'es_ES': 'Push y Pull -- Git Remotes!',
'pt_BR': 'Push & Pull -- repositórios remotos no Git!',
'gl' : 'Push & Pull -- Repositorios remotos no Git!',
@ -142,7 +151,8 @@ var sequenceInfo = exports.sequenceInfo = {
'uk' : 'Push & Pull -- віддалені репозиторії в Git!',
'ko' : 'Push & Pull -- Git 원격 저장소!',
'vi' : 'Push & Pull -- Tác động git từ xa!',
'sl_SI': 'Push & Pull -- Oddaljeni Git'
'sl_SI': 'Push & Pull -- Oddaljeni Git',
'pl' : 'Push & Pull -- Zdalne repozytoria'
},
about: {
'en_US': 'Time to share your 1\'s and 0\'s kids; coding just got social',
@ -150,6 +160,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : '自分のコードをより広く公開しましょう',
'de_DE': 'Zeit eure 1en und 0en zu teilen; Coding mit sozialer Komponente',
'es_AR': 'Hora de compartir sus 1\'s y 0\'s, chicos; programar se volvió social!',
'es_MX': 'Hora de compartir sus 1\'s y 0\'s, chicos; programar se volvió social!',
'es_ES': 'Hora de compartir vuestros 1\'s y 0\'s, chicos; programar se volvió social!',
'pt_BR': 'Hora de compartilhar seus 1\'s e 0\'s, crianças; programar agora é social!',
'gl' : 'Hora de compartilos seus 1\' e 0\'s, rapaces; programar agora é social!',
@ -159,7 +170,8 @@ var sequenceInfo = exports.sequenceInfo = {
'uk' : 'Настав час поділитися своїми нулями та одиничками; соціальне програмування',
'ko' : '내 코드를 공개할 때가 되었습니다. 코드를 공개해봅시다!',
'vi' : 'Chia sẻ đứa con tinh thần \'0\' và \'1\' của bạn; mã đã đến với cộng đồng',
'sl_SI': 'Čas za deljenje tvojih 1 in 0; kodiranje je pravkar postalo socialno'
'sl_SI': 'Čas za deljenje tvojih 1 in 0; kodiranje je pravkar postalo socialno',
'pl' : 'Czas podzielić się swoimi dziećmi 1 i 0; kodowanie właśnie stało się społeczne'
}
},
remoteAdvanced: {
@ -170,6 +182,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : '"origin"とその先へ -- Gitリモート上級編',
'fr_FR': 'Vers l\'infini et au-delà -- dépôts distants version avancée',
'es_AR': 'Hasta el origin y más allá -- Git Remotes avanzado!',
'es_MX': 'Hasta el origin y más allá -- Git Remotes avanzado!',
'es_ES': 'Hasta el origen y más allá -- Git Remotes avanzado!',
'pt_BR': 'Até a origin e além -- repositórios remotos avançados!',
'gl' : 'Ata á orixe e máis aló -- repositorios remotos avanzados!',
@ -179,13 +192,15 @@ var sequenceInfo = exports.sequenceInfo = {
'uk' : 'Через origin – до зірок. Прогресивне використання Git Remotes',
'ko' : '"origin"그 너머로 -- 고급 Git 원격 저장소',
'vi' : 'Về với cội nguồn và vươn xa hơn -- nâng cao về các git remote',
'sl_SI': 'Do Origina In Naprej -- Napredni Oddaljeni Git'
'sl_SI': 'Do Origina In Naprej -- Napredni Oddaljeni Git',
'pl' : 'Do źródła i dalej -- zaawansowane zdalne repozytoria'
},
about: {
'en_US': 'And you thought being a benevolent dictator would be fun...',
'fr_FR': 'Et vous pensiez qu\'être un dictateur bienfaisant serait amusant...',
'ja' : '絶えず上級者の仕事は存在する。。。',
'es_AR': 'Y pensabas que ser un dictador benévolo sería divertido...',
'es_MX': 'Y pensabas que ser un dictador benévolo sería divertido...',
'es_ES': 'Y pensabas que ser un dictador benévolo sería divertido...',
'pt_BR': 'E você achava que ser um déspota esclarecido seria mais divertido...',
'gl' : 'E pensabas que ser un dictador benévolo sería divertido...',
@ -196,7 +211,8 @@ var sequenceInfo = exports.sequenceInfo = {
'uk' : 'А ти думав, що бути всесильним диктатором весело...',
'ko' : '자비로운 독재자가 되는게 재밌을 줄 알았겠지만...',
'vi' : 'Và bạn nghĩ làm một kẻ độc tài nhân từ thì sẽ vui ...',
'sl_SI': 'In ti si mislil, da je biti dobronamerni diktator zabavno ...'
'sl_SI': 'In ti si mislil, da je biti dobronamerni diktator zabavno ...',
'pl' : 'A myślałeś, że bycie życzliwym dyktatorem byłoby fajne...'
}
},
move: {
@ -205,6 +221,7 @@ var sequenceInfo = exports.sequenceInfo = {
'de_DE': 'Code umherschieben',
'fr_FR': 'Déplacer le travail',
'es_AR': 'Moviendo el trabajo por ahí',
'es_MX': 'Moviendo el trabajo por ahí',
'es_ES': 'Moviendo el trabajo por ahí',
'pt_BR': 'Movendo trabalho por aí',
'gl' : 'Movendo o traballo por ahí',
@ -215,13 +232,15 @@ var sequenceInfo = exports.sequenceInfo = {
'ru_RU': 'Перемещаем труды туда-сюда',
'uk' : 'Переміщуємо роботу туди-сюди',
'vi' : 'Điều chỉnh vị trí',
'sl_SI': 'Premikanje Dela Naokrog'
'sl_SI': 'Premikanje Dela Naokrog',
'pl' : 'Przenoszenie pracy'
},
about: {
'en_US': '"Git" comfortable with modifying the source tree :P',
'de_DE': 'Gewöhn dich daran, den Git-Baum zu verändern',
'fr_FR': 'Soyez à l\'aise pour modifier l\'arbre Git',
'es_AR': 'Ponete cómodo con modificar el directorio fuente',
'es_MX': 'Ponte cómodo al modificar el directorio fuente :P',
'es_ES': 'Ponte cómodo cuando modifiques el directorio fuente',
'pt_BR': 'Fique confortável em modificar a árvore de códigos',
'gl' : 'Ponte cómodo modificando a árbore de git',
@ -232,7 +251,8 @@ var sequenceInfo = exports.sequenceInfo = {
'ru_RU': 'Не стесняйтесь менять историю',
'uk' : 'Не соромимось змінювати історію',
'vi' : 'Chỉnh sửa cây lịch sử Git không hề khó',
'sl_SI': 'Spretno "Git" premikanje po drevesu :P'
'sl_SI': 'Spretno "Git" premikanje po drevesu :P',
'pl' : 'GIT dobrze radzi sobie z modyfikacją drzewa źródłowego :P'
}
},
mixed: {
@ -242,6 +262,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : '様々なtips',
'fr_FR': 'Un assortiment',
'es_AR': 'Bolsa de gatos',
'es_MX': 'De todo un poco',
'es_ES': 'Un poco de todo',
'pt_BR': 'Sortidos',
'gl' : 'Todo mesturado',
@ -251,7 +272,8 @@ var sequenceInfo = exports.sequenceInfo = {
'ru_RU': 'Сборная солянка',
'uk' : 'Всяке',
'vi' : 'Những trò mèo đáng đồng tiền bát gạo',
'sl_SI': 'Mešana Vreča'
'sl_SI': 'Mešana Vreča',
'pl' : 'Po trochu wszystkiego'
},
about: {
'en_US': 'A mixed bag of Git techniques, tricks, and tips',
@ -259,6 +281,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : 'gitを使う上での様々なtipsやテクニックなど',
'fr_FR': 'Un assortiment de techniques et astuces pour utiliser Git',
'es_AR': 'Un rejunte de técnicas, trucos y tips sobre Git',
'es_MX': 'Un recopilatorio de técnicas, trucos y tips sobre Git',
'es_ES': 'Un batiburrillo de técnicas, trucos y sugerencias sobre Git',
'pt_BR': 'Técnicas, truques e dicas sortidas sobre Git',
'gl' : 'Mestura de técnicas, trucos e consellos',
@ -268,7 +291,8 @@ var sequenceInfo = exports.sequenceInfo = {
'ru_RU': 'Ассорти из приёмов работы с Git, хитростей и советов',
'uk' : 'Різні прийоми роботи з Git, хитрощі та поради',
'vi' : 'Các kỹ thuật, bí quyết, và mẹo vặt hữu ích',
'sl_SI': 'Mešana vreča Git tehnik, trikov in nasvetov'
'sl_SI': 'Mešana vreča Git tehnik, trikov in nasvetov',
'pl' : 'Po trochu wszystkiego... wskazóweki i triki'
}
},
advanced: {
@ -278,6 +302,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : '上級トピック',
'fr_FR': 'Sujets avancés',
'es_AR': 'Temas avanzados',
'es_MX': 'Temas avanzados',
'es_ES': 'Temas avanzados',
'pt_BR': 'Temas avançados',
'gl' : 'Temas avanzados',
@ -287,7 +312,8 @@ var sequenceInfo = exports.sequenceInfo = {
'uk' : 'Досвідчений рівень',
'ko' : '고급 문제',
'vi' : 'Các chủ đề nâng cao',
'sl_SI': 'Napredne Teme'
'sl_SI': 'Napredne Teme',
'pl' : 'Zaawansowane tematy'
},
about: {
'en_US': 'For the truly brave!',
@ -295,6 +321,7 @@ var sequenceInfo = exports.sequenceInfo = {
'ja' : '勇気ある人のみ！',
'fr_FR': 'Pour les plus courageux !',
'es_AR': '¡Para los verdaderos valientes!',
'es_MX': '¡Para los verdaderos valientes!',
'es_ES': '¡Para los verdaderos valientes!',
'pt_BR': 'Para os verdadeiros valentes!',
'gl' : '¡Para os verdadeiros valerosos!',
@ -304,7 +331,8 @@ var sequenceInfo = exports.sequenceInfo = {
'uk' : 'Для хоробрих',
'ko' : '용기있는 도전자를 위해 준비한 문제입니다',
'vi' : 'Mạnh mẽ lên!',
'sl_SI': 'Za resnično pogumne!'
'sl_SI': 'Za resnično pogumne!',
'pl' : 'Dla naprawdę odważnych!'
}
}
};

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

@ -7,6 +7,7 @@ exports.level = {
"ja" : "Gitのブランチ",
"ko": "Git에서 브랜치 쓰기",
"es_AR": "Brancheando en Git",
"es_MX": "Creando ramas en Git",
"es_ES": "Creando ramas en Git",
"pt_BR": "Ramos no Git",
"gl" : "Ramas en Git",
@ -16,13 +17,15 @@ exports.level = {
"ru_RU": "Ветвление в Git",
"uk": "Розгалуження в Git",
"vi": "Rẽ nhánh với Git",
"sl_SI": "Branchanje v Gitu"
"sl_SI": "Branchanje v Gitu",
"pl" : "Rozgałęzienia w GIT-cie (branch)"
},
"hint": {
"en_US": "Make a new branch with \"git branch <branch-name>\" and check it out with \"git checkout <branch-name>\"",
"de_DE": 'Lege mit "git branch <Name>" einen neuen Branch an und checke ihn mit "git checkout <Name> aus',
"de_DE": "Lege mit \"git branch [Branch-Name]\" einen neuen Branch an und checke ihn mit \"git checkout [Branch-Name]\" aus",
"ja" : "ブランチの作成（\"git branch [ブランチ名]\"）と、チェックアウト（\"git checkout [ブランチ名]\"）",
"es_AR": "Hacé una nueva rama con \"git branch [nombre]\" y cambiá a ella con \"git checkout [nombre]\"",
"es_MX": "Crea una nueva rama con \"git branch [nombre]\" y sitúate en ella con \"git checkout [nombre]\"",
"es_ES": "Crea una nueva rama con \"git branch [nombre]\" y sitúate en ella con \"git checkout [nombre]\"",
"pt_BR": "Crie um novo ramo com \"git branch [nome]\" e mude para ele com \"git checkout [nome]\"",
"gl" : "Crea unha nova rama con \"git branch [nome]\" e cambiate a ela facendo \"git checkout [nome]\"",
@ -33,7 +36,8 @@ exports.level = {
"ru_RU": "Создай новую ветку при помощи \"git branch [name]\" и перейди на неё при помощи \"git checkout [name]\"",
"uk": "Створи нову гілку за допомогою \"git branch [ім’я]\" й перейди на неї за допомогою \"git checkout [ім’я]\"",
"vi": "Tạo một nhánh mới với lệnh \"git branch <ten-nhanh>\" và chuyển sang đó với lệnh \"git checkout <ten-nhanh>\"",
"sl_SI": "Naredi nov branch z \"git branch [ime-brancha]\" in ga checkoutaj z \"git checkout [ime-brancha]\""
"sl_SI": "Naredi nov branch z \"git branch [ime-brancha]\" in ga checkoutaj z \"git checkout [ime-brancha]\"",
"pl" : "Utwórz nowy branch za pomocą \"git branch <branch-name>\" i sprawdź ją za pomocą \"git checkout <branch-name>\""
},
"disabledMap": {
"git revert": true
@ -81,7 +85,7 @@ exports.level = {
"Let's try to put some work on this new branch. Hit the button below."
],
"afterMarkdowns": [
"Oh no! The `master` branch moved but the `newImage` branch didn't! That's because we weren't \"on\" the new branch, which is why the asterisk (*) was on `master`."
"Oh no! The `main` branch moved but the `newImage` branch didn't! That's because we weren't \"on\" the new branch, which is why the asterisk (*) was on `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -106,6 +110,17 @@ exports.level = {
"beforeCommand": "git branch newImage"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"*Note: In Git version 2.23, a new command called `git switch` was introduced to eventually replace `git checkout`, ",
"which is somewhat overloaded as a command (it does a bunch of separate things). The lessons here will still use ",
"`checkout` instead of `switch` because most people won't have access to `switch` yet, but support for the new command ",
"works in the app if you want to try it out! You can <a href=\"https://git-scm.com/docs/git-switch\" target=\"_blank\">learn more here</a>.* "
]
}
},
{
"type": "ModalAlert",
"options": {
@ -133,7 +148,7 @@ exports.level = {
"",
"Da das Anlegen von Branches keinen Plattenplatz und Speicher verbraucht, liegt es nahe die Arbeit in kleine logische Häppchen aufzuteilen, anstatt mit wenigen großen, monolithischen Branches zu hantieren.",
"",
"Wir werden sehen wie Commits und Branches zusammengehören sobald wir anfangen mit beiden zu arbeiten. Bis hierhin merk dir einfach, dass ein Branch im Prinzip bedeutet \"ich möchte die Arbeit, die in diesem Commit und seinen Vorgängern steckt, sichern\"."
"Wir werden sehen wie Commits und Branches zusammengehören, sobald wir anfangen mit beiden zu arbeiten. Bis hierhin merk dir einfach, dass ein Branch im Prinzip bedeutet \"ich möchte die Arbeit, die in diesem Commit und seinen Vorgängern steckt, sichern\"."
]
}
},
@ -159,7 +174,7 @@ exports.level = {
"Lass uns mal ein wenig auf dem neuen Branch arbeiten. Machen wir einen Commit:"
],
"afterMarkdowns": [
"Oi! Der Branch `master` hat sich verändert, aber der Branch `issue` nicht. Das liegt daran, dass wir nicht \"auf\" dem neuen Branch waren, weshalb das Sternchen `*` auch hinter `master` steht."
"Oi! Der Branch `main` hat sich verändert, aber der Branch `issue` nicht. Das liegt daran, dass wir nicht \"auf\" dem neuen Branch waren, weshalb das Sternchen `*` auch hinter `main` steht."
],
"command": "git commit",
"beforeCommand": "git branch issue"
@ -236,7 +251,7 @@ exports.level = {
"この新しいブランチに何か変更を加えてみましょう。次のボタンを押してください。"
],
"afterMarkdowns": [
"あらら、`newImage`ではなくて`master`ブランチが移動してしまいました。これは、私たちが`newImage`のブランチ上で作業していなかったためです。どのブランチで作業しているかは、アスタリスク(*)がついてるかどうかで分かります。"
"あらら、`newImage`ではなくて`main`ブランチが移動してしまいました。これは、私たちが`newImage`のブランチ上で作業していなかったためです。どのブランチで作業しているかは、アスタリスク(*)がついてるかどうかで分かります。"
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -314,7 +329,7 @@ exports.level = {
"Pongamos algo de trabajo en esta nueva rama. Apretá el botón de acá abajo."
],
"afterMarkdowns": [
"¡Uh, no! ¡La rama `master` avanzó, pero `newImage` no! Eso es porque no estábamos \"en\" la rama nueva, y por eso el asterisco (*) estaba en `master`."
"¡Uh, no! ¡La rama `main` avanzó, pero `newImage` no! Eso es porque no estábamos \"en\" la rama nueva, y por eso el asterisco (*) estaba en `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -350,6 +365,84 @@ exports.level = {
}
]
},
"es_MX": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Ramas en Git",
"",
"Las ramas (branches) en Git son increíblemente livianas. Son sólo referencias a un commit específico - nada más. Por esto es que tantos entusiastas de Git siguen el mantra:",
"",
"```",
"branchea temprano, y branchea seguido",
"```",
"",
"Como no hay consumo extra de almacenamiento ni memoria al hacer varias ramas, es más fácil dividir lógicamente tu trabajo que tener un par de ramas grandes.",
"",
"Cuando empecemos a mezclar ramas y commits, vamos a ver cómo se combinan estas dos herramientas. Por ahora, en cambio, simplemente recuerda que una rama esencialmente dice \"Quiero incluir el trabajo de este commit y todos su ancestros\"."
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Veamos cómo se ven las ramas en práctica.",
"",
"Acá vamos a crear una rama nueva llamada `newImage`."
],
"afterMarkdowns": [
"Ahí está, ¡eso es todo lo que hay que hacer para branchear! La rama `newImage` ahora referencia al commit `C1`."
],
"command": "git branch newImage",
"beforeCommand": ""
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Pongamos algo de trabajo en esta nueva rama. Aprieta el botón que se encuentra debajo."
],
"afterMarkdowns": [
"¡Uh, no! ¡La rama `main` avanzó, pero `newImage` no! Eso es porque no estábamos \"en\" la rama nueva, y por eso el asterisco (*) estaba en `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Digámosle a git que queremos hacer checkout a esa rama con",
"",
"```",
"git checkout [name]",
"```",
"",
"Esto nos situará en esa rama antes de hacer commit a nuestros cambios."
],
"afterMarkdowns": [
"¡Ahí estamos! Nuestros cambios se registraron en nuestra nueva rama."
],
"command": "git checkout newImage; git commit",
"beforeCommand": "git branch newImage"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"¡Ok! Ya estás listo para manejar ramas. Cuando se cierre esta ventana,",
"crea una nueva rama llamada `bugFix` y cámbiate a ella."
]
}
}
]
},
"es_ES": {
"childViews": [
{
@ -392,7 +485,7 @@ exports.level = {
"Pongamos algo de trabajo en esta nueva rama. Aprieta el botón de aquí abajo."
],
"afterMarkdowns": [
"¡Vaya! ¡La rama `master` avanzó, pero `newImage` no! Eso es porque no estábamos \"en\" la rama nueva, y por eso el asterisco (*) estaba en `master`."
"¡Vaya! ¡La rama `main` avanzó, pero `newImage` no! Eso es porque no estábamos \"en\" la rama nueva, y por eso el asterisco (*) estaba en `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -470,7 +563,7 @@ exports.level = {
"Vamos tentar colocar algum trabalho neste novo ramo. Clique no botão abaixo."
],
"afterMarkdowns": [
"Ah não! O ramo `master` se moveu mas o `newImage` não! Isso é porque o novo ramo não era o \"ativo\", e é por isso que o asterisco (*) estava no `master`."
"Ah não! O ramo `main` se moveu mas o `newImage` não! Isso é porque o novo ramo não era o \"ativo\", e é por isso que o asterisco (*) estava no `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -548,7 +641,7 @@ exports.level = {
"Imos intentar colocar algún traballo nesta nova rama. Pincha no botón de abaixo."
],
"afterMarkdowns": [
"¡Bueno home! A rama `master` moveuse pero a rama `newImage` non! Eso é porque a nova rama non era a \"actual\", e é por iso que o asterisco (*) ficaba na rama `master`."
"¡Bueno home! A rama `main` moveuse pero a rama `newImage` non! Eso é porque a nova rama non era a \"actual\", e é por iso que o asterisco (*) ficaba na rama `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -630,7 +723,7 @@ exports.level = {
"Travaillons mainenant dans cette branche. Appuyez sur le bouton ci-dessous."
],
"afterMarkdowns": [
"Oh non! La branche `master` a bougé mais pas la branche `newImage` ! C'est parce que nous n'étions pas \"sur\" la nouvelle branche, comme indiqué par l'astérisque (*) sur `master`."
"Oh non! La branche `main` a bougé mais pas la branche `newImage` ! C'est parce que nous n'étions pas \"sur\" la nouvelle branche, comme indiqué par l'astérisque (*) sur `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -680,7 +773,7 @@ exports.level = {
"早建分支！多用分支！",
"```",
"",
"这是因为即使创建再多分的支也不会造成储存或内存上的开销，并且按逻辑分解工作到不同的分支要比维护那些特别臃肿的分支简单多了。",
"这是因为即使创建再多的分支也不会造成储存或内存上的开销，并且按逻辑分解工作到不同的分支要比维护那些特别臃肿的分支简单多了。",
"",
"在将分支和提交记录结合起来后，我们会看到两者如何协作。现在只要记住使用分支其实就相当于在说：“我想基于这个提交以及它所有的父提交进行新的工作。”"
]
@ -709,7 +802,7 @@ exports.level = {
],
"command": "git commit",
"afterMarkdowns": [
"哎呀！为什么 `master` 分支前进了，但 `newImage` 分支还待在原地呢？！这是因为我们没有“在”这个新分支上，看到 `master` 分支上的那个星号（*）了吗？这表示当前所在的分支是 `master`。"
"哎呀！为什么 `main` 分支前进了，但 `newImage` 分支还待在原地呢？！这是因为我们没有“在”这个新分支上，看到 `main` 分支上的那个星号（*）了吗？这表示当前所在的分支是 `main`。"
],
"beforeCommand": "git branch newImage"
}
@ -789,7 +882,7 @@ exports.level = {
],
"command": "git commit",
"afterMarkdowns": [
"太奇怪了啦！ `master` branch 前進了，但 `newImage` branch 沒有前進！這是因為我們沒有「在」這個新的 branch 上，這也是為什麼星號（*）會在 `master` 上。"
"太奇怪了啦！ `main` branch 前進了，但 `newImage` branch 沒有前進！這是因為我們沒有「在」這個新的 branch 上，這也是為什麼星號（*）會在 `main` 上。"
],
"beforeCommand": "git branch newImage"
}
@ -866,7 +959,7 @@ exports.level = {
"이 새로운 브랜치에 약간의 작업을 더해봅시다. 아래 버튼을 눌러주세요"
],
"afterMarkdowns": [
"앗! `master` 브랜치가 움직이고, `newImage` 브랜치는 이동하지 않았네요! 그건 우리가 새 브랜치 위에 있지 않았었기 때문입니다. 별표(*)가 `master`에 있었던 것이죠."
"앗! `main` 브랜치가 움직이고, `newImage` 브랜치는 이동하지 않았네요! 그건 우리가 새 브랜치 위에 있지 않았었기 때문입니다. 별표(*)가 `main`에 있었던 것이죠."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -918,7 +1011,7 @@ exports.level = {
"",
"Так как создание множества веток никак не отражается на памяти или жестком диске, удобнее и проще разбивать свою работу на много маленьких веток, чем хранить все изменения в одной огромной ветке.",
"",
"Чуть позже мы попробуем использовать ветки и коммиты, и вы увидите, как две эти возможности сочетаются. Можно сказать, что созданная ветка хранит изменения текущих коммитов и всех его родителей."
"Чуть позже мы попробуем использовать ветки и коммиты, и вы увидите, как две эти возможности сочетаются. Можно сказать, что созданная ветка хранит изменения текущего коммита и всех его родителей."
]
}
},
@ -944,7 +1037,7 @@ exports.level = {
"Теперь попробуем сделать некоторые изменения в этой ветке. Для этого нажми кнопку ниже."
],
"afterMarkdowns": [
"О-оу! Ветка master сдвинулась, тогда как ветка newImage - нет! Всё из-за того, что мы не переключились на новую ветку, а остались в старой, о чём говорит звёздочка около ветки master."
"О-оу! Ветка main сдвинулась, тогда как ветка newImage - нет! Всё из-за того, что мы не переключились на новую ветку, а остались в старой, о чём говорит звёздочка около ветки main."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -1025,7 +1118,7 @@ exports.level = {
"Давайте спробуємо додати якусь інформацію до цієї нової гілки. Натисни кнопку внизу."
],
"afterMarkdowns": [
"От халепа! Гілка `master` просунулася вперед, але гілка `newImage` \u2014 ні! Це тому, що ми були не \"на новій гілці\". Через це зірочка (*) була поруч з `master`."
"От халепа! Гілка `main` просунулася вперед, але гілка `newImage` \u2014 ні! Це тому, що ми були не \"на новій гілці\". Через це зірочка (*) була поруч з `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -1103,7 +1196,7 @@ exports.level = {
"Nào cùng thử thêm nội dung vào nhánh mới này nào. Hãy bấm nút bên dưới"
],
"afterMarkdowns": [
"Ồ không! Nhánh `master` đã di chuyển nhưng nhánh `newImage` thì không! Đó là do ta không \"nằm trên\" nhánh mới, đó là tại sao dấu hoa thị (*) nằm trên nhánh `master`."
"Ồ không! Nhánh `main` đã di chuyển nhưng nhánh `newImage` thì không! Đó là do ta không \"nằm trên\" nhánh mới, đó là tại sao dấu hoa thị (*) nằm trên nhánh `main`."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -1185,7 +1278,7 @@ exports.level = {
"Poizkusimo dodati nekaj dela na ta nov branch. Pristisni gumb spodaj."
],
"afterMarkdowns": [
"O ne! `master` branch se je premaknil ampak `newImage` branch se pa ni! To je zato, ker nismo bili \"na\" novem branchu, kot smo lahko videli z označeno zvezdico (*) na `master` branchu."
"O ne! `main` branch se je premaknil ampak `newImage` branch se pa ni! To je zato, ker nismo bili \"na\" novem branchu, kot smo lahko videli z označeno zvezdico (*) na `main` branchu."
],
"command": "git commit",
"beforeCommand": "git branch newImage"
@ -1224,6 +1317,99 @@ exports.level = {
}
}
]
},
"pl": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## GIT Branch",
"",
"Branch w GIT są niezwykle lekkie. Są po prostu wskazówkami dla konkretnego commit-u (zatwierdzenia) i to wszytko. Dlatego tak wielu entuzjastów GIT-a przestrzega Mantry:",
"",
"```",
"twórz branch-e wcześnie i często",
"```",
"",
"Ponieważ tworzenie wielu branch-y nie wiąże się z dodatkowymi kosztami przestrzeni czy też pamięci, dlatego łatwiej jest logicznie podzielić swoją pracę, niż mieć duże, mocne branch-e.",
"",
"Kiedy zaczniemy mieszać branch-e i commit-y, zobaczymy, jak łączą się te dwie funkcje. Na&nbsp;razie jednak pamiętaj, że branch zasadniczo mówi: \"Chcę uwzględnić pracę tego zatwierdzenia oraz wszystkie commit-y nadrzędnych\"."
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Zobaczmy, jak wyglądają branch-e (gałęzie) w&nbsp;praktyce.",
"",
"Tutaj utworzymy nowy branch o nazwie `mojBranch`."
],
"afterMarkdowns": [
"To wszystko o rozgałęzieniu! Branch (gałąź) `mojBranch` odnosi się teraz do commit-u (zatwierdzenia) `C1`."
],
"command": "git branch mojBranch",
"beforeCommand": ""
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Spróbujmy trochę popracować nad tą nowym branch-em (gałęzią).\nKliknij przycisk poniżej."
],
"afterMarkdowns": [
"O nie! branch `main` uległ zmianie, a branch `mojBranch` nie! To dlatego, że nie byliśmy \"w\" nowym branch-u (gałęzi) i dlatego gwiazdka (*) była przy `main`"
],
"command": "git commit",
"beforeCommand": "git branch mojBranch"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Powiedzmy GIT-owi, z którym branch-em chcemy pracować",
"",
"```",
"git checkout <nazwa_branch>",
"```",
"",
"Spowoduje to przeniesienie nas do nowego branch-a przed wprowadzeniem zmian."
],
"afterMarkdowns": [
"Gotowe! Nasze zmiany zostały zarejestrowane w nowym branch-u."
],
"command": "git checkout mojBranch; git commit",
"beforeCommand": "git branch mojBranch"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"*Uwaga: w wersji 2.23 GIT-a zostało wprowadzono nowe polecenie o nazwie \n`git switch`, które zastępuje polecenie `git checkout`, ",
"a jest nieco przeciążony poleceniem (robi ono kilka oddzielnych rzeczy). Lekcje tutaj będą nadal używane",
"`checkout` zamiast `switch`, ponieważ większość ludzi nie ma jeszcze dostępu do nowego polecenia `switch`, ale w tej aplikacja obsługuje nowe polecenie, ",
"jeśli chcesz możesz ją wypróbować! Możesz dowiedzieć się więcej o poleceniu <a href=\"https://git-scm.com/docs/git-switch\" target=\"_blank\">tutaj</a>.* "
]
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok! Teraz jesteś gotowy do samodzielnego tworzenia gałęzi (branching-u).",
"Po zamknięciu tego okna, stwórz nowy branch o nazwie `bugFix` i przełącz się na ten branch.",
"",
"Przy okazji, oto skrót: jeśli chcesz stworzyć",
"nowy branch ORAZ przełączyć się na niego w tym samym czasie,",
"możesz po prostu wpisać `git checkout -b [nazwa_branch-u]`."
]
}
}
]
}
}
};

100
src/levels/intro/commits.js
View file

@ -3,6 +3,7 @@ exports.level = {
"en_US": "Introduction to Git Commits",
"de_DE": "Einführung in Git Commits",
"es_AR": "Introducción a los commits de Git",
"es_MX": "Introducción a los commits de Git",
"es_ES": "Introducción a los commits de Git",
"pt_BR": "Introdução aos commits no Git",
"gl" : "Introducción ós commits de Git",
@ -14,7 +15,8 @@ exports.level = {
'ru_RU': 'Знакомство с Git Commit ',
'uk': 'Знайомство з комітами в Git',
'vi': 'Giới thiệu về Git Commit',
'sl_SI': "Uvod v Git Commit"
'sl_SI': "Uvod v Git Commit",
'pl' : "Wprowadzenie do zatwierdzeń GIT-a (commit)"
},
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C3\",\"id\":\"master\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}",
"solutionCommand": "git commit;git commit",
@ -23,6 +25,7 @@ exports.level = {
"en_US": "Just type in 'git commit' twice to finish!",
"de_DE": "Gib einfach zweimal 'git commit' ein um den Level abzuschließen",
"es_AR": "¡Simplemente tipeá 'git commit' dos veces para terminar!",
"es_MX": "¡Simplemente escribe 'git commit' dos veces para terminar!",
"es_ES": "¡Simplemente escribe 'git commit' dos veces para terminar!",
"pt_BR": "Simplesmente digite 'git commit' duas vezes para concluir!",
"gl" : "Simplemente escribe 'git commit' dúas veces para terminar.",
@ -34,7 +37,8 @@ exports.level = {
"ru_RU": "Попробуй дважды выполнить команду 'git commit' ;)",
"uk": "Спробуй двічі виконати команду 'git commit' ;)",
'vi': "Đơn giản là cứ gõ 'git commit' 2 lần",
'sl_SI': "Preprosto dvakrat vpiši 'git commit' in zaključi!"
'sl_SI': "Preprosto dvakrat vpiši 'git commit' in zaključi!",
"pl" : "Aby zakończyć, wystarczy dwukrotnie wpisać 'git commit'!"
},
"disabledMap": {
"git revert": true
@ -47,7 +51,7 @@ exports.level = {
"options": {
"markdowns": [
"## Git Commits",
"A commit in a git repository records a snapshot of all the files in your directory. It's like a giant copy and paste, but even better!",
"A commit in a git repository records a snapshot of all the (tracked) files in your directory. It's like a giant copy and paste, but even better!",
"",
"Git wants to keep commits as lightweight as possible though, so it doesn't just blindly copy the entire directory every time you commit. It can (when possible) compress a commit as a set of changes, or a \"delta\", from one version of the repository to the next.",
"",
@ -89,11 +93,11 @@ exports.level = {
"options": {
"markdowns": [
"## Git Commits",
"Ein Commit in ein Git-Repository speichert eine Abbildung aller Dateien in deinem Projektverzeichnis. Es ist wie ein riesiges Kopieren und Einfügen, nur besser.",
"Ein Commit in einem Git-Repository speichert eine Abbildung aller Dateien in deinem Projektverzeichnis. Es ist wie ein riesiges Kopieren und Einfügen, nur besser.",
"",
"Allerdings will Git die Commits so schlank wie möglich halten, also kopiert es nicht einfach stur das ganze Verzeichnis jedes Mal wenn du committest. Es kann (wenn möglich) Commits als Menge von Änderungen zusammenpacken, von einer Version des Repositorys zur nächsten.",
"",
"Außerdem führt Git ein Protokoll darüber welche Commits wann gemacht wurden, und welcher auf welchen folgt. Deshalb werden die Commits hier mit ihrem Vorgänger über sich gezeigt -- wir verwenden Pfeile zur Darstellung der Beziehung. Dieses Protokoll zu haben ist eine tolle Sache für jeden, der an einem Projekt arbeitet.",
"Außerdem führt Git ein Protokoll darüber, welche Commits wann gemacht wurden, und welcher auf welchen folgt. Deshalb werden die Commits hier mit ihrem Vorgänger über sich gezeigt -- wir verwenden Pfeile zur Darstellung der Beziehung. Dieses Protokoll zu haben ist eine tolle Sache für jeden, der an einem Projekt arbeitet.",
"",
"Das war jetzt eine Menge Neues, aber vorerst kannst du dir Commits einfach als Abbildungen des Projekts vorstellen. Commits sind sehr ressourcenschonend, und zwischen ihnen wechseln geht superschnell!"
]
@ -118,7 +122,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Probier das committen gleich mal aus! Mach zwei Commits um den Level abzuschließen."
"Probier das Committen gleich mal aus! Mach zwei Commits um den Level abzuschließen."
]
}
}
@ -212,6 +216,48 @@ exports.level = {
}
]
},
"es_MX": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Commits de Git",
"Un commit en un repositorio git registra un snapshot de todos los archivos en tu directorio. Es como un _gran_ copy&paste, ¡pero incluso mejor!",
"",
"Git pretende mantener los commits tan livianos como sea posible, por lo que no copia ciegamente el directorio completo cada vez que haces commit. Puede (cuando sea posible) comprimir un commit como un conjunto de cambios (o un _\"delta\"_) entre una versión de tu repositorio y la siguiente.",
"",
"Git mantiene, también, un historial de qué commits se hicieron cuándo. Es por eso que la mayoría de los commits tienen commits ancestros arriba suyo -- designamos esto con flechas en nuestra visualización. ¡Mantener el historial es genial para todos los que trabajan en el proyecto!",
"",
"Hay un montón en lo que ahondar, pero por ahora puedes pensar en los commits como snapshots de tu proyecto. Los commits son muy livianos, y ¡cambiar de uno a otro es terriblemente rápido!"
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Veamos cómo se ve esto en la práctica. A la derecha tenemos una visualización de un (pequeño) repositorio git. Hay dos commits ahora: el commit inicial, `C0`, y un commit que lo sigue, `C1`, que podría tener algunos cambios interesantes.",
"",
"Dale al botón de abajo para hacer un nuevo commit."
],
"afterMarkdowns": [
"¡Ahí va! Increíble. Acabamos de hacer cambios al repositorio y los guardamos como un commit. El commit que acabamos de crear tiene un padre, `C1`, que referencia al commit en que se basó este."
],
"command": "git commit",
"beforeCommand": ""
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"¡Vamos, inténtalo ahora! Cuando se cierre esta ventana, haz dos commits para completar el nivel."
]
}
}
]
},
"es_ES": {
"childViews": [
{
@ -679,6 +725,48 @@ exports.level = {
}
}
]
},
"pl": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Zatwierdzenia GIT-a (commit)",
"`commit` w repozytorium GIT-a rejestruje migawkę wszystkich (śledzonych) plików w twoim katalogu. To jak gigantyczne kopiowanie i wklejanie, ale jeszcze lepsze!",
"",
"GIT stara się, aby commit-y 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ć zatwierdzenie 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!",
"",
"Jest mnóstwo rzeczy do zagłębienia, ale na razie możesz myśleć o commit-ach jako migawkach projektu. Zatwierdzenia są bardzo lekkie, a przełączanie się między nimi jest niesamowicie szybkie!"
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Zobaczmy, jak to wygląda w praktyce. Po prawej stronie mamy wizualizację (małego) repozytorium GIT-a. Istnieją dwa zatwierdzenia:\n początkowy commit `C0`, a następnie po nim commit `C1`, które mogą mieć kilka interesujących zmian.",
"",
"Kliknij poniższy przycisk, aby dokonać nowy commit."
],
"afterMarkdowns": [
"Gotowe! Niesamowite. Właśnie wprowadziliśmy zmiany w repozytorium i zapisaliśmy je jako zatwierdzenie (commit). Utworzony przez nas commit ma rodzica `C1`, który odnosi się do commit-a, na który został oparty."
],
"command": "git commit",
"beforeCommand": ""
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Śmiało i wypróbuj to sam! Po zamknięciu tego okna wykonaj dwa zatwierdzenia (tj. commit-y), aby ukończyć poziom."
]
}
}
]
}
}
};

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

@ -1,10 +1,11 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C4\",\"id\":\"master\"},\"bugFix\":{\"target\":\"C2\",\"id\":\"bugFix\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\",\"C2\"],\"id\":\"C4\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}",
"solutionCommand": "git checkout -b bugFix;git commit;git checkout master;git commit;git merge bugFix",
"solutionCommand": "git checkout -b bugFix;git commit;git checkout main;git commit;git merge bugFix",
"name": {
"en_US": "Merging in Git",
"de_DE": "Mergen in git",
"de_DE": "Mergen in Git",
"es_AR": "Mergeando en Git",
"es_MX": "Haciendo merge en Git",
"es_ES": "Haciendo merge en Git",
"pt_BR": "Merge no Git",
"gl" : "Merge en Git",
@ -16,24 +17,27 @@ exports.level = {
"ru_RU": "Слияния веток в Git",
"uk": "Злиття гілок в Git",
"vi": "Gộp nhánh trong Git",
"sl_SI": "Merganje v Gitu"
"sl_SI": "Merganje v Gitu",
"pl" : "Łączenie/Scalanie w GIT (merge)"
},
"hint": {
"en_US": "Remember to commit in the order specified (bugFix before master)",
"de_DE": "Denk dran in der angegebenen Reihenfolge zu committen (erst bugFix, dann master)",
"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"　　　: "指示された順番でコミットすること（masterの前にbugFixで）",
"es_AR": "Acordate de commitear en el orden especificado (bugFix antes de master)",
"es_ES": "Acuérdate de hacer commit en el orden especificado (bugFix antes de master)",
"pt_BR": "Lembre-se de commitar na ordem especificada (bugFix antes de master)",
"gl" : "Lembrate de facer commit na orde específica (bugFix antes de master)",
"fr_FR": "Pensez à faire des commits dans l'ordre indiqué (bugFix avant master)",
"zh_CN": "要按目标窗口中指定的顺序进行提交（bugFix 先于 master）",
"zh_TW": "記住按指定的順序 commit（bugFix 比 master 優先）",
"ko": "말씀드린 순서대로 커밋해주세요 (bugFix에 먼저 커밋하고 master에 커밋)",
"ru_RU": "Не забудь делать коммиты в правильном порядке (сначала bugFix, потом master)",
"uk": "Не забудь робити коміти в правильному порядку (спочатку bugFix, а вже потім master)",
"vi": "Nhớ là commit theo đúng thứ tự(bugFix trước master)",
"sl_SI": 'Zapomni si, da je potrebno commitati v pravilnem vrstnem redu (bugfix pred master)'
"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)",
"pt_BR": "Lembre-se de commitar na ordem especificada (bugFix antes de main)",
"gl" : "Lembrate de facer commit na orde específica (bugFix antes de main)",
"fr_FR": "Pensez à faire des commits dans l'ordre indiqué (bugFix avant main)",
"zh_CN": "要按目标窗口中指定的顺序进行提交（bugFix 先于 main）",
"zh_TW": "記住按指定的順序 commit（bugFix 比 main 優先）",
"ko": "말씀드린 순서대로 커밋해주세요 (bugFix에 먼저 커밋하고 main에 커밋)",
"ru_RU": "Не забудь делать коммиты в правильном порядке (сначала bugFix, потом main)",
"uk": "Не забудь робити коміти в правильному порядку (спочатку bugFix, а вже потім main)",
"vi": "Nhớ là commit theo đúng thứ tự(bugFix trước main)",
"sl_SI": 'Zapomni si, da je potrebno commitati v pravilnem vrstnem redu (bugfix pred main)',
"pl" : "Pamiętaj, aby commit-ować w określonej kolejności (bugFix przed main)"
},
"disabledMap": {
"git revert": true
@ -61,32 +65,32 @@ exports.level = {
"beforeMarkdowns": [
"Here we have two branches; each has one commit that's unique. This means that neither branch includes the entire set of \"work\" in the repository that we have done. Let's fix that with merge.",
"",
"We will `merge` the branch `bugFix` into `master`."
"We will `merge` the branch `bugFix` into `main`."
],
"afterMarkdowns": [
"Woah! See that? First of all, `master` now points to a commit that has two parents. If you follow the arrows up the commit tree from `master`, you will hit every commit along the way to the root. This means that `master` contains all the work in the repository now.",
"Woah! See that? First of all, `main` now points to a commit that has two parents. If you follow the arrows up the commit tree from `main`, you will hit every commit along the way to the root. This means that `main` contains all the work in the repository now.",
"",
"Also, see how the colors of the commits changed? To help with learning, I have included some color coordination. Each branch has a unique color. Each commit turns a color that is the blended combination of all the branches that contain that commit.",
"",
"So here we see that the `master` branch color is blended into all the commits, but the `bugFix` color is not. Let's fix that..."
"So here we see that the `main` branch color is blended into all the commits, but the `bugFix` color is not. Let's fix that..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Let's merge `master` into `bugFix`:"
"Let's merge `main` into `bugFix`:"
],
"afterMarkdowns": [
"Since `bugFix` was an ancestor of `master`, git didn't have to do any work; it simply just moved `bugFix` to the same commit `master` was attached to.",
"Since `bugFix` was an ancestor of `main`, git didn't have to do any work; it simply just moved `bugFix` to the same commit `main` was attached to.",
"",
"Now all the commits are the same color, which means each branch contains all the work in the repository! Woohoo!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -98,9 +102,9 @@ exports.level = {
"* Make a new branch called `bugFix`",
"* Checkout the `bugFix` branch with `git checkout bugFix`",
"* Commit once",
"* Go back to `master` with `git checkout`",
"* Go back to `main` with `git checkout`",
"* Commit another time",
"* Merge the branch `bugFix` into `master` with `git merge`",
"* Merge the branch `bugFix` into `main` with `git merge`",
"",
"*Remember, you can always re-display this dialog with \"objective\"!*"
]
@ -130,32 +134,32 @@ exports.level = {
"beforeMarkdowns": [
"Hier haben wir zwei Branches; jeder besteht jeweils aus einem eigenen Commit. Das bedeutet, dass keiner der beiden Branches alle Inhalte des gesamten Repositorys kennt. Das werden wir mit einem Merge ändern.",
"",
"Wir werden den Branch `bugFix` in `master` integrieren."
"Wir werden den Branch `bugFix` in `main` integrieren."
],
"afterMarkdowns": [
"Wow! Hast du das gesehen? Zunächst mal zeigt `master` jetzt auf einen Commit mit zwei Vorgängern. Wenn du den beiden Pfeilen immer weiter folgst, kommst du an jedem Commit im Repository vorbei. Das heißt `master` enthält jetzt alles, was es im Repository gibt.",
"Wow! Hast du das gesehen? Zunächst mal zeigt `main` jetzt auf einen Commit mit zwei Vorgängern. Wenn du den beiden Pfeilen immer weiter folgst, kommst du an jedem Commit im Repository vorbei. Das heißt `main` enthält jetzt alles, was es im Repository gibt.",
"",
"Siehst du außerdem wie sich die Farben der Commits verändert haben? Um die Vorgänge zu verdeutlichen hab ich etwas Farbe ins Spiel gebracht. Jeder Branch hat seine eindeutige Farbe. Jeder Merge Commit bekommt als Farbe eine Mischung aus den Farben seiner Vorgänger.",
"",
"Wir sehen also, dass die Farbe des Branch `master` in alle Commits gemischt wurde, die von `bugFix` aber nicht. Ändern wir das ..."
"Wir sehen also, dass die Farbe des Branch `main` in alle Commits gemischt wurde, die von `bugFix` aber nicht. Ändern wir das ..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Mergen wir `master` in `bugFix`:"
"Mergen wir `main` in `bugFix`:"
],
"afterMarkdowns": [
"Da `bugFix` ein Vorgänger von `master` war, musste git hier kaum etwas tun; es verschiebt `bugFix` einfach auf den Commit, auf den auch `master` zeigt.",
"Da `bugFix` ein Vorgänger von `main` war, musste git hier kaum etwas tun; es verschiebt `bugFix` einfach auf den Commit, auf den auch `main` zeigt.",
"",
"Jetzt haben alle Commits dieselbe Farbe, das heißt jeder Branch enthält die Informationen des gesamten Repositorys! Juhu!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -167,9 +171,9 @@ exports.level = {
"* Lege einen neuen Branch `bugFix` an",
"* Checke `bugFix` aus mittels `git checkout bugFix`",
"* Mach einen Commit",
"* Geh mit `git checkout` zum `master` zurück",
"* Geh mit `git checkout` zum `main` zurück",
"* Mach noch einen Commit",
"* Merge den Branch `bugFix` in `master` mit `git merge`",
"* Merge den Branch `bugFix` in `main` mit `git merge`",
"",
"*Denk dran, du kannst diese Meldung mit dem Befehl `objective` so oft anzeigen, wie du willst!*"
]
@ -199,32 +203,32 @@ exports.level = {
"beforeMarkdowns": [
"それぞれ別のコミットを指している2つのブランチがあります。変更が別々のブランチに分散していて統合されていないケースです。これをマージで1つにまとめてみましょう。",
"",
"`bugFix`ブランチを`master`ブランチにマージしてみます。"
"`bugFix`ブランチを`main`ブランチにマージしてみます。"
],
"afterMarkdowns": [
"わあ、見ましたか？まず初めに、`master`ブランチが2つのコミットを親に持つ新しいコミットを指してますね。`master`から親をたどっていくと、最も古いコミットにたどり着くまでに全てのコミットを含んでいる様が確認できます。これで、全ての変更を含む`master`が完成しました。",
"わあ、見ましたか？まず初めに、`main`ブランチが2つのコミットを親に持つ新しいコミットを指してますね。`main`から親をたどっていくと、最も古いコミットにたどり着くまでに全てのコミットを含んでいる様が確認できます。これで、全ての変更を含む`main`が完成しました。",
"",
"色がどう変わったかにも注目して下さい。学習を助けるために、ブランチ毎に色をつけています。それぞれのブランチは自分の色を持っていて、どのブランチから派生して出てくるか次第でコミットごとの色が決まります。",
"",
"今回のコミットには`master`ブランチの色が使われました。しかし`bugFix`ブランチの色がまだ変わってないようなので、これを変えてみましょう。"
"今回のコミットには`main`ブランチの色が使われました。しかし`bugFix`ブランチの色がまだ変わってないようなので、これを変えてみましょう。"
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"`master`ブランチを`bugFix`ブランチにマージしてみます。"
"`main`ブランチを`bugFix`ブランチにマージしてみます。"
],
"afterMarkdowns": [
"`bugFix`ブランチは`master`ブランチの派生元だったので、gitは実際大したことはしていません。`bugFix`ブランチを指していたポインタを`master`が指していたコミットへと移動させただけです。",
"`bugFix`ブランチは`main`ブランチの派生元だったので、gitは実際大したことはしていません。`bugFix`ブランチを指していたポインタを`main`が指していたコミットへと移動させただけです。",
"",
"これで全てのコミットが同じ色になりました。つまり、リポジトリの中の全ての変更をそれぞれのブランチが持ったことになります。やったね！"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -236,9 +240,9 @@ exports.level = {
"* `bugFix`という名前で新しいブランチを切る",
"* `git checkout bugFix`コマンドで`bugFix`ブランチに切り替える",
"* 一回だけコミット",
"* `git checkout`で`master`へ戻る",
"* `git checkout`で`main`へ戻る",
"* もう1回コミットする",
"* `git merge`コマンドを使って、`bugFix`ブランチを`master`ブランチへとマージする",
"* `git merge`コマンドを使って、`bugFix`ブランチを`main`ブランチへとマージする",
"",
"*注：\"objective\"コマンドでこのヘルプにいつでも戻ってこれます*"
]
@ -268,32 +272,32 @@ exports.level = {
"beforeMarkdowns": [
"Acá tenemos dos ramas, y cada una tiene un commit que le es único. Esto significa que ninguna de las ramas incluye \"todo el trabajo\" que hay en nuestro repositorio. Hagamos un merge para solucionar eso.",
"",
"Vamos a `merge`ar la rama `bugFix` a `master`."
"Vamos a `merge`ar la rama `bugFix` a `main`."
],
"afterMarkdowns": [
"¡Wooow! ¿Viste eso? Primero que nada, `master` ahora apunta a un commit que tiene dos padres. Si seguís las flechas por el árbol de commits empezando desde `master` vas a cruzarte con cada commit del repositorio hasta llegar a la raíz. Esto significa que `master` ahora contiene todo el trabajo que hay en el repositorio.",
"¡Wooow! ¿Viste eso? Primero que nada, `main` ahora apunta a un commit que tiene dos padres. Si seguís las flechas por el árbol de commits empezando desde `main` vas a cruzarte con cada commit del repositorio hasta llegar a la raíz. Esto significa que `main` ahora contiene todo el trabajo que hay en el repositorio.",
"",
"Además, ¿viste cómo cambiaron los colores de los commits? Para ayudar al aprendizaje, incluí algunas convenciones de colores. Cada rama tiene un color propio. Cada commmit se vuelve del color resultante de mezclar los colores de todas las ramas que lo contienen.",
"",
"Así que acá vemos que el color de la rama `master` participa en la mezcla de todos los commits, pero que el de `bugFix` no. Arreglemos eso..."
"Así que acá vemos que el color de la rama `main` participa en la mezcla de todos los commits, pero que el de `bugFix` no. Arreglemos eso..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Mergeemos `master` a `bugFix`:"
"Mergeemos `main` a `bugFix`:"
],
"afterMarkdowns": [
"Como `bugFix` era un ancestro de `master`, git no tuvo que hacer ningún trabajo; simplemente movió `bugFix` al mismo commit al que estaba anexado `master`.",
"Como `bugFix` era un ancestro de `main`, git no tuvo que hacer ningún trabajo; simplemente movió `bugFix` al mismo commit al que estaba anexado `main`.",
"",
"Ahora todos los commits son del mismo color, lo que significa que cada rama contiene todo el trabajo que hay en el repositorio. ¡Wiii!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -305,9 +309,9 @@ exports.level = {
"* Creá una nueva rama, llamada `bugFix`",
"* Checkouteá la rama `bugFix` usando `git checkout bugFix`",
"* Hacé un commit",
"* Volvé a `master` con `git checkout`",
"* Volvé a `main` con `git checkout`",
"* Hacé otro commit",
"* Mergeá la rama `bugFix` a `master` usando `git merge`",
"* Mergeá la rama `bugFix` a `main` usando `git merge`",
"",
"*Acordate: siempre podés volver a ver este mensaje tipeando \"objective\"!*"
]
@ -315,6 +319,75 @@ exports.level = {
}
]
},
"es_MX": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Mergeando ramas",
"",
"¡Genial! Ya sabemos cómo hacer commit y cómo crear ramas. Ahora tenemos que aprender algún modo de unificar el trabajo de dos ramas diferentes. Esto nos va a permitir abrir una nueva rama de desarrollo, implementar alguna nueva funcionalidad, y después unirla de nuevo con el trabajo principal.",
"",
"El primer método para combinarlas que vamos a explorar es `git merge`. Mergear en Git crea un commit especial que tiene dos padres diferentes. Un commit con dos padres esencialmente significa \"Quiero incluir todo el trabajo de este padre de acá y este otro padre de acá, *y* del conjunto de todos sus ancestros\"",
"",
"Es más simple visualizarlo, veámoslo a continuación"
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Acá tenemos dos ramas, y cada una tiene un commit que le es único. Esto significa que ninguna de las ramas incluye \"todo el trabajo\" que hay en nuestro repositorio. Hagamos un merge para solucionar eso.",
"",
"Vamos a `merge`ar la rama `bugFix` a `main`."
],
"afterMarkdowns": [
"¡Wooow! ¿Viste eso? Primero que nada, `main` ahora apunta a un commit que tiene dos padres. Si sigues las flechas por el árbol de commits empezando desde `main` vas a cruzarte con cada commit del repositorio hasta llegar a la raíz. Esto significa que `main` ahora contiene todo el trabajo que hay en el repositorio.",
"",
"Además, ¿Viste cómo cambiaron los colores de los commits? Para ayudar al aprendizaje, incluí algunas convenciones de colores. Cada rama tiene un color propio. Cada commmit se vuelve del color resultante de mezclar los colores de todas las ramas que lo contienen.",
"",
"Así que acá vemos que el color de la rama `main` participa en la mezcla de todos los commits, pero que el de `bugFix` no. Arreglemos eso..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Mergeemos `main` a `bugFix`:"
],
"afterMarkdowns": [
"Como `bugFix` era un ancestro de `main`, git no tuvo que hacer ningún trabajo; simplemente movió `bugFix` al mismo commit al que estaba anexado `main`.",
"",
"Ahora todos los commits son del mismo color, lo que significa que cada rama contiene todo el trabajo que hay en el repositorio. ¡Súper!"
],
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nivel, sigue estos pasos:",
"",
"* Crea una nueva rama, llamada `bugFix`",
"* Cambia a la rama `bugFix` usando `git checkout bugFix`",
"* Haz un commit",
"* Vuelve a `main` con `git checkout`",
"* Haz otro commit",
"* Haz un merge de la rama `bugFix` a `main` usando `git merge`",
"",
"*Recuerda: siempre puedes volver a ver este mensaje usando el comando \"objective\"!*"
]
}
}
]
},
"es_ES": {
"childViews": [
{
@ -337,32 +410,32 @@ exports.level = {
"beforeMarkdowns": [
"Aquí tenemos dos ramas, y cada una tiene un commit que le es único. Esto significa que ninguna de las ramas incluye \"todo el trabajo\" que hay en nuestro repositorio. Hagamos un merge para solucionar eso.",
"",
"Vamos a `merge`ar la rama `bugFix` a `master`."
"Vamos a `merge`ar la rama `bugFix` a `main`."
],
"afterMarkdowns": [
"¡Caramba! ¿Viste eso? Antes de nada, `master` ahora apunta a un commit que tiene dos padres. Si sigues las flechas por el árbol de commits empezando desde `master` vas a cruzarte con cada commit del repositorio hasta llegar a la raíz. Esto significa que `master` ahora contiene todo el trabajo que hay en el repositorio.",
"¡Caramba! ¿Viste eso? Antes de nada, `main` ahora apunta a un commit que tiene dos padres. Si sigues las flechas por el árbol de commits empezando desde `main` vas a cruzarte con cada commit del repositorio hasta llegar a la raíz. Esto significa que `main` ahora contiene todo el trabajo que hay en el repositorio.",
"",
"Además, ¿viste cómo cambiaron los colores de los commits? Para ayudar al aprendizaje, he incluido algunas convenciones de colores. Cada rama tiene un color propio. Cada commmit se vuelve del color resultante de mezclar los colores de todas las ramas que lo contienen.",
"",
"Así que aquí vemos que el color de la rama `master` participa en la mezcla de todos los commits, pero que el de `bugFix` no. Arreglemos eso..."
"Así que aquí vemos que el color de la rama `main` participa en la mezcla de todos los commits, pero que el de `bugFix` no. Arreglemos eso..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Hagamos merge de `master` a `bugFix`:"
"Hagamos merge de `main` a `bugFix`:"
],
"afterMarkdowns": [
"Como `bugFix` era un ancestro de `master`, git no tuvo que hacer ningún trabajo; simplemente movió `bugFix` al mismo commit al que estaba anexado `master`.",
"Como `bugFix` era un ancestro de `main`, git no tuvo que hacer ningún trabajo; simplemente movió `bugFix` al mismo commit al que estaba anexado `main`.",
"",
"Ahora todos los commits son del mismo color, lo que significa que cada rama contiene todo el trabajo que hay en el repositorio. ¡Genial!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -374,9 +447,9 @@ exports.level = {
"* Crea una nueva rama, llamada `bugFix`",
"* Haz checkout de la rama `bugFix` usando `git checkout bugFix`",
"* Crea un commit",
"* Vuelve a `master` con `git checkout`",
"* Vuelve a `main` con `git checkout`",
"* Crea otro commit",
"* Haz merge de la rama `bugFix` a `master` usando `git merge`",
"* Haz merge de la rama `bugFix` a `main` usando `git merge`",
"",
"*Recuerda: siempre puedes volver a ver este mensaje escribiendo \"objective\"!*"
]
@ -406,32 +479,32 @@ exports.level = {
"beforeMarkdowns": [
"Aqui nós temos dois ramos; cada um tem um commit que é único. Isso significa que nenhum ramo inclui o conjunto do \"trabalho\" que foi realizado no repositório. Vamos consertar isso com um merge.",
"",
"Vamos juntar o ramo `bugFix` no `master`."
"Vamos juntar o ramo `bugFix` no `main`."
],
"afterMarkdowns": [
"Uau! Viu isso? Antes de tudo, o `master` agora aponta para um commit que possui dois pais. Se você seguir as setas subindo a árvore de commits a partir do `master`, você será capaz de encontrar, ao longo do caminho até a raiz, qualquer um dos commits. Isso significa que o `master` contém todo o trabalho realizado no repositório até o momento.",
"Uau! Viu isso? Antes de tudo, o `main` agora aponta para um commit que possui dois pais. Se você seguir as setas subindo a árvore de commits a partir do `main`, você será capaz de encontrar, ao longo do caminho até a raiz, qualquer um dos commits. Isso significa que o `main` contém todo o trabalho realizado no repositório até o momento.",
"",
"Além disso, viu como as cores dos commits mudaram? Para ajudá-lo a aprender, eu incluí uma legenda. Cada ramo tem uma cor única. Cada commit tem a cor resultante da mistura das cores de todos os ramos que o contém.",
"",
"Aqui vemos que a cor do ramo `master` está misturada em todos os commits, mas a cor do `bugFix` não está. Vamos corrigir isso..."
"Aqui vemos que a cor do ramo `main` está misturada em todos os commits, mas a cor do `bugFix` não está. Vamos corrigir isso..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Vamos juntar o `master` no `bugFix`:"
"Vamos juntar o `main` no `bugFix`:"
],
"afterMarkdowns": [
"Como o `bugFix` é um ancestral do `master`, o git não teve trabalho nenhum; ele só precisou mover o `bugFix` para o mesmo commit do `master`.",
"Como o `bugFix` é um ancestral do `main`, o git não teve trabalho nenhum; ele só precisou mover o `bugFix` para o mesmo commit do `main`.",
"",
"Agora todos os commits possuem a mesma cor, o que significa que ambos os ramos contém todo o trabalho realizado no repositório! Eba!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -443,9 +516,9 @@ exports.level = {
"* Crie um novo ramo chamado `bugFix`",
"* Faça checkout no ramo `bugFix` com `git checkout bugFix`",
"* Faça um commit",
"* Volte ao `master` com `git checkout`",
"* Volte ao `main` com `git checkout`",
"* Faça um novo commit",
"* Junte o ramo `bugFix` no `master` com `git merge`",
"* Junte o ramo `bugFix` no `main` com `git merge`",
"",
"*Lembre-se, você pode sempre mostrar esta mensagem novamente com o comando \"objective\"!*"
]
@ -475,32 +548,32 @@ exports.level = {
"beforeMarkdowns": [
"Aquí nos temos dúas ramas; cada unha ten un commit que é único. Isto significa que ningunha rama inclúe o conxunto de \"traballo\" feito no noso repositorio. Imos arranxar esto cun merge.",
"",
"Imos xuntar a rama `bugFix` na `master`."
"Imos xuntar a rama `bugFix` na `main`."
],
"afterMarkdowns": [
"¡Uah! ¿Viches? Antes de todo, `master` agora apunta a un commit que ten dous pais. Se ti sigues as frechas subindo a árbore de commits a partir de `master`, serás capaz de ver tódolos commits ata a raíz, calquera de eles. Isto significa que a rama `master` contén todo o traballo realizado no repositorio ata ese momento.",
"¡Uah! ¿Viches? Antes de todo, `main` agora apunta a un commit que ten dous pais. Se ti sigues as frechas subindo a árbore de commits a partir de `main`, serás capaz de ver tódolos commits ata a raíz, calquera de eles. Isto significa que a rama `main` contén todo o traballo realizado no repositorio ata ese momento.",
"",
"Ademáis, ¿viches como cambiaron as cores dos commits? Para axudarte a aprender, hai unha lenda. Cada rama ten unha única cor. Cada commit ten a cor resultante de mesturar as cores de tódalas ramas que contén.",
"",
"Aquí vemos que a rama `master` está mesturada en todos os commits, pero a cor da rama `bugFix` non o está. Imos arranxar eso..."
"Aquí vemos que a rama `main` está mesturada en todos os commits, pero a cor da rama `bugFix` non o está. Imos arranxar eso..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Imos mesturar a rama `master` en `bugFix`:"
"Imos mesturar a rama `main` en `bugFix`:"
],
"afterMarkdowns": [
"Como o `bugFix` é un ancestro de `master`, o git non ten traballo que facer; el só ten que mover o punteiro de `bugFix` para o mesmo commit que `master`.",
"Como o `bugFix` é un ancestro de `main`, o git non ten traballo que facer; el só ten que mover o punteiro de `bugFix` para o mesmo commit que `main`.",
"",
"Agora tódolos commits teñen a mesma cor, o que significa que ambas ramas teñen o mesmo traballo no repositorios! Iepa!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -512,9 +585,9 @@ exports.level = {
"* Crea unha nova ramara chamada `bugFix`",
"* Fai checkout da rama `bugFix` con `git checkout bugFix`",
"* Fai un commit",
"* Volve á rama `master` con `git checkout`",
"* Volve á rama `main` con `git checkout`",
"* Fai un novo commit",
"* Xunta a rama `bugFix` en `master` con `git merge`",
"* Xunta a rama `bugFix` en `main` con `git merge`",
"",
"¡Recorda, podes amosar esta mensaxe novamente co comando \"objective\"!"
]
@ -530,7 +603,7 @@ exports.level = {
"markdowns": [
"## Branches et Merges",
"",
"Super ! Nous savons désormais comment faire des commits et des branches. Maintenant nous devons apprendre comment combiner ensemble les contenus de deux branches différentes. Ceci nous permettra de créer une nouvelle branche, développer une nouvelle fonctionnalité sur cette dernière, puis intégrer cette fonctionnalité en combinant le contenu de cette branche de développement à la branche d'origine (master par exemple).",
"Super ! Nous savons désormais comment faire des commits et des branches. Maintenant nous devons apprendre comment combiner ensemble les contenus de deux branches différentes. Ceci nous permettra de créer une nouvelle branche, développer une nouvelle fonctionnalité sur cette dernière, puis intégrer cette fonctionnalité en combinant le contenu de cette branche de développement à la branche d'origine (main par exemple).",
"",
"La première méthode que nous allons voir pour combiner le contenu de deux branches est `git merge`. Faire un 'merge' avec Git crée un commit spécial qui a deux parents. Un commit avec deux parents indique en susbtance \"Je veux inclure le contenu de ce parent et le contenu de cet autre parent, *et* l'ensemble de leurs parents.\"",
"",
@ -544,32 +617,32 @@ exports.level = {
"beforeMarkdowns": [
"Ici nous avons deux branches ; chacune a un commit qui lui est propre. Cela signifie qu'aucune des deux branches n'inclut la totalité du \"travail\" qui a été fait dans le dépôt. Arrangeons-cela avec merge.",
"",
"Nous allons `merge` («fusionner») la branche `bugFix` dans `master`."
"Nous allons `merge` («fusionner») la branche `bugFix` dans `main`."
],
"afterMarkdowns": [
"Youhou ! Vous avez vu ça ? Avant tout, `master` pointe donc maintenant sur un commit qui a deux parents. Si vous remontez l'enchaînement des flèches depuis `master`, vous allez passez par tous les commits jusqu'à la racine. Cela signifie que `master` contient maintenant tout le travail du dépôt.",
"Youhou ! Vous avez vu ça ? Avant tout, `main` pointe donc maintenant sur un commit qui a deux parents. Si vous remontez l'enchaînement des flèches depuis `main`, vous allez passez par tous les commits jusqu'à la racine. Cela signifie que `main` contient maintenant tout le travail du dépôt.",
"",
"Par ailleurs, avez-vous remarqué les nouvelles couleurs des commits ? Pour faciliter l'apprentissage, j'ai inclus une certaine logique dans la coloration. Chaque branche a une unique couleur. Chaque commit est de la couleur de toutes les branches qui le contiennent.",
"",
"Ici nous voyons que la couleur de `master` est intégrée à tous les commits, sauf ceux de `bugFix`. Réparons-cela ..."
"Ici nous voyons que la couleur de `main` est intégrée à tous les commits, sauf ceux de `bugFix`. Réparons-cela ..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Faisons un merge de `master` dans `bugFix`:"
"Faisons un merge de `main` dans `bugFix`:"
],
"afterMarkdowns": [
"Puisque `bugFix` était un ancêtre de `master`, git n'avait aucun travail à effectuer; il a simplement déplacé `bugFix` au même commit auquel `master` est attaché.",
"Puisque `bugFix` était un ancêtre de `main`, git n'avait aucun travail à effectuer; il a simplement déplacé `bugFix` au même commit auquel `main` est attaché.",
"",
"Maintenant tous les commits sont de la même couleur, ce qui indique que chaque branche contient tout le contenu du dépôt ! Woohoo!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -581,9 +654,9 @@ exports.level = {
"* Faites une nouvelle branche appelée `bugFix`",
"* Positionnez-vous sur la branche `bugFix` avec `git checkout bugFix`",
"* Faites un commit",
"* Retournez sur la branche `master` (commande `git checkout`)",
"* Retournez sur la branche `main` (commande `git checkout`)",
"* Faites un nouveau commit",
"* Fusionnez la branche `bugFix` dans `master` avec `git merge`",
"* Fusionnez la branche `bugFix` dans `main` avec `git merge`",
"",
"*Rappelez-vous que vous pouvez à tout moment réafficher ces indications avec \"objective\"!*"
]
@ -613,32 +686,32 @@ exports.level = {
"beforeMarkdowns": [
"我们准备了两个分支，每个分支上各有一个独有的提交。这意味着没有一个分支包含了我们修改的所有内容。咱们通过合并这两个分支来解决这个问题。",
"",
"我们要把 `bugFix` 合并到 `master` 里"
"我们要把 `bugFix` 合并到 `main` 里"
],
"command": "git merge bugFix",
"afterMarkdowns": [
"哇哦！看见了吗？首先，`master` 现在指向了一个拥有两个父节点的提交记录。假如从 `master` 开始沿着箭头向上看，在到达起点的路上会经过所有的提交记录。这意味着 `master` 包含了对代码库的所有修改。↓↓↓",
"哇哦！看见了吗？首先，`main` 现在指向了一个拥有两个父节点的提交记录。假如从 `main` 开始沿着箭头向上看，在到达起点的路上会经过所有的提交记录。这意味着 `main` 包含了对代码库的所有修改。↓↓↓",
"",
"还有，看见各个提交记录的颜色变化了吗？为了帮助学习理解，我引入了颜色搭配。每个分支都有不同的颜色，而每个提交记录的颜色是所有包含该提交记录的分支的颜色混合之后的颜色。",
"",
"所以，`master` 分支的颜色被混入到所有的提交记录，但 `bugFix` 没有。下面咱们让它也改变一下颜色。"
"所以，`main` 分支的颜色被混入到所有的提交记录，但 `bugFix` 没有。下面咱们让它也改变一下颜色。"
],
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"咱们再把 `master` 分支合并到 `bugFix`："
"咱们再把 `main` 分支合并到 `bugFix`："
],
"command": "git checkout bugFix; git merge master",
"command": "git checkout bugFix; git merge main",
"afterMarkdowns": [
"因为 `master` 继承自 `bugFix`，Git 什么都不用做，只是简单地把 `bugFix` 移动到 `master` 所指向的那个提交记录。",
"因为 `main` 继承自 `bugFix`，Git 什么都不用做，只是简单地把 `bugFix` 移动到 `main` 所指向的那个提交记录。",
"",
"现在所有提交记录的颜色都一样了，这表明每一个分支都包含了代码库的所有修改！大功告成！"
],
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -650,9 +723,9 @@ exports.level = {
"* 创建新分支 `bugFix`",
"* 用 `git checkout bugFix` 命令切换到该分支",
"* 提交一次",
"* 用 `git checkout master` 切换回 `master`",
"* 用 `git checkout main` 切换回 `main`",
"* 再提交一次",
"* 用 `git merge` 把 `bugFix` 合并到 `master`",
"* 用 `git merge` 把 `bugFix` 合并到 `main`",
"",
"* 你随时都可以用“objective”命令来打开这个对话框！*"
]
@ -668,7 +741,7 @@ exports.level = {
"markdowns": [
"## branch 以及 merge",
"",
"太好了! 我們已經知道怎麼使用 commit 和 branch 了。接下來要學的一招是如何合併（merge）兩個不同 branch 的工作。這讓我們可以建立一個新的 branch ，並且在上面開發新功能，然後合併回 master branch。",
"太好了! 我們已經知道怎麼使用 commit 和 branch 了。接下來要學的一招是如何合併（merge）兩個不同 branch 的工作。這讓我們可以建立一個新的 branch ，並且在上面開發新功能，然後合併回 main branch。",
"",
"`git merge` 是我們要學習 merge 的第一個方法。該 merge 會產生一個特殊的 commit，它包含兩個唯一 parent commit。一個 commit 如果有兩個 parent commit 的話，那就表示：「我想把這兩個 parent commit 本身及它們的 所有的 parent commit 都包含進來。」",
"",
@ -682,32 +755,32 @@ exports.level = {
"beforeMarkdowns": [
"在這裡，我們有兩個 branch：各自都有一個唯一的 commit。這意味著沒有一個 branch 包含我們對文件的所有修改。讓我們 merge 這兩個 branch 來解決這個問題。",
"",
"我們要 merge `bugFix` 到 `master` "
"我們要 merge `bugFix` 到 `main` "
],
"command": "git merge bugFix",
"afterMarkdowns": [
"哇！看見了沒有？首先，`master` 現在指向一個 commit，這個 commit 有兩個 parent commit。假如從 `master` 開始沿著箭頭向上走，在到達起點的路上會經過所有的 commit。這說明了現在 `master` 紀錄了對文件的所有修改。",
"哇！看見了沒有？首先，`main` 現在指向一個 commit，這個 commit 有兩個 parent commit。假如從 `main` 開始沿著箭頭向上走，在到達起點的路上會經過所有的 commit。這說明了現在 `main` 紀錄了對文件的所有修改。",
"",
"還有，看見各個 commit 的顏色變化了嗎？為了幫助學習，我混合了顏色。每個 branch 都有特定的顏色。每個 commit 的顏色都變成了含有此 commit 的所有 branch 的混合色。",
"",
"所以，`master` branch 的顏色被混入到所有的 commit，但 `bugFix` 沒有。接下來就改一下這裡吧。"
"所以，`main` branch 的顏色被混入到所有的 commit，但 `bugFix` 沒有。接下來就改一下這裡吧。"
],
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"讓我們 merge `master` branch 到 `bugFix` 吧。"
"讓我們 merge `main` branch 到 `bugFix` 吧。"
],
"command": "git checkout bugFix; git merge master",
"command": "git checkout bugFix; git merge main",
"afterMarkdowns": [
"因為 `bugFix` branch只是 `master` branch 的 parent，git 什麼都不用做，只是簡單地把 `bugfix` branch 移動到 `master` 指向的 commit。",
"因為 `bugFix` branch只是 `main` branch 的 parent，git 什麼都不用做，只是簡單地把 `bugfix` branch 移動到 `main` 指向的 commit。",
"",
"現在所有的 commit 的顏色都是一樣的啦，這表示每一個 branch 都包含了所有文件的修改！太厲害了啦！"
],
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -719,9 +792,9 @@ exports.level = {
"* 建立新的 branch，叫做 `bugFix` ",
"* 用 `git checkout bugFix` 切換到 `bugFix` branch",
"* commit 一次",
"* 用 `git checkout` 切換回 `master` branch",
"* 用 `git checkout` 切換回 `main` branch",
"* 再 commit 一次",
"* 用 `git merge` 將 `bugFix` merge 到 `master`",
"* 用 `git merge` 將 `bugFix` merge 到 `main`",
"",
"*記住，你可以用 \"objective\" 指令來重新顯示這個對話框！*"
]
@ -751,32 +824,32 @@ exports.level = {
"beforeMarkdowns": [
"여기에 브랜치가 두 개 있습니다. 각 브랜치에 독립된 커밋이 하나씩 있구요. 그 말은 이 저장소에 지금까지 작업한 내역이 나뉘어 담겨 있다는 얘기입니다. 두 브랜치를 합쳐서(merge) 이 문제를 해결해 볼까요?",
"",
"`bugFix` 브랜치를 `master` 브랜치에 합쳐(merge) 보겠습니다."
"`bugFix` 브랜치를 `main` 브랜치에 합쳐(merge) 보겠습니다."
],
"afterMarkdowns": [
"보셨어요? 우선, `master`가 두 부모가 있는 커밋을 가리키고 있습니다. ",
"보셨어요? 우선, `main`가 두 부모가 있는 커밋을 가리키고 있습니다. ",
"",
"또, 커밋들의 색이 바뀐 것을 눈치 채셨나요? 이해를 돕기위해 색상으로 구분해 표현했습니다. 각 브랜치는 그 브랜치만의 색상으로 그렸습니다. 브랜치가 합쳐지는 커밋의 경우에는, 그 브랜치들의 색을 조합한 색상으로 표시 했습니다.",
"",
"그런식으로 여기에 `bugFix`브랜치 쪽을 제외한 나머지 커밋만 `master` 브랜치의 색으로 칠해져 있습니다. 이걸 고쳐보죠..."
"그런식으로 여기에 `bugFix`브랜치 쪽을 제외한 나머지 커밋만 `main` 브랜치의 색으로 칠해져 있습니다. 이걸 고쳐보죠..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"이제 `master` 브랜치에 `bugFix`를 합쳐(merge) 봅시다:"
"이제 `main` 브랜치에 `bugFix`를 합쳐(merge) 봅시다:"
],
"afterMarkdowns": [
"`bugFix`가 `master`의 부모쪽에 있었기 때문에, git이 별다른 일을 할 필요가 없었습니다; 간단히 `bugFix`를 `master`가 붙어 있는 커밋으로 이동시켰을 뿐입니다.",
"`bugFix`가 `main`의 부모쪽에 있었기 때문에, git이 별다른 일을 할 필요가 없었습니다; 간단히 `bugFix`를 `main`가 붙어 있는 커밋으로 이동시켰을 뿐입니다.",
"",
"짜잔! 이제 모든 커밋의 색이 같아졌고, 이는 두 브랜치가 모두 저장소의 모든 작업 내역을 포함하고 있다는 뜻입니다."
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -788,9 +861,9 @@ exports.level = {
"* `bugFix`라는 새 브랜치를 만듭니다",
"* `git checkout bugFix`를 입력해 `bugFix` 브랜치로 이동(checkout)합니다.",
"* 커밋 한 번 하세요",
"* `git checkout` 명령어를 이용해 `master`브랜치로 돌아갑니다",
"* `git checkout` 명령어를 이용해 `main`브랜치로 돌아갑니다",
"* 커밋 또 하세요",
"* `git merge` 명령어로 `bugFix`브랜치를 `master`에 합쳐 넣습니다.",
"* `git merge` 명령어로 `bugFix`브랜치를 `main`에 합쳐 넣습니다.",
"",
"*아 그리고, \"objective\" 명령어로 이 안내창을 다시 볼 수 있다는 것을 기억해 두세요!*"
]
@ -820,32 +893,32 @@ exports.level = {
"beforeMarkdowns": [
"Вот у нас две ветки, каждая содержит по одному уникальному коммиту. Это означает, что ни одна из веток не содержит полный набор \"работ\", выполненных в этом репозитории. Можно исправить эту ситуацию, выполнив слияние.",
"",
"Мы сделаем `merge` ветки `bugFix` в ветку `master`."
"Мы сделаем `merge` ветки `bugFix` в ветку `main`."
],
"afterMarkdowns": [
"Что мы видим? Во-первых, ветка `master` теперь указывает на коммит, у которого два родителя. Если проследовать по стрелкам от этого коммита, вы пройдёте через каждый коммит в дереве прямиком к началу. Это означает, что теперь в ветке `master` содержатся все изменения репозитория.",
"Что мы видим? Во-первых, ветка `main` теперь указывает на коммит, у которого два родителя. Если проследовать по стрелкам от этого коммита, вы пройдёте через каждый коммит в дереве прямиком к началу. Это означает, что теперь в ветке `main` содержатся все изменения репозитория.",
"",
"Во-вторых, обрати внимание, как изменились цвета коммитов. Мы ввели цветовую дифференциацию, чтобы помочь пониманию. У каждой ветки — свой цвет. Каждый коммит становится того цвета, какого его ветка. Если в нём изменения сразу двух веток - он становится цветом, смешанным из цветов родительских веток.",
"",
"И вот мы видим, что цвет ветки `master` подмешан к каждому коммиту, а ветки `bugFix` - нет. Это можно поправить."
"И вот мы видим, что цвет ветки `main` подмешан к каждому коммиту, а ветки `bugFix` - нет. Это можно поправить."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Смерджим ветку `master` в ветку `bugFix`."
"Смерджим ветку `main` в ветку `bugFix`."
],
"afterMarkdowns": [
"Так как ветка `bugFix` была предшественницей `master`, Git не делал ничего, только сдвинул `bugFix` на тот же коммит, где находится `master`",
"Так как ветка `bugFix` была предшественницей `main`, Git не делал ничего, только сдвинул `bugFix` на тот же коммит, где находится `main`",
"",
"Теперь все коммиты одного цвета, что означает, что каждая ветка содержит все изменения репозитория! Поздравляем!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -857,9 +930,9 @@ exports.level = {
"* Создай новую ветку под названием `bugFix`",
"* Переключись на новую ветку `bugFix` командой `git checkout bugFix`",
"* Сделай один коммит",
"* Вернись на ветку `master` при помощи `git checkout`",
"* Вернись на ветку `main` при помощи `git checkout`",
"* Сделай ещё один коммит",
"* Слей ветку `bugFix` с веткой `master` при помощи `git merge`",
"* Слей ветку `bugFix` с веткой `main` при помощи `git merge`",
"",
"* Если что-то пошло не так - можешь подглядеть в эту шпаргалку командой \"objective\"!*"
]
@ -889,32 +962,32 @@ exports.level = {
"beforeMarkdowns": [
"Тут ми маємо дві гілки; кожна з них містить унікальний коміт. Це означає що жодна з них не містить повного набору \"робочої інфи\" в цьому репозиторії. Давайте зіллємо всю інфу докупи за допомогою merge.",
"",
"Ми `змержимо` гілку `bugFix` в `master`."
"Ми `змержимо` гілку `bugFix` в `main`."
],
"afterMarkdowns": [
"Нічого собі! Ви це бачили? По-перше, `master` тепер вказує на коміт з двома батьками. Якщо ти піднімешся вверх з цього коміту по дереву, починаючи з `master`, на шляху ти зустрінеш кожен коміт аж до кореневого. Це означає що гілка `master` тепер містить всю інфу в цьому репозиторії.",
"Нічого собі! Ви це бачили? По-перше, `main` тепер вказує на коміт з двома батьками. Якщо ти піднімешся вверх з цього коміту по дереву, починаючи з `main`, на шляху ти зустрінеш кожен коміт аж до кореневого. Це означає що гілка `main` тепер містить всю інфу в цьому репозиторії.",
"",
"А ти помітив як змінилися кольори комітів? Для кращого розуміння процесу я додав певну кольорову диференціацію. Кожен бранч виділено окремим кольором. Колір кожного коміту це суміш кольорів всіх гілок що місять цей коміт.",
"",
"Тож ми бачимо що колір гілки `master` містять всі коміти, але не колір `bugFix`. Давайте виправимо це..."
"Тож ми бачимо що колір гілки `main` містять всі коміти, але не колір `bugFix`. Давайте виправимо це..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Давай змержимо `master` в `bugFix`:"
"Давай змержимо `main` в `bugFix`:"
],
"afterMarkdowns": [
"Так як `bugFix` є нащадком `master`, git'у не потрібно нічого робити; він просто пересунув `bugFix` на тей самий коміт, на якому знаходиться `master`.",
"Так як `bugFix` є нащадком `main`, git'у не потрібно нічого робити; він просто пересунув `bugFix` на тей самий коміт, на якому знаходиться `main`.",
"",
"Тепер всі коміти одного кольору, що означає що кожен бранч включає в собі всю корисну інфу яка є в цьому репозиторії! Ура!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -926,9 +999,9 @@ exports.level = {
"* Зроби нову гілку (branch) з назвою `bugFix`",
"* Перейди на гілку `bugFix` за допомогою `git checkout bugFix`",
"* Зроби один коміт",
"* Повернись до `master` за допомогою `git checkout`",
"* Повернись до `main` за допомогою `git checkout`",
"* Зроби ще один коміт",
"* Змерджи (злий) гілку `bugFix` в `master` за допомогою `git merge`",
"* Змерджи (злий) гілку `bugFix` в `main` за допомогою `git merge`",
"",
"*Не забувай, ти можеш завжди повернутися до цього діалогу за допомогою \"objective\"!*"
]
@ -958,32 +1031,32 @@ exports.level = {
"beforeMarkdowns": [
"Ở đây ta có 2 nhánh; mỗi nhánh có 1 commit độc nhất. Có nghĩa là chẳng nhánh nào có đủ \"thành quả\" trong kho chứa của ta cả. Sửa nó bằng merge nào.",
"",
"Ta sẽ `merge` nhánh `bugFix` vào `master`."
"Ta sẽ `merge` nhánh `bugFix` vào `main`."
],
"afterMarkdowns": [
"Wao! Thấy chứ? Trước tiên, `master` giờ đã trỏ đến commit có 2 cha. Nếu bạn lần theo mũi tên lên trên từ `master`, bạn sẽ gặp tất cả các commit lên đến commit gốc. Có nghĩa là `master` giờ đã chứa tất cả thành quả trong kho.",
"Wao! Thấy chứ? Trước tiên, `main` giờ đã trỏ đến commit có 2 cha. Nếu bạn lần theo mũi tên lên trên từ `main`, bạn sẽ gặp tất cả các commit lên đến commit gốc. Có nghĩa là `main` giờ đã chứa tất cả thành quả trong kho.",
"",
"Đồng thời, bạn thấy màu commit thay đổi chứ? Để bạn dễ học hơn, tôi đã phối hợp một số bảng màu. Mỗi nhánh có một màu duy nhất. Mỗi commit mang màu pha trộn của tất cả nhánh chứa nó.",
"",
"Vì vậy, ở đây chúng ta thấy rằng màu nhánh `master` được pha trộn vào tất cả các commit, nhưng màu` bugFix` thì không. Hãy sửa nó nào ..."
"Vì vậy, ở đây chúng ta thấy rằng màu nhánh `main` được pha trộn vào tất cả các commit, nhưng màu` bugFix` thì không. Hãy sửa nó nào ..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Hãy gộp nhánh `master` vào `bugFix` nào:"
"Hãy gộp nhánh `main` vào `bugFix` nào:"
],
"afterMarkdowns": [
"Vì `bugFix` là bậc cha ông của `master`, git chẳng phải làm gì cả; nó đơn giản chỉ chuyển `bugFix` vào commit mà `master` đang trỏ tới.",
"Vì `bugFix` là bậc cha ông của `main`, git chẳng phải làm gì cả; nó đơn giản chỉ chuyển `bugFix` vào commit mà `main` đang trỏ tới.",
"",
"Giờ thì tất cả commit đã có cùng màu, nghĩa là mỗi nhánh đã chứa tất cả thành quả trong kho! Ồ hố!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -995,9 +1068,9 @@ exports.level = {
"* Tạo một nhánh mới tên là `bugFix`",
"* Chuyển sang nhánh `bugFix` với `git checkout bugFix`",
"* Commit một lần",
"* Trở về `master` với `git checkout`",
"* Trở về `main` với `git checkout`",
"* Commit một lần nữa",
"* Gộp nhánh `bugFix` vào `master` với `git merge`",
"* Gộp nhánh `bugFix` vào `main` với `git merge`",
"",
"*Nhớ rằng, bạn luôn luôn có thể bật lại hội thoại này với lệnh \"objective\"!*"
]
@ -1027,32 +1100,32 @@ exports.level = {
"beforeMarkdowns": [
"Tu imamo dva brancha; vsak ima en commit, ki je unikaten. To pomeni, da noben branch v repozitorju nima vsega \"dela\". Pa popravimo to z mergeom.",
"",
"Sedaj bomo `mergeali` branch `bugFix` v `master`."
"Sedaj bomo `mergeali` branch `bugFix` v `main`."
],
"afterMarkdowns": [
"Woah! Si videl to? `master` sedaj kaže na commit, ki ima dva starša. Če slediš puščicam po drevesu commitov iz `master`, boš našel vsak commit po poti do roota. To pomeni, da `master` sedaj vsebuje vso delo iz repozitorija.",
"Woah! Si videl to? `main` sedaj kaže na commit, ki ima dva starša. Če slediš puščicam po drevesu commitov iz `main`, boš našel vsak commit po poti do roota. To pomeni, da `main` sedaj vsebuje vso delo iz repozitorija.",
"",
"Opaziš tudi, kako so se barve commitov spremenile? V pomoč pri učenju, sem vključil še nekaj barvne pomoči. Vsak branch ima svojo barvo. Vsak commit spremeni barvo v kombinirano barvo vseh branchev, ki imajo ta commit.",
"",
"Torej tukaj vidimo, da je `master` branch barva zmešana v vseh commitih, `bugFix` barva pa ne. Popravimo to ..."
"Torej tukaj vidimo, da je `main` branch barva zmešana v vseh commitih, `bugFix` barva pa ne. Popravimo to ..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Zmergajmo sedaj `master` v `bugFix`:"
"Zmergajmo sedaj `main` v `bugFix`:"
],
"afterMarkdowns": [
"Ker je `bugFix` bil prednik `master`, git ni rabil storiti ničesar; preprosto je premaknil `bugFix` v isti commit, kamer kaže `master`.",
"Ker je `bugFix` bil prednik `main`, git ni rabil storiti ničesar; preprosto je premaknil `bugFix` v isti commit, kamer kaže `main`.",
"",
"Sedaj so vsi commiti iste barve, kar pomeni, da vsak branch vsebuje vse delo v repozitoriju!! Woohoo!"
],
"command": "git checkout bugFix; git merge master",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit; git merge bugFix"
"command": "git checkout bugFix; git merge main",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit; git merge bugFix"
}
},
{
@ -1064,15 +1137,84 @@ exports.level = {
"* Naredi novi branch `bugFix`",
"* Checkoutaj `bugFix` branch z `git checkout bugFix`",
"* Enkrat commitaj",
"* Pojdi nazaj na `master` z `git checkout`",
"* Pojdi nazaj na `main` z `git checkout`",
"* Še enkrat commitaj",
"* Mergeaj branch `bugFix` v `master` z `git merge`",
"* Mergeaj branch `bugFix` v `main` z `git merge`",
"",
"*Pomni, vedno lahko spet pogledaš ta dialog z \"objective\"!*"
]
}
}
]
},
"pl": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Łączenie (scalanie) Branch-y",
"",
"Świetnie! Już wiemy, jak stworzyć commit-y oraz jak tworzyć branch-e. Teraz musimy się nauczyć jak połączyć pracę dwóch różnych branch-y. Stwórzmy nowy branch, wprowadzamy nową funkcjonalność, a następnie je połączymy.",
"",
"Pierwszą metodą łączenia pracy, którą zamierzamy użyć, jest `git merge`. 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\".",
"",
"Łatwiej będzie to wizualizować, zobaczymy to w następnym widoku."
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Mamy tutaj dwa branch-e (gałęzie); każdy ma po jednym commit-cie, które są unikalne. Oznacza to, że żadna z branch-y nie zawiera \"całej pracy\", które jest w naszym repozytorium. Naprawmy to za pomocą funkcji marge.",
"",
"Użyjmy `merge` aby połączyć branch `bugFix` z `main`."
],
"afterMarkdowns": [
"Wow! Widzialiście to? Przede wszystkim \"main\" wskazuje teraz na commit, który ma dwoje rodziców. Jeśli podążasz za strzałkami w górę drzewa zatwierdzenia 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 zatwierdzeń? Aby Ci pomóc 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 branch-y, które commit-ujesz",
"",
"Więc tutaj widzimy, że kolor branch-a `main` uczestniczy w miksowaniu wszystkich commit-ów, ale kolor branch-u `bugFix` już nie. Naprawmy to..."
],
"command": "git merge bugFix",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Połączmy brach `main` z branch `bugFix`:"
],
"afterMarkdowns": [
"Ponieważ `bugFix` był przodkiem branch-a `main`, GIT nie musiał wykonywać żadnej pracy; po prostu przeniosł branch `bugFix` do tego samego commit-a, do którego był dołączony branch `main`.",
"",
"Teraz wszystkie commit-y mają ten sam kolor, co oznacza, że każdy branch 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"
}
},
{
"type": "ModalAlert",
"options": {
"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 branch-u `main` za pomocą polecenia `git checkout`",
"* Zrób ponownie commit",
"* Złącz branch `bugFix` z branch-em `main` używając polecenia `git merge`",
"",
"*Pamiętaj: zawsze możesz zobaczyć tą wiadomość ponownie, wpisując \"objective\"!*"
]
}
}
]
}
}
};

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

@ -1,11 +1,12 @@
exports.level = {
"goalTreeString": "%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C3%22%2C%22id%22%3A%22master%22%7D%2C%22bugFix%22%3A%7B%22target%22%3A%22C2%27%22%2C%22id%22%3A%22bugFix%22%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C2%27%22%3A%7B%22parents%22%3A%5B%22C3%22%5D%2C%22id%22%3A%22C2%27%22%7D%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22bugFix%22%2C%22id%22%3A%22HEAD%22%7D%7D",
"solutionCommand": "git checkout -b bugFix;git commit;git checkout master;git commit;git checkout bugFix;git rebase master",
"solutionCommand": "git checkout -b bugFix;git commit;git checkout main;git commit;git checkout bugFix;git rebase main",
"name": {
"en_US": "Rebase Introduction",
"de_DE": "Einführung in Rebase",
"ja" : "Rebaseの解説",
"es_AR": "Introducción a rebase",
"es_MX": "Introducción a rebase",
"es_ES": "Introducción a rebase",
"pt_BR": "Introdução ao rebase",
"gl" : "Introducción a rebase",
@ -16,7 +17,8 @@ exports.level = {
"ru_RU": "Введение в rebase",
"uk": "Знайомство з rebase",
"vi": "Giới thiệu về rebase",
'sl_SI': 'Uvod v Rebase'
'sl_SI': 'Uvod v Rebase',
"pl" : "Wprowadzenie do Rebase"
},
"hint": {
"en_US": "Make sure you commit from bugFix first",
@ -24,6 +26,7 @@ exports.level = {
"ja" : "初めにbugFixを指した状態でコミットする",
"fr_FR": "Assurez-vous de bien faire votre commit sur bugFix en premier",
"es_AR": "Asegurate de commitear desde bugFix primero",
"es_MX": "Asegúrate de hacer commit desde bugFix primero",
"es_ES": "Asegúrate de hacer commit desde bugFix primero",
"pt_BR": "O bugFix precisa ser commitado primeiro",
"gl" : "Asegurate de facer o commit dende bugFix primeiro",
@ -33,7 +36,8 @@ exports.level = {
"ru_RU": "Убедись, что сделал коммит в ветке bugFix",
"uk": "Впевнись, що зробив коміт в гілці bugFix",
"vi": "Hãy chắc chắn rằng bạn commit từ bugFix trước",
'sl_SI': 'Prepričaj se, da si najprej commital bugFix.'
'sl_SI': 'Prepričaj se, da si najprej commital bugFix.',
"pl" : "Upewnij się, że masz commit z bugFix"
},
"disabledMap": {
"git revert": true
@ -61,18 +65,18 @@ exports.level = {
"beforeMarkdowns": [
"Here we have two branches yet again; note that the bugFix branch is currently selected (note the asterisk)",
"",
"We would like to move our work from bugFix directly onto the work from master. That way it would look like these two features were developed sequentially, when in reality they were developed in parallel.",
"We would like to move our work from bugFix directly onto the work from main. That way it would look like these two features were developed sequentially, when in reality they were developed in parallel.",
"",
"Let's do that with the `git rebase` command."
],
"afterMarkdowns": [
"Awesome! Now the work from our bugFix branch is right on top of master and we have a nice linear sequence of commits.",
"Awesome! Now the work from our bugFix branch is right on top of main and we have a nice linear sequence of commits.",
"",
"Note that the commit C3 still exists somewhere (it has a faded appearance in the tree), and C3' is the \"copy\" that we rebased onto master.",
"Note that the commit C3 still exists somewhere (it has a faded appearance in the tree), and C3' is the \"copy\" that we rebased onto main.",
"",
"The only problem is that master hasn't been updated either, let's do that now..."
"The only problem is that main hasn't been updated either, let's do that now..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -80,13 +84,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Now we are checked out on the `master` branch. Let's go ahead and rebase onto `bugFix`..."
"Now we are checked out on the `main` branch. Let's go ahead and rebase onto `bugFix`..."
],
"afterMarkdowns": [
"There! Since `master` was an ancestor of `bugFix`, git simply moved the `master` branch reference forward in history."
"There! Since `main` was an ancestor of `bugFix`, git simply moved the `main` branch reference forward in history."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -97,8 +101,8 @@ exports.level = {
"",
"* Checkout a new branch named `bugFix`",
"* Commit once",
"* Go back to master and commit again",
"* Check out bugFix again and rebase onto master",
"* Go back to main and commit again",
"* Check out bugFix again and rebase onto main",
"",
"Good luck!"
]
@ -116,7 +120,7 @@ exports.level = {
"",
"Der zweite Weg um Inhalte aus verschiedenen Branches zu kombinieren ist `git rebase`. Rebasen nimmt im Prinzip eine Menge von Commits, \"kopiert\" sie und packt sie auf etwas anderes drauf.",
"",
"Auch wenn das erst mal komisch klingt liegt der Vorteil von Rebase darin, dass man es benutzen kann um hübsch lineare Abfolgen von Commits zu erhalten. Das Commit-Protokoll des Repositorys wird durch Rebase eine ganze Ecke einfacher aussehen, weil Merge Commits vermieden werden.",
"Auch wenn das erst mal komisch klingt, liegt der Vorteil von Rebase darin, dass man es benutzen kann um hübsch lineare Abfolgen von Commits zu erhalten. Das Commit-Protokoll des Repositorys wird durch Rebase eine ganze Ecke einfacher aussehen, weil Merge Commits vermieden werden.",
"",
"Schauen wir's uns mal in Aktion an ..."
]
@ -128,18 +132,18 @@ exports.level = {
"beforeMarkdowns": [
"Hier haben wir wieder zwei Branches; wie du siehst ist `bugFix` aktuell ausgewählt (sieht man am `*`).",
"",
"Wir würden jetzt gerne unsere Arbeit aus `bugFix` direkt auf den `master` packen. Das Ergebnis wäre, dass alle aktuellen Änderungen in `master` auch im Branch `bugFix` sind.",
"Wir würden jetzt gerne unsere Arbeit aus `bugFix` direkt auf den `main` packen. Das Ergebnis wäre, dass alle aktuellen Änderungen in `main` auch im Branch `bugFix` sind.",
"",
"Das machen wir mit dem Befehl `git rebase`:"
],
"afterMarkdowns": [
"Hammer! Was wir in `bugFix` gemacht haben ist jetzt oben auf `master` draufgepackt und wir haben eine schön lineare Abfolge von Commits bekommen.",
"Hammer! Was wir in `bugFix` gemacht haben ist jetzt oben auf `main` draufgepackt und wir haben eine schön lineare Abfolge von Commits bekommen.",
"",
"Commit `C3` existiert immer noch irgendwo (deswegen ist er blaß dargestellt) und `C3'` ist die \"Kopie\" die wir auf den `master` gepackt haben.",
"Commit `C3` existiert immer noch irgendwo (deswegen ist er blaß dargestellt) und `C3'` ist die \"Kopie\" die wir auf den `main` gepackt haben.",
"",
"Aber `master` ist jetzt nicht aktualisiert worden, lass uns das gerade noch nachholen ..."
"Aber `main` ist jetzt nicht aktualisiert worden, lass uns das gerade noch nachholen ..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -147,13 +151,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Jetzt sind wir im `master`. Lass uns den mal auf `bugFix` rebasen ..."
"Jetzt sind wir im `main`. Lass uns den mal auf `bugFix` rebasen ..."
],
"afterMarkdowns": [
"So! Da `master` ein Vorgänger von `bugFix` war konnte Git hier einfach den Bezeichner `master` auf denselben Commit schieben, auf den auch `bugFix` zeigt."
"So! Da `main` ein Vorgänger von `bugFix` war konnte Git hier einfach den Bezeichner `main` auf denselben Commit schieben, auf den auch `bugFix` zeigt."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -164,8 +168,8 @@ exports.level = {
"",
"* Einen neuen Branch namens `bugFix` auschecken",
"* Einen Commit machen",
"* Zurück zum `master` wechseln und noch einmal committen",
"* `bugFix` auschecken und auf den `master` rebasen",
"* Zurück zum `main` wechseln und noch einmal committen",
"* `bugFix` auschecken und auf den `main` rebasen",
"",
"Viel Erfolg!"
]
@ -206,7 +210,7 @@ exports.level = {
"",
"一つ問題が残ってて、masterブランチがまだ最新化されていませんね。ちょっと直してみましょう。。"
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -217,10 +221,10 @@ exports.level = {
"masterブランチにチェックアウトしてあります。この状態からmasterブランチを`bugFix`へとリベースしてみましょう。"
],
"afterMarkdowns": [
"できた！`master`は`bugFix`の直前のコミットだったので、gitは単純に`master`ブランチのポインタを前に進めただけでした。"
"できた！`main`は`bugFix`の直前のコミットだったので、gitは単純に`main`ブランチのポインタを前に進めただけでした。"
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -262,18 +266,18 @@ exports.level = {
"beforeMarkdowns": [
"Acá tenemos dos ramas otra vez. Notar que la rama bugFix está actualmente seleccionada (tiene un asterisco)",
"",
"Nos gustaría mover nuestro trabajo de bugFix directamente sobre el trabajo de master. De ese modo, parecería que esas dos tareas se desarrollaron secuencialmente, cuando en realidad se hicieron en paralelo.",
"Nos gustaría mover nuestro trabajo de bugFix directamente sobre el trabajo de main. De ese modo, parecería que esas dos tareas se desarrollaron secuencialmente, cuando en realidad se hicieron en paralelo.",
"",
"Hagámoslo usando el comando `git rebase`."
],
"afterMarkdowns": [
"¡Genial! Ahora el trabajo de nuestra rama bugFix está justo encima del de master, y tenemos una secuencia lineal de commits.",
"¡Genial! Ahora el trabajo de nuestra rama bugFix está justo encima del de main, y tenemos una secuencia lineal de commits.",
"",
"Notá que el commit C3 sigue existiendo en algún lado (aparece medio desvanecido en el árbol), y C3' es la \"copia\" que rebaseamos sobre master.",
"Notá que el commit C3 sigue existiendo en algún lado (aparece medio desvanecido en el árbol), y C3' es la \"copia\" que rebaseamos sobre main.",
"",
"El único problema es que master todavía no se actualizó, resolvámoslo ahora..."
"El único problema es que main todavía no se actualizó, resolvámoslo ahora..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -281,13 +285,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ahora estamos parados sobre la rama `master`. Avancemos y rebaseémosla sobre `bugFix`..."
"Ahora estamos parados sobre la rama `main`. Avancemos y rebaseémosla sobre `bugFix`..."
],
"afterMarkdowns": [
"¡Ahí está! Como `master` era un ancestro de `bugFix`, git simplemente movió la referencia de `master` hacia adelante en la historia."
"¡Ahí está! Como `main` era un ancestro de `bugFix`, git simplemente movió la referencia de `main` hacia adelante en la historia."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -298,8 +302,75 @@ exports.level = {
"",
"* Checkouteá una nueva rama llamada `bugFix`",
"* Commiteá una vez",
"* Volvé a master y commiteå de nuevo",
"* Checkoutá bugFix otra vez y rebaseala sobre master",
"* Volvé a main y commiteå de nuevo",
"* Checkoutá bugFix otra vez y rebaseala sobre main",
"",
"¡Éxitos!"
]
}
}
]
},
"es_MX": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Git Rebase",
"",
"El segundo modo de combinar el trabajo de distintas ramas es el *rebase*. Rebasear esencialmente agarra un conjunto de commits, los \"copia\", y los aplica sobre algún otro lado.",
"",
"Aunque esto pueda sonar confuso, la ventaja de rebasear es que puede usarse para conseguir una secuencia de commits lineal, más bonita. El historial / log de commits del repositorio va a estar mucho más claro si sólo usas rebase.",
"",
"Veámoslo en acción..."
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Acá tenemos dos ramas otra vez. Nota que la rama bugFix está actualmente seleccionada (tiene un asterisco)",
"",
"Nos gustaría mover nuestro trabajo de bugFix directamente sobre el trabajo de main. De ese modo, parecería que esas dos tareas se desarrollaron secuencialmente, cuando en realidad se hicieron en paralelo.",
"",
"Hagámoslo usando el comando `git rebase`."
],
"afterMarkdowns": [
"¡Genial! Ahora el trabajo de nuestra rama bugFix está justo encima del de main, y tenemos una secuencia lineal de commits.",
"",
"Notá que el commit C3 sigue existiendo en algún lado (aparece medio desvanecido en el árbol), y C3' es la \"copia\" que rebaseamos sobre main.",
"",
"El único problema es que main todavía no se actualizó, resolvámoslo ahora..."
],
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ahora estamos parados sobre la rama `main`. Avancemos y rebaseémosla sobre `bugFix`..."
],
"afterMarkdowns": [
"¡Ahí está! Como `main` era un ancestro de `bugFix`, git simplemente movió la referencia de `main` hacia adelante en la historia."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nivel, haz lo siguiente:",
"",
"* Cámbiate a una nueva rama llamada `bugFix`",
"* Haz un commit de una vez",
"* Vuelve a main y haz commit de nuevo",
"* Cámbiate a la rama bugFix otra vez y rebaséala sobre main",
"",
"¡Éxitos!"
]
@ -329,18 +400,18 @@ exports.level = {
"beforeMarkdowns": [
"Aquí tenemos dos ramas otra vez. Observa que la rama bugFix está actualmente seleccionada (tiene un asterisco)",
"",
"Nos gustaría mover nuestro trabajo de bugFix directamente sobre el trabajo de master. De ese modo, parecería que esas dos tareas se desarrollaron secuencialmente, cuando en realidad se hicieron en paralelo.",
"Nos gustaría mover nuestro trabajo de bugFix directamente sobre el trabajo de main. De ese modo, parecería que esas dos tareas se desarrollaron secuencialmente, cuando en realidad se hicieron en paralelo.",
"",
"Hagámoslo usando el comando `git rebase`."
],
"afterMarkdowns": [
"¡Genial! Ahora el trabajo de nuestra rama bugFix está justo encima del de master, y tenemos una secuencia lineal de commits.",
"¡Genial! Ahora el trabajo de nuestra rama bugFix está justo encima del de main, y tenemos una secuencia lineal de commits.",
"",
"Nota que el commit C3 sigue existiendo en algún lado (aparece medio desvanecido en el árbol), y C3' es la \"copia\" que rebaseamos sobre master.",
"Nota que el commit C3 sigue existiendo en algún lado (aparece medio desvanecido en el árbol), y C3' es la \"copia\" que rebaseamos sobre main.",
"",
"El único problema es que master todavía no se actualizó, resolvámoslo ahora..."
"El único problema es que main todavía no se actualizó, resolvámoslo ahora..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -348,13 +419,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ahora estamos parados sobre la rama `master`. Avancemos y hagamos rebase sobre `bugFix`..."
"Ahora estamos parados sobre la rama `main`. Avancemos y hagamos rebase sobre `bugFix`..."
],
"afterMarkdowns": [
"¡Ahí está! Como `master` era un ancestro de `bugFix`, git simplemente movió la referencia de `master` hacia adelante en la historia."
"¡Ahí está! Como `main` era un ancestro de `bugFix`, git simplemente movió la referencia de `main` hacia adelante en la historia."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -365,8 +436,8 @@ exports.level = {
"",
"* Haz checkout de una nueva rama llamada `bugFix`",
"* Crea un commit",
"* Vuelve a la rama master y crea otro commit",
"* Haz checkout en bugFix otra vez y haz rebase sobre master",
"* Vuelve a la rama main y crea otro commit",
"* Haz checkout en bugFix otra vez y haz rebase sobre main",
"",
"¡Misión cumplida!"
]
@ -396,18 +467,18 @@ exports.level = {
"beforeMarkdowns": [
"Aqui temos dois ramos novamente; note que o ramo bugFix está atualmente ativo (veja o asterisco)",
"",
"Queremos mover nosso trabalho do bugFix diretamente dentro do master. Desta forma, vai parecer que esses dois recursos foram desenvolvidos sequencialmente, quando na realidade foram feitos em paralelo.",
"Queremos mover nosso trabalho do bugFix diretamente dentro do main. Desta forma, vai parecer que esses dois recursos foram desenvolvidos sequencialmente, quando na realidade foram feitos em paralelo.",
"",
"Vamos fazê-lo com o comando `git rebase`."
],
"afterMarkdowns": [
"Incrível! Agora o trabalho do nosso ramo bugFix está logo após o do master, e temos uma linda sequência linear de commits.",
"Incrível! Agora o trabalho do nosso ramo bugFix está logo após o do main, e temos uma linda sequência linear de commits.",
"",
"Perceba que o commit C3 ainda existe em algum lugar (ele está clareado na árvore), e que o C3' é a \"cópia\" que rebaseamos no master.",
"Perceba que o commit C3 ainda existe em algum lugar (ele está clareado na árvore), e que o C3' é a \"cópia\" que rebaseamos no main.",
"",
"O único problema é que o master não foi atualizado também, vamos fazê-lo agora..."
"O único problema é que o main não foi atualizado também, vamos fazê-lo agora..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -415,13 +486,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Agora o ramo `master` está ativo. Vamos em frente, fazer rebase no `bugFix`..."
"Agora o ramo `main` está ativo. Vamos em frente, fazer rebase no `bugFix`..."
],
"afterMarkdowns": [
"Aí está! Como o `master` era um ancestral do `bugFix`, o git simplesmente moveu a referência do ramo `master` para frente na história."
"Aí está! Como o `main` era um ancestral do `bugFix`, o git simplesmente moveu a referência do ramo `main` para frente na história."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -432,8 +503,8 @@ exports.level = {
"",
"* Faça checkout de um novo branch chamado `bugFix`",
"* Faça um commit",
"* Volte ao master e faça um novo commit",
"* Faça checkout do bugFix novamente e faça rebase no master",
"* Volte ao main e faça um novo commit",
"* Faça checkout do bugFix novamente e faça rebase no main",
"",
"Boa sorte!"
]
@ -463,18 +534,18 @@ exports.level = {
"beforeMarkdowns": [
"Aquí temos dúas ramas novamente; decátate de que a rama `bugFix` está seleccionada (olla ó asterisco)",
"",
"Queremos mover o noso traballo do `bugFix` directamente dentro da rama `master`. Desta forma, vai parecer que eses dous recursos foron editados secuencialmente, cando a realidade é que se fixeron en paralelo.",
"Queremos mover o noso traballo do `bugFix` directamente dentro da rama `main`. Desta forma, vai parecer que eses dous recursos foron editados secuencialmente, cando a realidade é que se fixeron en paralelo.",
"",
"Imos lanzar o comando `git rebase`."
],
"afterMarkdowns": [
"¡Buah chorvo! Agora o traballo da nosa rama `bugFix` está seguida de master, e temos unha fermosa línea de commits.",
"¡Buah chorvo! Agora o traballo da nosa rama `bugFix` está seguida de main, e temos unha fermosa línea de commits.",
"",
"Percibe que o commit `C3` aínda existe nalgún lugar (el está borrado na árbore), e que `C3'` é a \"copia\" que rebasamos en master.",
"Percibe que o commit `C3` aínda existe nalgún lugar (el está borrado na árbore), e que `C3'` é a \"copia\" que rebasamos en main.",
"",
"O único problema é que a rama master non foi actualizada tamén, ímolo facer agora..."
"O único problema é que a rama main non foi actualizada tamén, ímolo facer agora..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -482,13 +553,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Agora a rama `master` está ativa. Continuamos facendo o rebase na `bugFix`..."
"Agora a rama `main` está ativa. Continuamos facendo o rebase na `bugFix`..."
],
"afterMarkdowns": [
"¡Xa está! Como `master` era um ancestro de `bugFix`, git simplemente moveu a referencia da rama `master` máis adiante na historia."
"¡Xa está! Como `main` era um ancestro de `bugFix`, git simplemente moveu a referencia da rama `main` máis adiante na historia."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -499,8 +570,8 @@ exports.level = {
"",
"* Fai checkout de un novo branch chamado `bugFix`",
"* Fai un commit",
"* Regresa a master e fai un commit novamente",
"* Móvete á rama bugFix outra vez e fai rebase sobre master",
"* Regresa a main e fai un commit novamente",
"* Móvete á rama bugFix outra vez e fai rebase sobre main",
"",
"Boa sorte!"
]
@ -530,18 +601,18 @@ exports.level = {
"beforeMarkdowns": [
"Ici nous avons encore une fois deux branches; notez que nous sommes sur la branche bugFix (cf. l'astérisque)",
"",
"Nous voudrions transférer notre travail de la branche 'bugFix' directement sur le travail existant dans 'master'. Ainsi on aurait l'impression que ces deux travaux ont été développés séquentiellement alors qu'en réalité ils ont été réalisés en parallèle.",
"Nous voudrions transférer notre travail de la branche 'bugFix' directement sur le travail existant dans 'main'. Ainsi on aurait l'impression que ces deux travaux ont été développés séquentiellement alors qu'en réalité ils ont été réalisés en parallèle.",
"",
"Faisons cela avec la commande `git rebase`."
],
"afterMarkdowns": [
"Super! Désormais, le travail de la branche 'bugFix' est juste en haut de la branche 'master' et nous avons une belle séquence linéaire de commits.",
"Super! Désormais, le travail de la branche 'bugFix' est juste en haut de la branche 'main' et nous avons une belle séquence linéaire de commits.",
"",
"Notez que le commit C3 existe toujours quelque part (il est en grisé sur l'arbre), et C3' est la \"copie\" que nous avons créée sur master avec rebase.",
"Notez que le commit C3 existe toujours quelque part (il est en grisé sur l'arbre), et C3' est la \"copie\" que nous avons créée sur main avec rebase.",
"",
"Le seul problème est que master n'a pas été mis à jour, faisons cela maintenant…"
"Le seul problème est que main n'a pas été mis à jour, faisons cela maintenant…"
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -549,8 +620,8 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Nous sommes désormais positionnés sur la branche `master`. Continuons en faisant le rebase sur `bugFix`…",
"Et voilà ! Puisque `master` était un ascendant de `bugFix`, git a simplement déplacé la référence de la branche `master` en avant dans le temps."
"Nous sommes désormais positionnés sur la branche `main`. Continuons en faisant le rebase sur `bugFix`…",
"Et voilà ! Puisque `main` était un ascendant de `bugFix`, git a simplement déplacé la référence de la branche `main` en avant dans le temps."
],
"afterMarkdowns": [
"Voilà vous avez vu comment cela fonctionne",
@ -558,7 +629,7 @@ exports.level = {
"Continuons et essayons ce niveau !"
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -569,8 +640,8 @@ exports.level = {
"",
"* Positionnez-vous (checkout) sur une nouvelle branche nommée `bugFix`",
"* Faites un commit",
"* Retournez sur master et faites un nouveau commit",
"* Positionnez-vous à nouveau sur bugFix et faites un rebase sur master",
"* Retournez sur main et faites un nouveau commit",
"* Positionnez-vous à nouveau sur bugFix et faites un rebase sur main",
"",
"Bonne chance !"
]
@ -600,17 +671,17 @@ exports.level = {
"beforeMarkdowns": [
"还是准备了两个分支；注意当前所在的分支是 bugFix（星号标识的是当前分支）",
"",
"我们想要把 bugFix 分支里的工作直接移到 master 分支上。移动以后会使得两个分支的功能看起来像是按顺序开发，但实际上它们是并行开发的。",
"我们想要把 bugFix 分支里的工作直接移到 main 分支上。移动以后会使得两个分支的功能看起来像是按顺序开发，但实际上它们是并行开发的。",
"",
"咱们这次用 `git rebase` 实现此目标"
],
"command": "git rebase master",
"command": "git rebase main",
"afterMarkdowns": [
"怎么样？！现在 bugFix 分支上的工作在 master 的最顶端，同时我们也得到了一个更线性的提交序列。",
"怎么样？！现在 bugFix 分支上的工作在 main 的最顶端，同时我们也得到了一个更线性的提交序列。",
"",
"注意，提交记录 C3 依然存在（树上那个半透明的节点），而 C3' 是我们 Rebase 到 master 分支上的 C3 的副本。",
"注意，提交记录 C3 依然存在（树上那个半透明的节点），而 C3' 是我们 Rebase 到 main 分支上的 C3 的副本。",
"",
"现在唯一的问题就是 master 还没有更新，下面咱们就来更新它吧……"
"现在唯一的问题就是 main 还没有更新，下面咱们就来更新它吧……"
],
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
@ -619,13 +690,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"现在我们切换到了 `master` 上。把它 rebase 到 `bugFix` 分支上……"
"现在我们切换到了 `main` 上。把它 rebase 到 `bugFix` 分支上……"
],
"command": "git rebase bugFix",
"afterMarkdowns": [
"好了！由于 `bugFix` 继承自 `master`，所以 Git 只是简单的把 `master` 分支的引用向前移动了一下而已。"
"好了！由于 `bugFix` 继承自 `main`，所以 Git 只是简单的把 `main` 分支的引用向前移动了一下而已。"
],
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -636,8 +707,8 @@ exports.level = {
"",
"* 新建并切换到 `bugFix` 分支",
"* 提交一次",
"* 切换回 master 分支再提交一次",
"* 再次切换到 bugFix 分支，rebase 到 master 上",
"* 切换回 main 分支再提交一次",
"* 再次切换到 bugFix 分支，rebase 到 main 上",
"",
"祝你好运！"
]
@ -667,17 +738,17 @@ exports.level = {
"beforeMarkdowns": [
"這裡，還是有兩個 branch；注意目前我們所在的 branch 是 bugFix（看那顆星啦）",
"",
"我們想要把在 bugfix 所做的修改直接移到 master branch上。使用 rebasing 的話，兩個 branch 看起來像是依序按順序進行修改，實際上它們的修改是平行進行的。",
"我們想要把在 bugfix 所做的修改直接移到 main branch上。使用 rebasing 的話，兩個 branch 看起來像是依序按順序進行修改，實際上它們的修改是平行進行的。",
"",
"用 `git rebase` 來實現吧"
],
"command": "git rebase master",
"command": "git rebase main",
"afterMarkdowns": [
"很厲害吧！現在 bugFix branch 上的工作在 master branch 的最前端，同時我們也得到了一個更加線性的 commit 順序。",
"很厲害吧！現在 bugFix branch 上的工作在 main branch 的最前端，同時我們也得到了一個更加線性的 commit 順序。",
"",
"注意，本來的 commit C3 沒有消失（在圖上面呈現陰影），而我們\"複製\" C3，將它的副本 C3' 接在 master branch 的後面。",
"注意，本來的 commit C3 沒有消失（在圖上面呈現陰影），而我們\"複製\" C3，將它的副本 C3' 接在 main branch 的後面。",
"",
"現在唯一的問題是 master branch 還沒有更新...我們接下來就更新它吧！"
"現在唯一的問題是 main branch 還沒有更新...我們接下來就更新它吧！"
],
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
@ -686,13 +757,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"現在，切換到 `master` branch。接下來就把它 rebase 到 `bugFix` 上面吧..."
"現在，切換到 `main` branch。接下來就把它 rebase 到 `bugFix` 上面吧..."
],
"command": "git rebase bugFix",
"afterMarkdowns": [
"完成！因為 `master` branch 是 `bugFix` 的 parent，所以 git 只是把 `master` branch 往前移動到 `bugFix` 上。"
"完成！因為 `main` branch 是 `bugFix` 的 parent，所以 git 只是把 `main` branch 往前移動到 `bugFix` 上。"
],
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -703,8 +774,8 @@ exports.level = {
"",
"* 建立 `bugFix` branch",
"* commit 一次",
"* 切換回 master branch 再 commit 一次",
"* 再次切換到 bugFix branch，接著 rebase bugFix 這個 branch 到 master branch 上",
"* 切換回 main branch 再 commit 一次",
"* 再次切換到 bugFix branch，接著 rebase bugFix 這個 branch 到 main branch 上",
"",
"祝你好運啦！"
]
@ -734,18 +805,18 @@ exports.level = {
"beforeMarkdowns": [
"여기 또 브랜치 두 개가 있습니다; bugFix브랜치가 현재 선택됐다는 점 눈여겨 보세요 (별표 표시)",
"",
"bugFix 브랜치에서의 작업을 master 브랜치 위로 직접 옮겨 놓으려고 합니다. 그렇게 하면, 실제로는 두 기능을 따로따로 개발했지만, 마치 순서대로 개발한 것처럼 보이게 됩니다.",
"bugFix 브랜치에서의 작업을 main 브랜치 위로 직접 옮겨 놓으려고 합니다. 그렇게 하면, 실제로는 두 기능을 따로따로 개발했지만, 마치 순서대로 개발한 것처럼 보이게 됩니다.",
"",
"`git rebase` 명령어로 함께 해보죠."
],
"afterMarkdowns": [
"오! 이제 bugFix 브랜치의 작업 내용이 master의 바로 위에 깔끔한 한 줄의 커밋으로 보이게 됐습니다.",
"오! 이제 `bugFix` 브랜치의 작업 내용이 `main`의 바로 위에 깔끔한 한 줄의 커밋으로 보이게 됐습니다.",
"",
"C3 커밋은 어딘가에 아직 남아있고(그림에서 흐려짐), C3'는 master 위에 올려 놓은 복사본입니다.",
"C3 커밋은 어딘가에 아직 남아있고(그림에서 흐려짐), C3'는 `main` 위에 올려 놓은 복사본입니다.",
"",
"master가 아직 그대로라는 문제가 남아있는데요, 바로 해결해보죠..."
"`main`이 아직 그대로라는 문제가 남아있는데요, 바로 해결해보죠..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -753,13 +824,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"우리는 지금 `master` 브랜치를 선택한 상태입니다. `bugFix` 브랜치쪽으로 리베이스 해보겠습니다..."
"우리는 지금 `main` 브랜치를 선택한 상태입니다. `bugFix` 브랜치쪽으로 리베이스 해보겠습니다..."
],
"afterMarkdowns": [
"보세요! `master`가 `bugFix`의 부모쪽에 있었기 때문에, 단순히 그 브랜치를 더 앞쪽의 커밋을 가리키게 이동하는 것이 전부입니다."
"보세요! `main`이 `bugFix`의 부모쪽에 있었기 때문에, 단순히 그 브랜치를 더 앞쪽의 커밋을 가리키게 이동하는 것이 전부입니다."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -770,8 +841,8 @@ exports.level = {
"",
"* `bugFix`라는 새 브랜치를 만들어 선택하세요",
"* 커밋 한 번 합니다",
"* master로 돌아가서 또 커밋합니다",
"* bugFix를 다시 선택하고 master에 리베이스 하세요",
"* `main` 브랜치로 돌아가서 또 커밋합니다",
"* `bugFix`를 다시 선택하고 `main`에 리베이스 하세요",
"",
"화이팅!"
]
@ -801,18 +872,18 @@ exports.level = {
"beforeMarkdowns": [
"У нас здесь снова две ветки. Обрати внимание, что выбрана ветка `bugFix` (отмечена звёздочкой)",
"",
"Хочется сдвинуть наши изменения из `bugFix` прямо на вершину ветки `master`. Благодаря этому всё будет выглядеть, как будто эти изменения делались последовательно, хотя на самом деле - параллельно.",
"Хочется сдвинуть наши изменения из `bugFix` прямо на вершину ветки `main`. Благодаря этому всё будет выглядеть, как будто эти изменения делались последовательно, хотя на самом деле - параллельно.",
"",
"Применим `git rebase`."
],
"afterMarkdowns": [
"Супер! Теперь изменения из `bugFix` находятся в конце ветки `master` и являют собой линейную последовательность коммитов.",
"Супер! Теперь изменения из `bugFix` находятся в конце ветки `main` и являют собой линейную последовательность коммитов.",
"",
"Обрати внимание, что коммит С3 до сих пор существует где-то, а С3' - это его \"копия\" в ветке `master`",
"Обрати внимание, что коммит С3 до сих пор существует где-то, а С3' - это его \"копия\" в ветке `main`",
"",
"Единственная проблема - ветка `master` не обновлена до последних изменений. Это легко исправить."
"Единственная проблема - ветка `main` не обновлена до последних изменений. Это легко исправить."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -820,13 +891,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Вот мы выбрали ветку `master`. Вперёд - сделаем rebase на `bugFix`."
"Вот мы выбрали ветку `main`. Вперёд - сделаем rebase на `bugFix`."
],
"afterMarkdowns": [
"Вуаля! Так как `master` был предком `bugFix`, git просто сдвинул ссылку на `master` вперёд."
"Вуаля! Так как `main` был предком `bugFix`, git просто сдвинул ссылку на `main` вперёд."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -837,8 +908,8 @@ exports.level = {
"",
"* Переключись на ветку `bugFix`",
"* Сделай коммит",
"* Вернись на `master` и сделай коммит ещё раз",
"* Переключись на `bugFix` и сделай rebase на `master`",
"* Вернись на `main` и сделай коммит ещё раз",
"* Переключись на `bugFix` и сделай rebase на `main`",
"",
"Удачи!"
]
@ -868,18 +939,18 @@ exports.level = {
"beforeMarkdowns": [
"Ми знову маємо дві гілки; зауваж, що наразі вибрана гілка bugFix (вважай зірочку)",
"",
"Ми хочемо перемістити наші зміни з гілки bugFix прямо до змін з гілки master. Тоді це буде виглядати наче ці зміни були додані одна за одною, хоча насправді вони були додані одночасно.",
"Ми хочемо перемістити наші зміни з гілки bugFix прямо до змін з гілки main. Тоді це буде виглядати наче ці зміни були додані одна за одною, хоча насправді вони були додані одночасно.",
"",
"Давайте зробимо це за допомогою команди `git rebase`."
],
"afterMarkdowns": [
"Добре! Тепер зміни з гілки bugFix знаходяться прямо попереду змін з master й ми отримали зручну лінійну послідовність комітів.",
"Добре! Тепер зміни з гілки bugFix знаходяться прямо попереду змін з main й ми отримали зручну лінійну послідовність комітів.",
"",
"Вважай що коміт C3 досі десь існує (в дереві він тьмяніший за решту), й C3' це \"копія\" яку ми заребейсили в master.",
"Вважай що коміт C3 досі десь існує (в дереві він тьмяніший за решту), й C3' це \"копія\" яку ми заребейсили в main.",
"",
"Є лише одна проблема: гілка master також не була оновлена, давайте зробимо це наступним кроком..."
"Є лише одна проблема: гілка main також не була оновлена, давайте зробимо це наступним кроком..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -887,13 +958,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Тепер ми перейшли (checkout) до гілки `master`. Далі робимо rebase на `bugFix`..."
"Тепер ми перейшли (checkout) до гілки `main`. Далі робимо rebase на `bugFix`..."
],
"afterMarkdowns": [
"Вуаля! Так як `master` це предок `bugFix`, git просто просунув посилання гілки `master` вперед в історії."
"Вуаля! Так як `main` це предок `bugFix`, git просто просунув посилання гілки `main` вперед в історії."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -904,8 +975,8 @@ exports.level = {
"",
"* Зачекауть (checkout) новий бранч з назвою `bugFix`",
"* Зроби один коміт",
"* Повернись на master й зроби ще один коміт",
"* Зачекауть bugFix знову й заребейсь його на master",
"* Повернись на main й зроби ще один коміт",
"* Зачекауть bugFix знову й заребейсь його на main",
"",
"Нехай щастить!"
]
@ -935,18 +1006,18 @@ exports.level = {
"beforeMarkdowns": [
"Giờ ta lại có 2 nhánh; để ý rằng nhánh bugFix đang được chọn (thấy dấu hoa thị chứ?)",
"",
"Ta muốn chuyển bugFix trực tiếp sang master. Theo cách đó thì các chức năng nhìn có vẻ được phát triển tuần tự, trong khi thực tế chúng được phát triển song song.",
"Ta muốn chuyển bugFix trực tiếp sang main. Theo cách đó thì các chức năng nhìn có vẻ được phát triển tuần tự, trong khi thực tế chúng được phát triển song song.",
"",
"Dùng lệnh `git rebase` để thử nào"
],
"afterMarkdowns": [
"Tuyệt vời! Giờ thành quả của nhánh bugFix nằm ngay trên master và ta có các commit nằm thẳng tuột.",
"Tuyệt vời! Giờ thành quả của nhánh bugFix nằm ngay trên main và ta có các commit nằm thẳng tuột.",
"",
"Để ý rằng commit C3 vẫn nằm đâu đó (đã được làm mờ), và commit C3' là bản \"sao chép\" mà ta dán lên nhánh master.",
"Để ý rằng commit C3 vẫn nằm đâu đó (đã được làm mờ), và commit C3' là bản \"sao chép\" mà ta dán lên nhánh main.",
"",
"Vấn đề duy nhất bây giờ là nhánh master vẫn chưa được cập nhật, làm luôn cho nóng nào..."
"Vấn đề duy nhất bây giờ là nhánh main vẫn chưa được cập nhật, làm luôn cho nóng nào..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -954,13 +1025,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Giờ thì ta đã chuyển sang nhánh `master`. Tiếp tục dán nó vào `bugFix` nào..."
"Giờ thì ta đã chuyển sang nhánh `main`. Tiếp tục dán nó vào `bugFix` nào..."
],
"afterMarkdowns": [
"Đó! Bởi vì `master` là cha ông của `bugFix`, git đơn giản chuyển tham chiếu của nhánh `master` tiến lên."
"Đó! Bởi vì `main` là cha ông của `bugFix`, git đơn giản chuyển tham chiếu của nhánh `main` tiến lên."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -971,8 +1042,8 @@ exports.level = {
"",
"* Chuyển sang nhánh mới tên là `bugFix`",
"* Commit một lần",
"* Quay về master và commit lần nữa",
"* Quay trở lại bugFix và rebase sang master",
"* Quay về main và commit lần nữa",
"* Quay trở lại bugFix và rebase sang main",
"",
"Chúc may mắn!"
]
@ -1008,11 +1079,11 @@ exports.level = {
"afterMarkdowns": [
"Super! Sedaj je naše delo iz bugFix brancha na vrhu masterja in imamo lepo zaporedje commitov.",
"",
"Omenimo, da commit C3 še vedno obstaja nekje (v drevesu je zbledel), in C3' je v bistvu \"kopija\", ki smo jo rebaseali na master.",
"Omenimo, da commit C3 še vedno obstaja nekje (v drevesu je zbledel), in C3' je v bistvu \"kopija\", ki smo jo rebaseali na main.",
"",
"Edini problem je, da tudi master ni bil posodobljen, naredimo to sedaj ..."
"Edini problem je, da tudi main ni bil posodobljen, naredimo to sedaj ..."
],
"command": "git rebase master",
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
@ -1020,13 +1091,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Sedaj smo checkoutani na `master` branchu. Pojdimo in rebaseajmo na `bugFix`..."
"Sedaj smo checkoutani na `main` branchu. Pojdimo in rebaseajmo na `bugFix`..."
],
"afterMarkdowns": [
"Tako! Ker je bil `master` prednik `bugFix`, je git enostavno premaknil `master` branch referenco naprej v zgodovini."
"Tako! Ker je bil `main` prednik `bugFix`, je git enostavno premaknil `main` branch referenco naprej v zgodovini."
],
"command": "git rebase bugFix",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase master; git checkout master"
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit; git rebase main; git checkout main"
}
},
{
@ -1037,14 +1108,81 @@ exports.level = {
"",
"* Checkoutaj nov branch poimenovan `bugFix`",
"* Enkrat commitaj",
"* Pojdi nazaj na master in commitaj ponovno",
"* Ponovno checkoutaj bugFix in ga rebaseaj na master",
"* Pojdi nazaj na main in commitaj ponovno",
"* Ponovno checkoutaj bugFix in ga rebaseaj na main",
"",
"Srečno!"
]
}
}
]
},
"pl": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Git Rebase",
"",
"Drugim sposobem na łączenie naszej pracy między branch-ami jest *rebase*. Rebase zasadniczo pobiera zestaw commit-ów, \"kopiuje\" je i umieszcza w innym miejscu.",
"",
"Chociaż brzmi to zagmatwane, zaletą rebase jest to, że można jej użyć do stworzenia ładnej liniowej sekwencji zatwierdzeń. Rebase sprawi, że historia commit-ów w repozytorium będzie wyglądał na dużo prostszy, ponieważ unika się commit-ów scalających (merge).",
"",
"Zobaczmy to w akcji..."
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Tutaj znowu mamy dwa gałęzie (branch-e); zwróć uwagę, że branch bugFix jest aktualnie wybrany (zwróć uwagę, że ma gwiazdkę)",
"",
"Chcielibyśmy przenieść nasze pracę z branch-a bugFix bezpośrednio do branch-a main. W&nbsp;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`."
],
"afterMarkdowns": [
"Świetnie! Teraz nasz branch bugFix znajduje się tuż nad main i mamy ładną liniową sekwencję zatwierdzeń tj. commit-ów.",
"",
"Zauważ, że commit C3 nadal gdzieś istnieje (ma wyblakły wygląd w drzewie), a commit C3' jest \"kopią\", którą nadpisujemy na main.",
"",
"Jedynym problemem jest to, że main też nie został zaktualizowany, zróbmy to teraz..."
],
"command": "git rebase main",
"beforeCommand": "git commit; git checkout -b bugFix C1; git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Jesteśmy teraz na branch-u `main`. Przejdźmy dalej i zróbmy połączenie rebase z branch-em `bugFix`..."
],
"afterMarkdowns": [
"Oto jest! Ponieważ `main` był przodkiem `bugFix`, GIT po prostu przesunął odniesienie do branch-a `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"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Aby ukończyć ten poziom, wykonaj następujące czynności:",
"",
"* Przejdź do nowego utworzonego branch-u o nazwie `bugFix`",
"* Zrób commit",
"* Wróć do branch-a main i zrób kolejny commit",
"* Przejdź do bugFix oraz połącz za pomocą rebase z main",
"",
"Powodzenia, misja zakończona!"
]
}
}
]
}
}
};

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

@ -76,7 +76,7 @@ exports.level = {
"Let's look at a quick example. For this tree below:"
],
"afterMarkdowns": [
"The command `git describe master` would output:",
"The command `git describe main` would output:",
"",
"`v1_2_gC2`",
"",
@ -139,7 +139,7 @@ exports.level = {
"Regardons un petit exemple. Prenons cet arbre :"
],
"afterMarkdowns": [
"La commande`git describe master` donne le résultat :",
"La commande`git describe main` donne le résultat :",
"",
"`v1_2_gC2`",
"",
@ -202,7 +202,7 @@ exports.level = {
"讓我們來看一個例子，對於下面的 tree："
],
"afterMarkdowns": [
"`git describe master` 會輸出：",
"`git describe main` 會輸出：",
"",
"`v1_2_gC2`",
"",
@ -267,7 +267,7 @@ exports.level = {
"让我们来看一个例子，对于下面的提交树："
],
"afterMarkdowns": [
"`git describe master` 会输出：",
"`git describe main` 会输出：",
"",
"`v1_2_gC2`",
"",
@ -330,7 +330,7 @@ exports.level = {
"Veamos un ejemplo breve. Para este árbol de commits:"
],
"afterMarkdowns": [
"El comando `git describe master` mostraría:",
"El comando `git describe main` mostraría:",
"",
"`v1_2_gC2`",
"",
@ -393,7 +393,7 @@ exports.level = {
"Veamos un ejemplo breve. Para este árbol de commits:"
],
"afterMarkdowns": [
"El comando `git describe master` mostraría:",
"El comando `git describe main` mostraría:",
"",
"`v1_2_gC2`",
"",
@ -456,7 +456,7 @@ exports.level = {
"Vejamos um exemplo rápido. Para a árvore abaixo:"
],
"afterMarkdowns": [
"O comando `git describe master` daria a saída:",
"O comando `git describe main` daria a saída:",
"",
"`v1_2_gC2`",
"",
@ -519,7 +519,7 @@ exports.level = {
"Vexamos un exemplo rápido. Para a árbore de abaixo:"
],
"afterMarkdowns": [
"O comando `git describe master` daría a saída:",
"O comando `git describe main` daría a saída:",
"",
"`v1_2_gC2`",
"",
@ -551,9 +551,9 @@ exports.level = {
"markdowns": [
"### Git Describe",
"",
"Weil Tags so super als \"Anker\" im Repository dienen können bietet Git einen Befehl um zu *beschreiben* wo du dich relativ zum nächsten \"Anker\" (also Tag) befindest. Und der heißt `git describe`.",
"Weil Tags so super als \"Anker\" im Repository dienen können, bietet Git einen Befehl um zu *beschreiben*, wo du dich relativ zum nächsten \"Anker\" (also Tag) befindest. Und der heißt `git describe`.",
"",
"Er hilft dir dabei, dir einen Überblick zu verschaffen nachdem du viele Commits im Log zurück- oder vorgegangen bist; das kann vorkommen nachdem du ein `git bisect` (eine Fehlersuche) abgeschlossen hast oder wenn du dich an den Rechner eines Kollegen setzt, der gerade aus dem Urlaub gekommen ist."
"Er hilft dir dabei, dir einen Überblick zu verschaffen nachdem du viele Commits im Log zurück- oder vorgegangen bist; das kann vorkommen, nachdem du ein `git bisect` (eine Fehlersuche) abgeschlossen hast oder wenn du dich an den Rechner eines Kollegen setzt, der gerade aus dem Urlaub gekommen ist."
]
}
},
@ -565,7 +565,7 @@ exports.level = {
"",
"`git describe <Ref-Name>`",
"",
"Dabei ist `<Ref-Name>` jeder beliebige Name, der einem Commit zugeordnet ist (Branch, Tag etc). Wenn du keinen angibst benutzt Git `HEAD`, also den aktuellen Checkout.",
"Dabei ist `<Ref-Name>` jeder beliebige Name, der einem Commit zugeordnet ist (Branch, Tag etc). Wenn du keinen angibst, benutzt Git `HEAD`, also den aktuellen Checkout.",
"",
"Die Befehlsausgabe sieht so aus:",
"",
@ -573,7 +573,7 @@ exports.level = {
"",
"`<Tag-Name>` ist dabei der nächstliegende Tag in den Vorgänger-Commits, `<Anzahl Commits>` zeigt an, wieviele Commits dieses Tag entfernt ist und `<Hash>` ist das SHA des Commits, auf den HEAD zeigt.",
"",
"**Achtung**: `<Anzahl Commits>` und `<Hash>` erscheint nur, wenn HEAD nicht auf ein Tag zeigt. `git describe` verarbeitet standardmässig nur annotierte Tags. Um nicht annotierte tags zu sehen, verwende bitte`git describe --tags`."
"**Achtung**: `<Anzahl Commits>` und `<Hash>` erscheint nur, wenn HEAD nicht auf ein Tag zeigt. `git describe` verarbeitet standardmäßig nur annotierte Tags. Um nicht annotierte Tags zu sehen, verwende bitte `git describe --tags`."
]
}
},
@ -584,7 +584,7 @@ exports.level = {
"Schauen wir uns das schnell an einem Beispiel an. Für den folgenden Baum:"
],
"afterMarkdowns": [
"Der Befehl `git describe master` würde folgendes ausgeben:",
"Der Befehl `git describe main` würde folgendes ausgeben:",
"",
"`v1_2_gC2`",
"",
@ -647,7 +647,7 @@ exports.level = {
"軽い例を見てみましょう。この木においての例は以下のようになります:"
],
"afterMarkdowns": [
"コマンド`git describe master`の結果は以下のようになります:",
"コマンド`git describe main`の結果は以下のようになります:",
"",
"`v1_2_gC2`",
"",
@ -710,7 +710,7 @@ exports.level = {
"Посмотрим на простой пример. Для дерева, показанного ниже:"
],
"afterMarkdowns": [
"Команда `git describe master` выведет:",
"Команда `git describe main` выведет:",
"",
"`v1_2_gC2`",
"",
@ -773,7 +773,7 @@ exports.level = {
"간단한 예제를 확인해 봅시다. 아래의 트리에서:"
],
"afterMarkdowns": [
"`git describe master` 명령은 다음을 출력합니다:",
"`git describe main` 명령은 다음을 출력합니다:",
"",
"`v1_2_gC2`",
"",
@ -836,7 +836,7 @@ exports.level = {
"Розгляньмо короткий приклад. Для дерева нижче:"
],
"afterMarkdowns": [
"Команда `git describe master` виведе:",
"Команда `git describe main` виведе:",
"",
"`v1_2_gC2`",
"",
@ -899,7 +899,7 @@ exports.level = {
"Cùng xem nhanh một ví dụ trên cây lịch sử phía dưới:"
],
"afterMarkdowns": [
"Câu lệnh `git describe master` sẽ cho kết quả:",
"Câu lệnh `git describe main` sẽ cho kết quả:",
"",
"`v1_2_gC2`",
"",
@ -962,7 +962,7 @@ exports.level = {
"Poglejmo hiter primer. Za drevo spodaj:"
],
"afterMarkdowns": [
"Bi ukaz `git describe master` izpisal:",
"Bi ukaz `git describe main` izpisal:",
"",
"`v1_2_gC2`",
"",

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

@ -11,7 +11,7 @@ exports.level = {
"git revert": true
},
"goalTreeString": "%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C4%27%22%2C%22id%22%3A%22master%22%7D%2C%22debug%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22debug%22%7D%2C%22printf%22%3A%7B%22target%22%3A%22C3%22%2C%22id%22%3A%22printf%22%7D%2C%22bugFix%22%3A%7B%22target%22%3A%22C4%27%22%2C%22id%22%3A%22bugFix%22%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C2%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C4%22%3A%7B%22parents%22%3A%5B%22C3%22%5D%2C%22id%22%3A%22C4%22%7D%2C%22C4%27%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C4%27%22%7D%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%7D",
"solutionCommand": "git rebase -i master --solution-ordering C4; git rebase bugFix master",
"solutionCommand": "git rebase -i main --solution-ordering C4; git rebase bugFix main",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\"},\"debug\":{\"target\":\"C2\",\"id\":\"debug\"},\"printf\":{\"target\":\"C3\",\"id\":\"printf\"},\"bugFix\":{\"target\":\"C4\",\"id\":\"bugFix\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"}},\"HEAD\":{\"target\":\"bugFix\",\"id\":\"HEAD\"}}",
"name": {
"ko": "딱 한 개의 커밋만 가져오기",
@ -60,7 +60,7 @@ exports.level = {
"",
"All of these debugging / print statements are in their own commits. Finally I track down the bug, fix it, and rejoice!",
"",
"Only problem is that I now need to get my `bugFix` back into the `master` branch. If I simply fast-forwarded `master`, then `master` would get all my debug statements which is undesirable. There has to be another way..."
"Only problem is that I now need to get my `bugFix` back into the `main` branch. If I simply fast-forwarded `main`, then `main` would get all my debug statements which is undesirable. There has to be another way..."
]
}
},
@ -81,7 +81,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"This is a later level so we will leave it up to you to decide which command you want to use, but in order to complete the level, make sure `master` receives the commit that `bugFix` references."
"This is a later level so we will leave it up to you to decide which command you want to use, but in order to complete the level, make sure `main` receives the commit that `bugFix` references."
]
}
}
@ -99,7 +99,7 @@ exports.level = {
"",
"Tous ces debug se retrouvent dans une branche particulière. Je trouve le bug et le répare, comme toujours !",
"",
"Le seul problème c'est que je ne peux pas faire de merge ou rebase, car tous ces commits de debug seront dans le master. Il doit y avoir une autre façon..."
"Le seul problème c'est que je ne peux pas faire de merge ou rebase, car tous ces commits de debug seront dans le main. Il doit y avoir une autre façon..."
]
}
},
@ -118,7 +118,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"C'est un niveau avancé, donc à vous de choisir quelle commande utiliser, mais pour réussir ce niveau, assurez-vous que `master` reçoive le même commit que `bugFix` référence."
"C'est un niveau avancé, donc à vous de choisir quelle commande utiliser, mais pour réussir ce niveau, assurez-vous que `main` reçoive le même commit que `bugFix` référence."
]
}
}
@ -136,7 +136,7 @@ exports.level = {
"",
"Todas estas cosas de imprimir y debuggear estan en su propia rama. Finalmente encuentro el problema, lo soluciono, ¡y disfruto!",
"",
"El único problema es que ahora necesito llevar mi `bugFix` a la rama `master`. Si simplemente fast-forwardeo `master`, entonces `master` va a tener todos mis agregados de debugging, que es indeseado. Tiene que haber otro modo..."
"El único problema es que ahora necesito llevar mi `bugFix` a la rama `main`. Si simplemente fast-forwardeo `main`, entonces `main` va a tener todos mis agregados de debugging, que es indeseado. Tiene que haber otro modo..."
]
}
},
@ -157,7 +157,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Este es un nivel más avanzado, así que está en vos decidir cuál de los dos comandos querés usar, pero para completar el nivel asegurate de que `master` recibe el commit que `bugFix` referencia."
"Este es un nivel más avanzado, así que está en vos decidir cuál de los dos comandos querés usar, pero para completar el nivel asegurate de que `main` recibe el commit que `bugFix` referencia."
]
}
}
@ -175,7 +175,7 @@ exports.level = {
"",
"Todas estas cosas de imprimir y debuggear estan en su propia rama. Finalmente encuentro el problema, lo soluciono, ¡y disfruto!",
"",
"El único problema es que ahora necesito llevar mi `bugFix` a la rama `master`. Si simplemente fast-forwardeo `master`, entonces `master` va a tener todos mis agregados de debugging, lo cual no es deseable. Tiene que haber otro modo..."
"El único problema es que ahora necesito llevar mi `bugFix` a la rama `main`. Si simplemente fast-forwardeo `main`, entonces `main` va a tener todos mis agregados de debugging, lo cual no es deseable. Tiene que haber otro modo..."
]
}
},
@ -196,7 +196,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Este es un nivel más avanzado, así que debes decidir cuál de los dos comandos quieres usar, pero para completar el nivel asegurate de que `master` recibe el commit que `bugFix` referencia."
"Este es un nivel más avanzado, así que debes decidir cuál de los dos comandos quieres usar, pero para completar el nivel asegurate de que `main` recibe el commit que `bugFix` referencia."
]
}
}
@ -214,7 +214,7 @@ exports.level = {
"",
"Todos esses comandos de debug e mensagens estão em seus próprios ramos. Finalmente eu encontro o bug, corrijo, e me regozijo!",
"",
"O único problema é que agora eu preciso devolver o meu `bugFix` ao ramo `master`. Se eu simplesmente der um fast-forward no `master`, então o `master` terminará contendo todos os comandos de debug, o que é indesejável. Deve existir alguma outra forma..."
"O único problema é que agora eu preciso devolver o meu `bugFix` ao ramo `main`. Se eu simplesmente der um fast-forward no `main`, então o `main` terminará contendo todos os comandos de debug, o que é indesejável. Deve existir alguma outra forma..."
]
}
},
@ -235,7 +235,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Este é um nível avançado, então vamos deixar para você a decisão de qual comando usar, mas para completar este nível, certifique-se de que o `master` receba o commit referenciado por `bugFix`."
"Este é um nível avançado, então vamos deixar para você a decisão de qual comando usar, mas para completar este nível, certifique-se de que o `main` receba o commit referenciado por `bugFix`."
]
}
}
@ -253,7 +253,7 @@ exports.level = {
"",
"¡Todos esos comandos de debug e mensaxes están nas súas ramas propias. Finalmente eu atopo o erro, arránxoo e reorganizo!",
"",
"O único problema é que agora eu preciso devolver o meu `bugFix` á rama `master`. Se eu fixera simplemente un fast-forward en `master`, entón o `master` rematará contendo tódolos comandos de debug, o que é indesexable. Debe existir algunha outra forma..."
"O único problema é que agora eu preciso devolver o meu `bugFix` á rama `main`. Se eu fixera simplemente un fast-forward en `main`, entón o `main` rematará contendo tódolos comandos de debug, o que é indesexable. Debe existir algunha outra forma..."
]
}
},
@ -274,7 +274,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Este é un nivel avanzado, entón imos deixarche a decisión de qué comando empregar, pero para completar este nivel, asegurate de que a rama `master` colla o commit referenciado por `bugFix`."
"Este é un nivel avanzado, entón imos deixarche a decisión de qué comando empregar, pero para completar este nivel, asegurate de que a rama `main` colla o commit referenciado por `bugFix`."
]
}
}
@ -288,11 +288,11 @@ exports.level = {
"markdowns": [
"## Lokale Commit-Haufen",
"",
"Folgende Situation habe ich beim Entwickeln des öfteren: ich bin auf der Suche nach einem Bug, aber er ist echt schwer zu finden. Um ihm auf die Spur zu kommen schreibe ich mehrere Debug-Kommandos und print-Befehle in den Code.",
"Folgende Situation habe ich beim Entwickeln des Öfteren: ich bin auf der Suche nach einem Bug, aber er ist echt schwer zu finden. Um ihm auf die Spur zu kommen schreibe ich mehrere Debug-Kommandos und print-Befehle in den Code.",
"",
"Die committe ich auch immer wieder, je weiter die Suche mich trägt; natürlich in einem lokalen Branch. Schließlich finde ich den Bug, fixe ihn und freue mich!",
"",
"Einziges Problem ist, dass ich diesen `bugFix` jetzt zurück in den `master` kriegen muss. Wenn ich einfach den `master` vorspule oder meinen Branch hinein merge, bekäme der `master` auch die ganzen Debug-Befehle, was nicht gewünscht ist. Das muss anders gehen ..."
"Einziges Problem ist, dass ich diesen `bugFix` jetzt zurück in den `main` kriegen muss. Wenn ich einfach den `main` vorspule oder meinen Branch hinein merge, bekäme der `main` auch die ganzen Debug-Befehle, was nicht gewünscht ist. Das muss anders gehen ..."
]
}
},
@ -312,7 +312,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Da dies ein späterer Level ist überlasse ich es dir zu entscheiden, welchen Befehl du benutzen willst. Aber um da Level zu schaffen musst du irgendwie sicherstellen, dass `master` den Commit bekommt, auf den `bugFix` zeigt."
"Da dies ein späterer Level ist überlasse ich es dir zu entscheiden, welchen Befehl du benutzen willst. Aber um das Level zu schaffen musst du irgendwie sicherstellen, dass `main` den Commit bekommt, auf den `bugFix` zeigt."
]
}
}
@ -331,7 +331,7 @@ exports.level = {
"",
"これらのデバッグ用のコードはバグ修正用のブランチにコミットされています。そしてついにバグの原因を突き止めて、修正した！やった！",
"",
"あとは`bugFix`ブランチを`master`ブランチに統合できればOK。そこで単純に`master`をfast-forwardすればよいかというと、それでは`master`ブランチの中にデバッグ用のコードも混入してしまいます。"
"あとは`bugFix`ブランチを`main`ブランチに統合できればOK。そこで単純に`main`をfast-forwardすればよいかというと、それでは`main`ブランチの中にデバッグ用のコードも混入してしまいます。"
]
}
},
@ -354,7 +354,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"後半の章ですのでどう解決するかをもう自分で考えることができると思います。このレベルをクリアするためには、`bugFix`が持っているコミットを`master`ブランチが受け取る必要がある点には注意してください。"
"後半の章ですのでどう解決するかをもう自分で考えることができると思います。このレベルをクリアするためには、`bugFix`が持っているコミットを`main`ブランチが受け取る必要がある点には注意してください。"
]
}
}
@ -372,7 +372,7 @@ exports.level = {
"",
"这些调试和打印语句都在它们各自的提交记录里。最后我终于找到了造成这个 Bug 的根本原因，解决掉以后觉得沾沾自喜！",
"",
"最后就差把 `bugFix` 分支里的工作合并回 `master` 分支了。你可以选择通过 fast-forward 快速合并到 `master` 分支上，但这样的话 `master` 分支就会包含我这些调试语句了。你肯定不想这样，应该还有更好的方式……"
"最后就差把 `bugFix` 分支里的工作合并回 `main` 分支了。你可以选择通过 fast-forward 快速合并到 `main` 分支上，但这样的话 `main` 分支就会包含我这些调试语句了。你肯定不想这样，应该还有更好的方式……"
]
}
},
@ -393,7 +393,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"由于我们刚刚闯过类似的关卡，所以要不要再尝试一次就看你自己了。但是如果你想试一把的话，确保 `master` 分支能得到 `bugFix` 分支上的相关提交。"
"由于我们刚刚闯过类似的关卡，所以要不要再尝试一次就看你自己了。但是如果你想试一把的话，确保 `main` 分支能得到 `bugFix` 分支上的相关提交。"
]
}
}
@ -411,7 +411,7 @@ exports.level = {
"",
"所有的這些 debug 的指令都只在 `bugFix` 這個 branch 裡面。最後我終於找到這個 bug，並且 fix 掉它，接著撒花慶祝一下！",
"",
"現在唯一的問題就是要把我在 `bugFix` branch 裡面所做的修改 merge 回 `master` branch。我可以簡單地透過 fast-forward 來 merge ，但這樣的話 `master` branch 就會包含這些含有 debug 指令的 commit 了。我相信一定有其它方法..."
"現在唯一的問題就是要把我在 `bugFix` branch 裡面所做的修改 merge 回 `main` branch。我可以簡單地透過 fast-forward 來 merge ，但這樣的話 `main` branch 就會包含這些含有 debug 指令的 commit 了。我相信一定有其它方法..."
]
}
},
@ -432,7 +432,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"這一個關卡是比較後面的關卡，你可以隨意決定你要選擇使用哪個指令，但是 `bugFix` 所指向的那個 commit 一定要可以被 `master` branch 包含到。"
"這一個關卡是比較後面的關卡，你可以隨意決定你要選擇使用哪個指令，但是 `bugFix` 所指向的那個 commit 一定要可以被 `main` branch 包含到。"
]
}
}
@ -450,7 +450,7 @@ exports.level = {
"",
"디버깅용 코드나 프린트 명령은 그 브랜치에 들어있습니다. 마침내 버그를 찾아서 고쳤고, 원래 작업하는 브랜치에 합치면 됩니다!",
"",
"이제 `bugFix`브랜치의 내용을 `master`에 합쳐 넣으려 하지만, 한 가지 문제가 있습니다. 그냥 간단히 `master`브랜치를 최신 커밋으로 이동시킨다면(fast-forward) 그 불필요한 디버그용 코드들도 함께 들어가 버린다는 문제죠."
"이제 `bugFix`브랜치의 내용을 `main`에 합쳐 넣으려 하지만, 한 가지 문제가 있습니다. 그냥 간단히 `main`브랜치를 최신 커밋으로 이동시킨다면(fast-forward) 그 불필요한 디버그용 코드들도 함께 들어가 버린다는 문제죠."
]
}
},
@ -473,7 +473,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"이번 레벨을 통과하기 위해 어떤 방법을 쓰시든 자유입니다만, `master`브랜치가 `bugFix` 브랜치의 커밋을 일부 가져오게 해주세요."
"이번 레벨을 통과하기 위해 어떤 방법을 쓰시든 자유입니다만, `main`브랜치가 `bugFix` 브랜치의 커밋을 일부 가져오게 해주세요."
]
}
}
@ -489,7 +489,7 @@ exports.level = {
"",
"Каждая отладочная команда (команды) вывода находится в своём коммите. В итоге мы нашли ошибку, исправили её и порадовались!",
"",
"Но проблема в том, что мы хотим добавить в `master` только исправление ошибки из ветки `bugFix`. Если мы воспользуемся простым fast-forward, то в `master` попадут также отладочные команды. Должен быть другой способ..."
"Но проблема в том, что мы хотим добавить в `main` только исправление ошибки из ветки `bugFix`. Если мы воспользуемся простым fast-forward, то в `main` попадут также отладочные команды. Должен быть другой способ..."
]
}
},
@ -528,7 +528,7 @@ exports.level = {
"",
"Всі ці команди для відлагодження та виводу данних знаходяться в своїх власних комітах. Врешті-решт я знаходжу баг, фікшу його та щиро радію!",
"",
"От тільки лишається проблема, що потрібно мій фікс перенести з `bugFix` назад в гілку `master`. Якщо я просто зроблю фастфорвард (fast-forwarded) в `master`, тоді в `master` потраплять всі мої println'и, що є зайвим. Має бути інший шлях..."
"От тільки лишається проблема, що потрібно мій фікс перенести з `bugFix` назад в гілку `main`. Якщо я просто зроблю фастфорвард (fast-forwarded) в `main`, тоді в `main` потраплять всі мої println'и, що є зайвим. Має бути інший шлях..."
]
}
},
@ -549,7 +549,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"На цьому рівні тобі вирішувати якими командами користуватися, але щоб пройти цей рівень, впевнись що в `master` потрапить коміт, на який посилається `bugFix`."
"На цьому рівні тобі вирішувати якими командами користуватися, але щоб пройти цей рівень, впевнись що в `main` потрапить коміт, на який посилається `bugFix`."
]
}
}
@ -567,7 +567,7 @@ exports.level = {
"",
"Mấy lệnh gỡ lỗi và in này nằm yên trong commit của chúng. Cuối cùng thì tôi cũng tìm ra lỗi, gỡ xong, ngon rồi!",
"",
"Bây giờ thì lại phải đưa `bugFix` trở về nhánh `master`. Nếu mà đơn giản dùng fast-forwarded lên `master`, thì `master` lại có tất cả các lệnh gỡ lỗi kia(chẳng muốn chút nào). Phải có cách khác chứ nhỉ..."
"Bây giờ thì lại phải đưa `bugFix` trở về nhánh `main`. Nếu mà đơn giản dùng fast-forwarded lên `main`, thì `main` lại có tất cả các lệnh gỡ lỗi kia(chẳng muốn chút nào). Phải có cách khác chứ nhỉ..."
]
}
},
@ -588,7 +588,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Bây giờ là cấp độ cao hơn rồi nên bạn hãy tự quyết định nên dùng câu lệnh nào, nhưng để hoàn thành được cấp độ, hãy đàm bảo rằng `master` nhận được commit mà `bugFix` tham chiếu tới."
"Bây giờ là cấp độ cao hơn rồi nên bạn hãy tự quyết định nên dùng câu lệnh nào, nhưng để hoàn thành được cấp độ, hãy đàm bảo rằng `main` nhận được commit mà `bugFix` tham chiếu tới."
]
}
}
@ -606,7 +606,7 @@ exports.level = {
"",
"Vsi te ukazi za debuggiranje / izpisovanje so v svojih commitih. Končno odkrijem bug, ga popravim in se veselim!",
"",
"Edini problem je, da morem sedaj spraviti moj `bugFix` nazaj v `master` branch. Če uporabim samo fast-forward na `masterju`, potem bi `master` vseboval vse moje debug vrstice, česar si ne želim. Mora obstajati še neka druga pot ..."
"Edini problem je, da morem sedaj spraviti moj `bugFix` nazaj v `main` branch. Če uporabim samo fast-forward na `masterju`, potem bi `main` vseboval vse moje debug vrstice, česar si ne želim. Mora obstajati še neka druga pot ..."
]
}
},
@ -627,7 +627,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Tebi prepuščam, da se odločiš, kateri ukaz boš uporabil, da končaš stopnjo. Poskrbi samo, da `master` dobi commit na katerega kaže `bugFix` referenca."
"Tebi prepuščam, da se odločiš, kateri ukaz boš uporabil, da končaš stopnjo. Poskrbi samo, da `main` dobi commit na katerega kaže `bugFix` referenca."
]
}
}

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

@ -15,7 +15,7 @@ exports.level = {
]
},
"goalTreeString": "%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C3%27%27%22%2C%22id%22%3A%22master%22%7D%2C%22newImage%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22newImage%22%7D%2C%22caption%22%3A%7B%22target%22%3A%22C3%27%27%22%2C%22id%22%3A%22caption%22%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C2%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C3%27%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%27%22%7D%2C%22C2%27%22%3A%7B%22parents%22%3A%5B%22C3%27%22%5D%2C%22id%22%3A%22C2%27%22%7D%2C%22C2%27%27%22%3A%7B%22parents%22%3A%5B%22C3%27%22%5D%2C%22id%22%3A%22C2%27%27%22%7D%2C%22C2%27%27%27%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%27%27%27%22%7D%2C%22C3%27%27%22%3A%7B%22parents%22%3A%5B%22C2%27%27%27%22%5D%2C%22id%22%3A%22C3%27%27%22%7D%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%7D",
"solutionCommand": "git rebase -i HEAD~2 --solution-ordering C3,C2;git commit --amend;git rebase -i HEAD~2 --solution-ordering C2'',C3';git rebase caption master",
"solutionCommand": "git rebase -i HEAD~2 --solution-ordering C3,C2;git commit --amend;git rebase -i HEAD~2 --solution-ordering C2'',C3';git rebase caption main",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\"},\"newImage\":{\"target\":\"C2\",\"id\":\"newImage\"},\"caption\":{\"target\":\"C3\",\"id\":\"caption\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"}},\"HEAD\":{\"target\":\"caption\",\"id\":\"HEAD\"}}",
"name": {
"ko": "커밋들 갖고 놀기",
@ -75,12 +75,12 @@ exports.level = {
"* We will re-order the commits so the one we want to change is on top with `git rebase -i`",
"* We will `git commit --amend` to make the slight modification",
"* Then we will re-order the commits back to how they were previously with `git rebase -i`",
"* Finally, we will move master to this updated part of the tree to finish the level (via the method of your choosing)",
"* Finally, we will move main to this updated part of the tree to finish the level (via the method of your choosing)",
"",
"There are many ways to accomplish this overall goal (I see you eye-ing cherry-pick), and we will see more of them later, but for now let's focus on this technique.",
"Lastly, pay attention to the goal state here -- since we move the commits twice, they both get an apostrophe appended. One more apostrophe is added for the commit we amend, which gives us the final form of the tree ",
"",
"That being said, I can compare levels now based on structure and relative apostrophe differences. As long as your tree's `master` branch has the same structure and relative apostrophe differences, I'll give full credit."
"That being said, I can compare levels now based on structure and relative apostrophe differences. As long as your tree's `main` branch has the same structure and relative apostrophe differences, I'll give full credit."
]
}
}
@ -109,13 +109,13 @@ exports.level = {
"* Nous allons réordonner les commits pour que celui que nous voulions changer soit sur le dessus `git rebase -i`",
"* Nous allons utiliser `git commit --amend` pour faire les petites modifications",
"* Nous allons réordonner les commits dans l'ordre original avec `git rebase -i`",
"* Finalement, nous allons déplacer master vers la nouvelle tête de l'arbre (avec la méthode de votre choix)",
"* Finalement, nous allons déplacer main vers la nouvelle tête de l'arbre (avec la méthode de votre choix)",
"",
"Il y a plusieurs façons d'atteindre ce but (cherry-pick semble très tentant), mais nous allons parler de cherry-pick plus tard, pour le moment concentrez-vous sur cette technique.",
"",
"Pour terminer, Faites attention au but -- Dû au fait que nous déplaçons les commits 2 fois, ils se retrouvent tous les deux avec une apostrophe. Une deuxième apostrophe est ajoutée sur le commit que nous modifions, ce qui nous donne la forme finale de l'arbre.",
"",
"Ceci étant dit, je peux comparer le résultat avec la structure et les différentes apostrophes. Tant que votre arbre `master` a la même structure et les différentes apostrophes le niveau sera considéré réussi."
"Ceci étant dit, je peux comparer le résultat avec la structure et les différentes apostrophes. Tant que votre arbre `main` a la même structure et les différentes apostrophes le niveau sera considéré réussi."
]
}
},
@ -144,13 +144,13 @@ exports.level = {
"* Vamos a reordenar los commits para que el que queremos cambiar quede arriba de todo con `git rebase -i`",
"* Vamos a hacer `git commit --amend` para aplicar la ligera modificación",
"* Después vamos a reordenar los commits a como estaban con `git rebase -i`",
"* Finalmente, vamos a mover master a esta parte actualizada de nuestro árbol de commits para terminar el nivel (usando el método que prefieras)",
"* Finalmente, vamos a mover main a esta parte actualizada de nuestro árbol de commits para terminar el nivel (usando el método que prefieras)",
"",
"Hay varias maneras de lograr este objetivo en general (ya te veo haciéndole ojitos al cherry-pick), y veremos algunos más después, pero por ahora concentrémonos en esta técnica.",
"",
"Por último, prestá atención al estado final acá -- como movemos los commits dos veces, ambos quedan con un apóstrofe. El commit que corregimos tiene un apóstrofe extra, y así nos queda nuestro árbol final",
"",
"Habiendo dicho eso, puedo comparar los niveles basándome ahora en la estructura y las diferencias relativas de apóstrofes. Mientras que tu rama `master` tenga la misma estructura y diferencias relativas de apóstrofes, te voy a dar el puntaje completo."
"Habiendo dicho eso, puedo comparar los niveles basándome ahora en la estructura y las diferencias relativas de apóstrofes. Mientras que tu rama `main` tenga la misma estructura y diferencias relativas de apóstrofes, te voy a dar el puntaje completo."
]
}
},
@ -179,13 +179,13 @@ exports.level = {
"* Vamos a reordenar los commits para que el que queremos cambiar quede arriba de los demás con `git rebase -i`",
"* Vamos a hacer `git commit --amend` para aplicar la ligera modificación",
"* Después vamos a reordenar los commits a como estaban con `git rebase -i`",
"* Finalmente, vamos a mover master a esta parte actualizada de nuestro árbol de commits para terminar el nivel (usando el método que prefieras)",
"* Finalmente, vamos a mover main a esta parte actualizada de nuestro árbol de commits para terminar el nivel (usando el método que prefieras)",
"",
"Hay varias maneras de lograr este objetivo en general (ya te veo haciéndole ojitos al cherry-pick), y veremos algunos más después, pero por ahora concentrémonos en esta técnica.",
"",
"Por último, presta atención al estado final -- como movemos los commits dos veces, ambos quedan con un apóstrofe. El commit que corregimos tiene un apóstrofe extra, y así nos queda nuestro árbol final",
"",
"Habiendo dicho eso, puedo comparar los niveles basándome ahora en la estructura y las diferencias relativas de apóstrofes. Mientras que tu rama `master` tenga la misma estructura y diferencias relativas de apóstrofes, te voy a dar el puntaje completo."
"Habiendo dicho eso, puedo comparar los niveles basándome ahora en la estructura y las diferencias relativas de apóstrofes. Mientras que tu rama `main` tenga la misma estructura y diferencias relativas de apóstrofes, te voy a dar el puntaje completo."
]
}
},
@ -214,13 +214,13 @@ exports.level = {
"* Reordenaremos os commits de forma que aquele que desejamos esteja no topo, com `git rebase -i`",
"* Usaremos o comando `git commit --amend` para fazer uma pequena modificação",
"* Vamos, então, reordenar os commits na mesma ordem que estavam anteriormente com `git rebase -i`",
"* Finalmente, moveremos o master para essa parte atualizada da árvore para finalizar o nível (usando o método de sua escolha)",
"* Finalmente, moveremos o main para essa parte atualizada da árvore para finalizar o nível (usando o método de sua escolha)",
"",
"Há muitas formas de alcançar o objetivo final (eu vejo o cherry-pick passando pela sua mente), e veremos mais delas depois, mas por enquanto foquemos nesta técnica.",
"",
"Por último, preste atenção no estado do \"objetivo\" aqui -- como nós movemos os commits duas vezes, ambos ficam com um apóstrofo. Um apóstrofo adicional é colocado no commit que sofreu o \"amend\", o que nos dá a forma final da árvore ",
"",
"Tendo dito isto, posso avaliar a resposta baseado na estrutura e nas diferenças relativas de número de apóstrofos. Desde que o ramo `master` da sua árvore tenha a mesma estrutura, e o número de apóstrofos seja igual a menos de uma constante, darei a você todos os pontos para esta tarefa."
"Tendo dito isto, posso avaliar a resposta baseado na estrutura e nas diferenças relativas de número de apóstrofos. Desde que o ramo `main` da sua árvore tenha a mesma estrutura, e o número de apóstrofos seja igual a menos de uma constante, darei a você todos os pontos para esta tarefa."
]
}
},
@ -249,13 +249,13 @@ exports.level = {
"* Reordenaremos os commits seleccionando aqueles que desexamos que estén no cambio, con `git rebase -i`",
"* Empregaremos o comando `git commit --amend` para facer unha pequena modificación",
"* Imos, entón, reordear os commits na mesma orde na que estaban anteriormente con `git rebase -i`",
"* Finalmente, moveremos o master para esa parte atualizada da árbore e así finalizar o nivel (usando o método que máis che pete)",
"* Finalmente, moveremos o main para esa parte atualizada da árbore e así finalizar o nivel (usando o método que máis che pete)",
"",
"Hai moitas formas de obter o obxectivo final (eu vexo o cherry-pick pasando pola túa cachola), e verémolo máis adiante, pero agora ímonos centrar nesta técnica.",
"",
"Por último, preste atención no estado do \"objectivo\" aquí -- como movemos os commits dúas veces, ambos teñen o apóstrofo sumado. O apóstrofo engádese polo commit que nos correximos (amend), o cal danos a forma final da árbore.",
"",
"Contado todo esto, a resposta valídase baseándose na estructura e nos diferentes apóstrofes. Cando a rama `master` teña a mesma estructura, e o número de apóstrofos sexa igual, obterás todos os puntos da tarefa."
"Contado todo esto, a resposta valídase baseándose na estructura e nos diferentes apóstrofes. Cando a rama `main` teña a mesma estructura, e o número de apóstrofos sexa igual, obterás todos os puntos da tarefa."
]
}
},
@ -281,16 +281,16 @@ exports.level = {
"markdowns": [
"Um das zu schaffen gehen wir wie folgt vor:",
"",
"* Wir sortieren die Commits mit `git rebase -i` so um, dass der, den wir ändern wollen, ganz oben liegt.",
"* Wir sortieren die Commits mit `git rebase -i` so um, dass der Commit, den wir ändern wollen, ganz oben liegt.",
"* Wir verändern den Commit mit `git commit --amend`.",
"* Dann sortieren wir die Commit mit einem erneuten `git rebase -i` wieder in die alte Reihenfolge.",
"* Schließlich aktualisieren wir den `master` auf das Ende unseres fertigen Baums, um diesen Level abzuschließen.",
"* Dann sortieren wir die Commits mit einem erneuten `git rebase -i` wieder in die alte Reihenfolge.",
"* Schließlich aktualisieren wir den `main` auf das Ende unseres fertigen Baums, um diesen Level abzuschließen.",
"",
"Es gibt sehr viele Wege um das Endziel dieses Levels zu erreichen (ich sehe, du schielst auf `cherry-pick`) und wir werden uns später noch andere ansehen. Aber für's erste lass uns diese Methode ausprobieren.",
"",
"Beachte den geschilderten Zielzustand. Da wir die Commits zweimal umsortieren bekommen sie jedesmal ein Apostroph hinzugefügt (weil sie jedesmal kopiert werden). Ein weiteres Apostroph entsteht durch den `git commit --amend`.",
"Beachte den geschilderten Zielzustand. Da wir die Commits zweimal umsortieren, bekommen sie jedes Mal ein Apostroph hinzugefügt (weil sie jedes Mal kopiert werden). Ein weiteres Apostroph entsteht durch den `git commit --amend`.",
"",
"Zuguterletzt noch eine Bemerkung: ich kann Level nur auf Struktur und Apostroph-Differenz prüfen. So lange wie dein `master` am Ende dieselbe Struktur und Apostroph-Differenz aufweist wie der Ziel-`master`, ist der Level bestanden."
"Zuguterletzt noch eine Bemerkung: ich kann Level nur auf Struktur und Apostroph-Differenz prüfen. So lange wie dein `main` am Ende dieselbe Struktur und Apostroph-Differenz aufweist wie der Ziel-`main`, ist der Level bestanden."
]
}
},
@ -352,12 +352,12 @@ exports.level = {
"* 先用 `git rebase -i` 将提交重新排序，然后把我们想要修改的提交记录挪到最前",
"* 然后用 `git commit --amend` 来进行一些小修改",
"* 接着再用 `git rebase -i` 来将他们调回原来的顺序",
"* 最后我们把 master 移到修改的最前端（用你自己喜欢的方法），就大功告成啦！",
"* 最后我们把 main 移到修改的最前端（用你自己喜欢的方法），就大功告成啦！",
"",
"当然完成这个任务的方法不止上面提到的一种（我知道你在看 cherry-pick 啦），之后我们会多点关注这些技巧啦，但现在暂时只专注上面这种方法。",
"最后有必要说明一下目标状态中的那几个`'` —— 我们把这个提交移动了两次，每移动一次会产生一个 `'`；而 C2 上多出来的那个是我们在使用了 amend 参数提交时产生的，所以最终结果就是这样了。",
"",
"也就是说，我在对比结果的时候只会对比提交树的结构，对于 `'` 的数量上的不同，并不纳入对比范围内。只要你的 `master` 分支结构与目标结构相同，我就算你通过。"
"也就是说，我在对比结果的时候只会对比提交树的结构，对于 `'` 的数量上的不同，并不纳入对比范围内。只要你的 `main` 分支结构与目标结构相同，我就算你通过。"
]
}
}
@ -386,7 +386,7 @@ exports.level = {
"* 先用 `git rebase -i` 將 commit 重新排序，然後把我們想要修改的 commit 移到最前面",
"* 然後用 `git commit --amend` 來進行一些修改",
"* 接著再用 `git rebase -i` 來將他們按照最開始的順序重新排好",
"* 最後我們把 master 移到這個修改的最前端（用你自己喜歡的方法），就大功告成啦！",
"* 最後我們把 main 移到這個修改的最前端（用你自己喜歡的方法），就大功告成啦！",
"",
"當然還有許多方法可以完成這個任務（我知道你在想 cherry-pick 啦），之後我們會多點關注這些技巧啦，但現在暫時只注意上面這種方法。",
"",
@ -419,7 +419,7 @@ exports.level = {
"* `git rebase -i` 명령으로 우리가 바꿀 커밋을 가장 최근 순서로 바꾸어 놓습니다",
"* `git commit --amend` 명령으로 커밋 내용을 정정합니다",
"* 다시 `git rebase -i` 명령으로 이 전의 커밋 순서대로 되돌려 놓습니다",
"* 마지막으로, master를 지금 트리가 변경된 부분으로 이동합니다. (편하신 방법으로 하세요)",
"* 마지막으로, main을 지금 트리가 변경된 부분으로 이동합니다. (편하신 방법으로 하세요)",
"",
"이 목표를 달성하기 위해서는 많은 방법이 있는데요(체리픽을 고민중이시죠?), 체리픽은 나중에 더 살펴보기로 하고, 우선은 위의 방법으로 해결해보세요.",
"",
@ -452,7 +452,7 @@ exports.level = {
"* Переставить коммит так, чтобы нужный находился наверху при помощи `git rebase -i`",
"* Внести изменения при помощи `git commit --amend`",
"* Переставить всё обратно при помощи `git rebase -i`",
"* И наконец, переместить master на изменённую часть дерева, чтобы закончить уровень.",
"* И наконец, переместить main на изменённую часть дерева, чтобы закончить уровень.",
"",
"Это задание можно выполнить несколькими способами (и, гляжу, ты посматриваешь на cherry-picking), но сейчас сосредоточься на вышеописанном методе.",
"",
@ -487,12 +487,12 @@ exports.level = {
"* Ми відсортуємо коміти таким чином, щоб той, який ми хочемо змінити, був останнім за допомогою `git rebase -i`",
"* Ми виконаємо `git commit --amend` щоб внести невелику правку до останнього коміту",
"* Тоді ми відсортуємо коміти в попередньому порядку, за допомогою `git rebase -i`",
"* І на останок, ми пересунемо master на змінену частину дерева щоб закінчити цей рівень(ти можеш вибрати метод)",
"* І на останок, ми пересунемо main на змінену частину дерева щоб закінчити цей рівень(ти можеш вибрати метод)",
"",
"Насправді є кілька способів як виконати поставлену задачу (Я бачу, ти поглядаєш на cherry-pick), і ми розберемося з ними всіма трохи пізніше, але зараз скористаймося саме цим методом.",
"Зверни увагу на фінальний стан в цьому рівні -- позаяк ми перемістили коміти двічі, кожен з них отримає по апострофу. Ще один апостроф додасться коли ми виконаємо commit --amend.",
"",
"Враховуючи сказане вище, я буду порівнювати дерево як за назвою коміта, так і за кількістю апострофів. Щойно дерево цілей та master співпадуть, ти пройдеш цей рівень."
"Враховуючи сказане вище, я буду порівнювати дерево як за назвою коміта, так і за кількістю апострофів. Щойно дерево цілей та main співпадуть, ти пройдеш цей рівень."
]
}
}
@ -521,12 +521,12 @@ exports.level = {
"* Ta sẽ dùng `git rebase -i` sắp xếp lại commit để cái ta cần sửa sẽ nằm trên cùng",
"* Ta sẽ dùng `git commit --amend` tạo ra một điều chỉnh nhỏ",
"* Sau đó ta sẽ lại sắp xếp lại commit như trước bằng cách dùng `git rebase -i`",
"* Cuối cùng, ta sẽ chuyển `master` tới phần đã cập nhật để hoàn thành cấp độ (dùng cách nào tùy bạn)",
"* Cuối cùng, ta sẽ chuyển `main` tới phần đã cập nhật để hoàn thành cấp độ (dùng cách nào tùy bạn)",
"",
"Có nhiều cách để hoàn thành mục tiêu (Tôi thấy bạn hấp háy sang cherry-pick rồi đấy), rồi ta sẽ thấy chúng nhiều hơn, nhưng giờ hãy cứ tập trung vào kỹ thuật này đã.",
"Sau cùng thì, để ý các dấu nháy đơn(') chứ?-- vì ta đã chuyển commit 2 lần, nên chúng có thêm một dấu nháy đơn. Và một dấu nữa cho commit mà ta đã sửa đổi, thế là ta có trạng thái cuối cùng của cây lịch sử ",
"",
"Nói cách khác, khi tôi so sánh kết quả, tôi chỉ so sánh cấu trúc của cây lịch sử. Sự khác biệt về số lượng `'` không được bao gồm trong so sánh. Miễn là cấu trúc nhánh `master` của bạn giống với cấu trúc đích, tôi sẽ vẫn để bạn qua bài."
"Nói cách khác, khi tôi so sánh kết quả, tôi chỉ so sánh cấu trúc của cây lịch sử. Sự khác biệt về số lượng `'` không được bao gồm trong so sánh. Miễn là cấu trúc nhánh `main` của bạn giống với cấu trúc đích, tôi sẽ vẫn để bạn qua bài."
]
}
}
@ -555,12 +555,12 @@ exports.level = {
"* Preuredili bomo commite tako, da bo tisti, ki ga želimo spremeniti, na vrhu z `git rebase -i`",
"* Izvedli bomo `git commit --amend`, da naredimo naš popravek",
"* Nato bomo preuredili commite nazaj v začetno stanje z `git rebase -i`",
"* Za konec bomo premaknili master na ta posodobljen del drevesa, da zaključimo stopnjo (z metodo po tvoji izbiri)",
"* Za konec bomo premaknili main na ta posodobljen del drevesa, da zaključimo stopnjo (z metodo po tvoji izbiri)",
"",
"Obstaja več načinov, da dosežemo ta cilj (vidim te kako gledaš cherry-pick) s katerimi se bomo ukvarjali kasneje, ampak za zdaj se osredotočimo na to tehniko.",
"In nenazadnje, bodi pozoren na ciljno stanje -- ker premaknemo commit dvakrat, oba dobita pripet opuščaj zgoraj. Še eden je dodan za ammendan commit, torej skupno tri.",
"",
"Sedaj lahko primerjam stopnje po strukturi in relativni spremembi opuščajev. Dokler ima `master` branch na tvojem drevesu enako strukturo in število opuščajev, dobiš vse točke."
"Sedaj lahko primerjam stopnje po strukturi in relativni spremembi opuščajev. Dokler ima `main` branch na tvojem drevesu enako strukturo in število opuščajev, dobiš vse točke."
]
}
}

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

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C3%27%22%2C%22id%22%3A%22master%22%7D%2C%22newImage%22%3A%7B%22target%22%3A%22C2%22%2C%22id%22%3A%22newImage%22%7D%2C%22caption%22%3A%7B%22target%22%3A%22C3%22%2C%22id%22%3A%22caption%22%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C2%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C2%27%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%27%22%7D%2C%22C2%27%27%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%27%27%22%7D%2C%22C3%27%22%3A%7B%22parents%22%3A%5B%22C2%27%27%22%5D%2C%22id%22%3A%22C3%27%22%7D%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%7D",
"solutionCommand": "git checkout master;git cherry-pick C2;git commit --amend;git cherry-pick C3",
"solutionCommand": "git checkout main;git cherry-pick C2;git commit --amend;git cherry-pick C3",
"disabledMap": {
"git revert": true
},
@ -34,21 +34,21 @@ exports.level = {
"sl_SI": "Žongliranje s Commiti #2"
},
"hint": {
"en_US": "Don't forget to forward master to the updated changes!",
"fr_FR": "N'oubliez pas d'appliquer les changements depuis la branche master",
"es_AR": "¡No te olvides de avanzar master a los cambios actualizados!",
"es_ES": "¡No te olvides de avanzar master a los cambios actualizados!",
"pt_BR": "Não se esqueça de avançar a referência do master para as mudanças efetuadas!",
"gl" : "¡Non te esquezas de avanzar master ós cambios actualizados!",
"de_DE": "Vergiss nicht den master auf die aktuelle Version vorzuspulen",
"en_US": "Don't forget to forward main to the updated changes!",
"fr_FR": "N'oubliez pas d'appliquer les changements depuis la branche main",
"es_AR": "¡No te olvides de avanzar main a los cambios actualizados!",
"es_ES": "¡No te olvides de avanzar main a los cambios actualizados!",
"pt_BR": "Não se esqueça de avançar a referência do main para as mudanças efetuadas!",
"gl" : "¡Non te esquezas de avanzar main ós cambios actualizados!",
"de_DE": "Vergiss nicht den main auf die aktuelle Version vorzuspulen",
"ja": "masterのポインタを先に進めることを忘れずに！",
"ko": "master를 변경 완료한 커밋으로 이동(forward)시키는 것을 잊지 마세요!",
"zh_CN": "别忘记了将 master 快进到最新的更新上！",
"zh_TW": "別忘記了將 master 推到最新的 commit 上面！",
"ru_RU": "Не забудь переместить master на последние изменения.",
"uk": "Не забудь перемістити master на останні зміни!",
"vi": "Đừng quên đẩy nhánh master lên cập nhật mới nhất!",
"sl_SI": "Ne pozabi prestaviti master naprej na posodobljene spremembe."
"ko": "main을 변경 완료한 커밋으로 이동(forward)시키는 것을 잊지 마세요!",
"zh_CN": "别忘记了将 main 快进到最新的更新上！",
"zh_TW": "別忘記了將 main 推到最新的 commit 上面！",
"ru_RU": "Не забудь переместить main на последние изменения.",
"uk": "Не забудь перемістити main на останні зміни!",
"vi": "Đừng quên đẩy nhánh main lên cập nhật mới nhất!",
"sl_SI": "Ne pozabi prestaviti main naprej na posodobljene spremembe."
},
"startDialog": {
"en_US": {
@ -79,7 +79,7 @@ exports.level = {
"Nice! Let's move on."
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -122,7 +122,7 @@ exports.level = {
"Bien ! continuons."
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -165,7 +165,7 @@ exports.level = {
"¡Bien! Sigamos..."
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -208,7 +208,7 @@ exports.level = {
"¡Bien! Sigamos..."
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -251,7 +251,7 @@ exports.level = {
"Ótimo! Vamos em frente."
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -294,7 +294,7 @@ exports.level = {
"¡A tope! Seguimos."
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -319,7 +319,7 @@ exports.level = {
"",
"Du solltest \"Jonglieren mit Commits\" (den vorherigen Level) bestanden haben, bevor du dich an diesem hier versuchst.",
"",
"Wie du im letzten Level gesehen hast haben wir `git rebase -i` genutzt, um die Commits neu anzuordnen. Sobald der Commit, den wir ändern wollte, ganz oben war, konnten wir das auch einfach mit `git commit --amend` tun. Danach haben wir die alte Reihenfolge wiederhergestellt.",
"Wie du im letzten Level gesehen hast, haben wir `git rebase -i` genutzt, um die Commits neu anzuordnen. Sobald der Commit, den wir ändern wollten, ganz oben war, konnten wir ihn einfach mit `git commit --amend` anpassen. Danach haben wir die alte Reihenfolge wiederhergestellt.",
"",
"Das einzige Problem ist hier, dass da eine Menge Umsortieren stattfindet, was zu Rebase-Konflikten führen kann. Schauen wir uns also eine Methode mit `git cherry-pick` an."
]
@ -329,7 +329,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Wie du dich erinnerst macht `git cherry-pick` eine Kopie des angegebenen Commits und fügt sie an `HEAD` an (es sei denn der Commit ist ein Vorgänger von `HEAD`).",
"Wie du dich erinnerst, macht `git cherry-pick` eine Kopie des angegebenen Commits und fügt sie an `HEAD` an (es sei denn der Commit ist ein Vorgänger von `HEAD`).",
"",
"Hier eine kleine Demo zur Erinnerung:"
],
@ -337,7 +337,7 @@ exports.level = {
"Schick! Und weiter geht's."
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -380,7 +380,7 @@ exports.level = {
"できました！次へ進みましょう"
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -421,7 +421,7 @@ exports.level = {
"afterMarkdowns": [
"看到了吧？我们继续"
],
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -464,7 +464,7 @@ exports.level = {
"afterMarkdowns": [
"太棒了，我們繼續吧！"
],
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -505,7 +505,7 @@ exports.level = {
"좋아요! 계속할게요"
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -546,7 +546,7 @@ exports.level = {
"Ок! Едем дальше!"
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -589,7 +589,7 @@ exports.level = {
"Добре! Продовжуємо"
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -632,7 +632,7 @@ exports.level = {
"Hay! Tiếp tục nào"
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{
@ -675,7 +675,7 @@ exports.level = {
"Odlično! Nadaljujmo ..."
],
"command": "git cherry-pick C2",
"beforeCommand": "git checkout -b bugFix; git commit; git checkout master; git commit"
"beforeCommand": "git checkout -b bugFix; git commit; git checkout main; git commit"
}
},
{

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

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C5\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"side\":{\"target\":\"C3\",\"id\":\"side\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C1\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C2\",\"C4\"],\"id\":\"C5\"}},\"tags\":{\"v1\":{\"target\":\"C2\",\"id\":\"v1\",\"type\":\"tag\"},\"v0\":{\"target\":\"C1\",\"id\":\"v0\",\"type\":\"tag\"}},\"HEAD\":{\"target\":\"C2\",\"id\":\"HEAD\"}}",
"solutionCommand": "git tag v1 side~1;git tag v0 master~2;git checkout v1",
"solutionCommand": "git tag v1 side~1;git tag v0 main~2;git checkout v1",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C5\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"side\":{\"target\":\"C3\",\"id\":\"side\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C1\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C2\",\"C4\"],\"id\":\"C5\"}},\"tags\":{},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}",
"name": {
"en_US": "Git Tags",
@ -461,7 +461,7 @@ exports.level = {
"markdowns": [
"## Git Tags",
"",
"Wie du aus den vorhergehenden Levels weißt sind Branches einfach durch die Gegend zu schieben und zeigen auf verschiedene Commits, während die Arbeit in ihnen fortschreitet. Ein Branch wird oft verändert, manchmal nur temporär, und ist ständig in Bewegung.",
"Wie du aus den vorhergehenden Levels weißt, sind Branches einfach durch die Gegend zu schieben und zeigen auf verschiedene Commits, während die Arbeit in ihnen fortschreitet. Ein Branch wird oft verändert, manchmal nur temporär, und ist ständig in Bewegung.",
"",
"Da das so ist fragst du dich vielleicht, ob es nicht eine Möglichkeit gibt, eine bestimmte Stelle in deiner Projekt-History *permanent* zu kennzeichnen. Kann man nicht zum Beispiel für große Releases und Meilensteine nicht einen Commit mit etwas festerem kennzeichnen, als mit einem Branch-Namen?",
""
@ -487,7 +487,7 @@ exports.level = {
"Lass uns ein Tag bei `C1` anlegen und damit die Version 1 unseres Prototyps markieren."
],
"afterMarkdowns": [
"Peng! Ziemlich einfach. Wir haben das Tag `v1` genannt und lassen es auf `C1` zeigen. Wenn du den Commit weglässt wird das Tag für den Commit erzeugt, auf den `HEAD` zeigt."
"Peng! Ziemlich einfach. Wir haben das Tag `v1` genannt und lassen es auf `C1` zeigen. Wenn du den Commit weglässt, wird das Tag für den Commit erzeugt, auf den `HEAD` zeigt."
],
"command": "git tag v1 C1",
"beforeCommand": "git commit"
@ -499,7 +499,7 @@ exports.level = {
"markdowns": [
"Um diesen Level zu schaffen, erstelle einfach die Tags wie sie in der Zielbeschreibung stehen und mach dann einen Checkout auf `v1`. Beachte wie du dabei in den \"Detached HEAD\" Zustand gehst -- das liegt daran, dass du keine Commits direkt auf das `v1` Tag machen kannst.",
"",
"Im nächsten Level schauen wir uns dann interessantere Anwendungsfälle für Tags an."
"Im nächsten Level schauen wir uns dann einen interessanteren Anwendungsfall für Tags an."
]
}
}

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

@ -78,20 +78,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Here's a repository where we have some work in branch `side` that we want to copy to `master`. This could be accomplished through a rebase (which we have already learned), but let's see how cherry-pick performs."
"Here's a repository where we have some work in branch `side` that we want to copy to `main`. This could be accomplished through a rebase (which we have already learned), but let's see how cherry-pick performs."
],
"afterMarkdowns": [
"That's it! We wanted commits `C2` and `C4` and git plopped them down right below us. Simple as that!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"To complete this level, simply copy some work from the three branches shown into master. You can see which commits we want by looking at the goal visualization.",
"To complete this level, simply copy some work from the three branches shown into main. You can see which commits we want by looking at the goal visualization.",
""
]
}
@ -135,20 +135,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ici le dépôt que nous avons contient du travail dans la branche `side`, que nous voulons copier dans `master`. Cela pourrait être fait avec un rebase (que nous avons déjà appris), mais voyons comment cherry-pick fonctionne."
"Ici le dépôt que nous avons contient du travail dans la branche `side`, que nous voulons copier dans `main`. Cela pourrait être fait avec un rebase (que nous avons déjà appris), mais voyons comment cherry-pick fonctionne."
],
"afterMarkdowns": [
"Voilà ! Nous voulions les commits `C2` et `C4` et git les a fait apparaître juste sous nos jambes. Aussi simple que ça !"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Pour finir ce niveau, copiez simplement le travail désigné dans la branche master. Vous pouvez voir les commits que nous souhaitons avoir en regardant dans la fenêtre d'objectif.",
"Pour finir ce niveau, copiez simplement le travail désigné dans la branche main. Vous pouvez voir les commits que nous souhaitons avoir en regardant dans la fenêtre d'objectif.",
""
]
}
@ -192,20 +192,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Acá tenemos un repositorio con algo de trabajo en la rama `side` que queremos copiar a `master`. Podríamos lograrlo con un rebase (y ya aprendimos cómo), pero veamos cómo se comporta cherry-pick."
"Acá tenemos un repositorio con algo de trabajo en la rama `side` que queremos copiar a `main`. Podríamos lograrlo con un rebase (y ya aprendimos cómo), pero veamos cómo se comporta cherry-pick."
],
"afterMarkdowns": [
"¡Eso es todo! Queríamos los commits `C2` y `C4` y git los aplicó justo donde estábamos. ¡Tan simple como eso!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nivel, simplemente copiá algo de trabajo desde otras tres ramas a master. Podés ver qué commits queremos en la visualización del objetivo.",
"Para completar este nivel, simplemente copiá algo de trabajo desde otras tres ramas a main. Podés ver qué commits queremos en la visualización del objetivo.",
""
]
}
@ -249,20 +249,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"A continuación tenemos un repositorio con algo de trabajo en la rama `side` que queremos copiar a `master`. Podríamos lograrlo con un rebase (y ya aprendimos cómo), pero veamos cómo se comporta cherry-pick."
"A continuación tenemos un repositorio con algo de trabajo en la rama `side` que queremos copiar a `main`. Podríamos lograrlo con un rebase (y ya aprendimos cómo), pero veamos cómo se comporta cherry-pick."
],
"afterMarkdowns": [
"¡Eso es todo! Queríamos los commits `C2` y `C4` y git los aplicó justo donde estábamos. ¡Tan simple como eso!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nivel, simplemente copia algo de trabajo desde otras tres ramas a master. Puedes ver qué commits queremos en la visualización del objetivo.",
"Para completar este nivel, simplemente copia algo de trabajo desde otras tres ramas a main. Puedes ver qué commits queremos en la visualización del objetivo.",
""
]
}
@ -306,20 +306,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Aqui está um repositório onde temos algum trabalho no ramo `side` que desejamos copiar para o `master`. Isso poderia ser obtido por meio de um rebase (que já aprendemos), mas vamos ver como o cherry-pick se sai."
"Aqui está um repositório onde temos algum trabalho no ramo `side` que desejamos copiar para o `main`. Isso poderia ser obtido por meio de um rebase (que já aprendemos), mas vamos ver como o cherry-pick se sai."
],
"afterMarkdowns": [
"É isso! Queríamos os commits `C2` e `C4` e o git os inseriu logo abaixo de nós. Simples assim!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nível, simplesmente copie algum trabalho dos outros três ramos para o master. Você pode ver quais commits queremos copiar na visualização do objetivo.",
"Para completar este nível, simplesmente copie algum trabalho dos outros três ramos para o main. Você pode ver quais commits queremos copiar na visualização do objetivo.",
""
]
}
@ -363,20 +363,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Aquí está un repositorio onde hai algún traballo na rama `side` que desexamos copiar para a rama `master`. Iso podería ser obtido por medio dun rebase (que xa aprendemos), pero imos ver como o resolve cherry-pick."
"Aquí está un repositorio onde hai algún traballo na rama `side` que desexamos copiar para a rama `main`. Iso podería ser obtido por medio dun rebase (que xa aprendemos), pero imos ver como o resolve cherry-pick."
],
"afterMarkdowns": [
"¡Eso é! Queríamos os commits `C2` e `C4` e git insertounos por baixo de nós. ¡Moi sinxelo!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nivel, copia algo de traballo das outras ramas na master. Podes ver qué commits queremos copiar na visualización do obxectivo.",
"Para completar este nivel, copia algo de traballo das outras ramas na main. Podes ver qué commits queremos copiar na visualización do obxectivo.",
""
]
}
@ -420,20 +420,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"這裡有一個 repo，在 `side` branch 中，我們有一些 commit 想要複製到 `master` branch 上，這可以透過一個 rebase 來完成（我們之前已經學到了），但是讓我們看看 `git cherry-pick` 怎麼做。"
"這裡有一個 repo，在 `side` branch 中，我們有一些 commit 想要複製到 `main` branch 上，這可以透過一個 rebase 來完成（我們之前已經學到了），但是讓我們看看 `git cherry-pick` 怎麼做。"
],
"afterMarkdowns": [
"就是那樣！我們複製了 `C2` 以及 `C4` 並且把它們放到我們的後面，很簡單吧！"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"要完成這個關卡，只需要從三個 branch 複製幾個 commit 到 `master` 下面，你可以從視覺化的目標看到我們需要哪些 commit。",
"要完成這個關卡，只需要從三個 branch 複製幾個 commit 到 `main` 下面，你可以從視覺化的目標看到我們需要哪些 commit。",
""
]
}
@ -476,20 +476,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"这里有一个仓库, 我们想将 `side` 分支上的工作复制到 `master` 分支，你立刻想到了之前学过的 `rebase` 了吧？但是咱们还是看看 `cherry-pick` 有什么本领吧。"
"这里有一个仓库, 我们想将 `side` 分支上的工作复制到 `main` 分支，你立刻想到了之前学过的 `rebase` 了吧？但是咱们还是看看 `cherry-pick` 有什么本领吧。"
],
"afterMarkdowns": [
"这就是了！我们只需要提交记录 `C2` 和 `C4`，所以 Git 就将被它们抓过来放到当前分支下了。 就是这么简单!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"要通过此关, 只需要简单的将三个分支中的提交记录复制到 master 上就可以了。目标窗口展示了我们想要哪些提交记录，如果你不小心关掉了的话，通过 `show goal` 命令可以打开，左上角也有“显示目标按钮”",
"要通过此关, 只需要简单的将三个分支中的提交记录复制到 main 上就可以了。目标窗口展示了我们想要哪些提交记录，如果你不小心关掉了的话，通过 `show goal` 命令可以打开，左上角也有“显示目标按钮”",
""
]
}
@ -504,7 +504,7 @@ exports.level = {
"markdowns": [
"## Inhalte verschieben",
"",
"Bis jetzt haben wir uns die Grundlagen von Git angeschaut -- comitten, verzweigen und sich im Commit-Baum bewegen. Nur damit lässt sich schon 90% der Macht von Git-Repositories nutzen und die meisten Anforderungen von Entwicklern erfüllen.",
"Bis jetzt haben wir uns die Grundlagen von Git angeschaut -- comitten, verzweigen und sich im Commit-Baum bewegen. Nur damit lässt sich schon 90% der Macht von Git-Repositorys nutzen und die meisten Anforderungen von Entwicklern erfüllen.",
"",
"Die übrigen 10% jedoch können in komplexeren Abläufen sehr hilfreich sein (oder wenn man sich in eine schwierige Lage manövriert hat). Das nächste was wir uns anschauen, ist, Inhalte durch den Commit-Baum zu schieben. Es gibt dem Entwickler die Möglichkeit in präziser, eloquenter Manier zu sagen \"Ich will diese Inhalte hier und diese dort haben\".",
"",
@ -522,7 +522,7 @@ exports.level = {
"",
"* `git cherry-pick <Commit1> <Commit2> <...>`",
"",
"Er ist eine einfache Möglichkeit um auszudrücken, dass du eine Folge von Commits unter deinen aktuellen Checkout (also `HEAD`) hängen möchtest. Ich persönlich liebe `cherry-pick`, weil es wenig Magic enthält und einfach zu verstehen ist.",
"Er ist eine einfache Möglichkeit um auszudrücken, dass du eine Folge von Commits unter deinen aktuellen Checkout (also `HEAD`) hängen möchtest. Ich persönlich liebe `cherry-pick`, weil es wenig Magie enthält und einfach zu verstehen ist.",
"",
"Schauen wir's uns mal an.",
""
@ -533,20 +533,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Hier haben wir ein Repository mit einigem Zeugs im Branch `side`, das wir in den Branch `master` kopieren wollen. Das könnten wir mit einem Rebase machen (wie bereits gesehen), aber schauen wir mal wie das mit `cherry-pick` geht."
"Hier haben wir ein Repository mit einigem Zeugs im Branch `side`, das wir in den Branch `main` kopieren wollen. Das könnten wir mit einem Rebase machen (wie bereits gesehen), aber schauen wir mal, wie das mit `cherry-pick` geht."
],
"afterMarkdowns": [
"Das war's! Wir wollten die commits `C2` und `C4` und Git hat die einfach unter unseren aktuellen Checkout kopiert. So einfach ist das."
"Das war's! Wir wollten die Commits `C2` und `C4` und Git hat die einfach unter unseren aktuellen Checkout kopiert. So einfach ist das."
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Um diesen Level zu schaffen musst du einfach nur einige Commits aus den drei gezeigten Branches in den `master` kopieren. Der Zielbaum zeigt dir, welche.",
"Um diesen Level zu schaffen musst du einfach nur einige Commits aus den drei gezeigten Branches in den `main` kopieren. Der Zielbaum zeigt dir, welche.",
""
]
}
@ -590,13 +590,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"このリポジトリには、現在`side`ブランチから`master`にコピーしたいコードがあります。この前に学んだrebaseコマンドでも実現可能ですが、ここではcherry-pickの動作を見ていきましょう。"
"このリポジトリには、現在`side`ブランチから`main`にコピーしたいコードがあります。この前に学んだrebaseコマンドでも実現可能ですが、ここではcherry-pickの動作を見ていきましょう。"
],
"afterMarkdowns": [
"これだけで終わりです！コミット`C2` と `C4`を取得したかったわけですが、gitが現在の位置の直下に落としてくれました。単純ですね！"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
@ -647,13 +647,13 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Вот репозиторий, где есть некие изменения в ветке `side`, которые мы хотим применить и в ветку `master`. Мы можем сделать это при помощи команды rebase, которую мы уже прошли, но давай посмотрим, как cherry-pick справится с этой задачей."
"Вот репозиторий, где есть некие изменения в ветке `side`, которые мы хотим применить и в ветку `main`. Мы можем сделать это при помощи команды rebase, которую мы уже прошли, но давай посмотрим, как cherry-pick справится с этой задачей."
],
"afterMarkdowns": [
"Вуаля! Мы хотели перенести коммиты `C2` и `C4`, Git дал нам их там, где они нужны. Всё просто!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
@ -704,20 +704,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"여기 repository가 있습니다. `master`와 master로 복사하고 싶은 작업이 있는 브랜치 `side`가 있습니다. 이것은 rebase를 통해서 할 수 있습니다(이미 배운), 하지만 체리-픽이 이 작업을 어떻게 수행하는지 확인해 봅시다."
"여기 repository가 있습니다. `main` 으로 복사하고 싶은 작업이 있는 브랜치 `side`가 있습니다. 이것은 rebase를 통해서 할 수 있습니다(이미 배운), 하지만 체리-픽이 이 작업을 어떻게 수행하는지 확인해 봅시다."
],
"afterMarkdowns": [
"됬습니다! 우리는 `C2`와 `C4` 커밋을 원했고 git이 우리가 원하는 곳 바로 밑에 톡 떨어뜨려 줬습니다. 아주 간단하죠!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"이 레벨을 통과하기 위해서는 몇개의 작업을 세개의 브랜치들에서 master로 복사해와야합니다. 어떤 커밋들이 필요한지는 goal을 보고 확인하면 됩니다.",
"이 레벨을 통과하기 위해서는 몇개의 작업을 세개의 브랜치들에서 `main` 브랜치로 복사해와야합니다. 어떤 커밋들이 필요한지는 goal을 보고 확인하면 됩니다.",
""
]
}
@ -761,20 +761,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ми бачимо репозиторій де є певні зміни в гілці `side` які ми хочемо скопіювати в `master`. Для цього можна використати rebase (який ми вже вивчили), але подивимось як з цим впорається cherry-pick."
"Ми бачимо репозиторій де є певні зміни в гілці `side` які ми хочемо скопіювати в `main`. Для цього можна використати rebase (який ми вже вивчили), але подивимось як з цим впорається cherry-pick."
],
"afterMarkdowns": [
"Овва! Ми хотіли коміти `C2` та `C4` і git додав їх до поточного розташування. Просто й доступно!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Щоб пройти це рівень, просто скопіюй якісь зміни з трьох гілок показаних на діаграмі в master. В візуалізації видно які коміти потрібно скопіювати.",
"Щоб пройти це рівень, просто скопіюй якісь зміни з трьох гілок показаних на діаграмі в main. В візуалізації видно які коміти потрібно скопіювати.",
""
]
}
@ -818,20 +818,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Ở đây ta có một kho chứa mà ta muốn sao chép thành quả công việc từ nhánh `side` sang nhánh `master`. Có thể dùng rebase để làm việc này (kỹ thuật mà ta đã học), nhưng hãy xem thử cherry-pick làm điều này ra sao."
"Ở đây ta có một kho chứa mà ta muốn sao chép thành quả công việc từ nhánh `side` sang nhánh `main`. Có thể dùng rebase để làm việc này (kỹ thuật mà ta đã học), nhưng hãy xem thử cherry-pick làm điều này ra sao."
],
"afterMarkdowns": [
"Thế thôi! Chúng ta chỉ cần các commit `C2` và` C4`, vì vậy Git sẽ lấy chúng và đặt chúng dưới nhánh hiện tại. Thật đơn giản!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Để hoàn thành cấp độ này, hãy copy thành quả công việc từ 3 nhánh khác vào master. Bạn có thể nhìn vào mô tả mục tiêu để biết chúng ta cần những commit nào.",
"Để hoàn thành cấp độ này, hãy copy thành quả công việc từ 3 nhánh khác vào main. Bạn có thể nhìn vào mô tả mục tiêu để biết chúng ta cần những commit nào.",
""
]
}
@ -875,20 +875,20 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Tu je repozitorij, kjer imamo nekaj dela na branchu `side`, ki bi ga radi skopirali na `master`. To bi lahko dosegli z rebase-om (kar smo se že naučili), ampak poglejmo kako se odreže cherry-pick."
"Tu je repozitorij, kjer imamo nekaj dela na branchu `side`, ki bi ga radi skopirali na `main`. To bi lahko dosegli z rebase-om (kar smo se že naučili), ampak poglejmo kako se odreže cherry-pick."
],
"afterMarkdowns": [
"To je to! Želeli smo commita `C2` in `C4` in git ju je prilimal točno pod nas. Preprosto!"
],
"command": "git cherry-pick C2 C4",
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Za končanje te stopnje enostavno skopiraj nekaj dela iz predstavljenih treh branchev v master. V priloženi vizualizaciji lahko vidiš katere commite.",
"Za končanje te stopnje enostavno skopiraj nekaj dela iz predstavljenih treh branchev v main. V priloženi vizualizaciji lahko vidiš katere commite.",
""
]
}

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

@ -17,7 +17,8 @@ exports.level = {
"ko" : "HEAD 분리하기",
"uk": "Втрачаємо голову чи detached HEAD",
'vi': "Tháo đầu cái nào",
"sl_SI": "Ločevanje tvoje glave - HEAD-a"
"sl_SI": "Ločevanje tvoje glave - HEAD-a",
"pl" : "Odczep swój HEAD"
},
"hint": {
"en_US": "Use the label (hash) on the commit for help!",
@ -34,7 +35,8 @@ exports.level = {
"ko" : "커밋에 있는 라벨(hash)을 활용하세요!",
"uk": "Орієнтуйся по індентифікаторам (hash) комітів.",
"vi": "Dùng mã băm (hash) của commit để hoàn thành!",
"sl_SI": "Uporabi oznako (hash) commita za pomoč!"
"sl_SI": "Uporabi oznako (hash) commita za pomoč!",
"pl": "Wpisz (hash) w wiadomości commita aby uzyskać pomoc!",
},
"startDialog": {
"en_US": {
@ -77,9 +79,9 @@ exports.level = {
"Let's see this in action. Here we will reveal HEAD before and after a commit."
],
"afterMarkdowns": [
"See! HEAD was hiding underneath our `master` branch all along."
"See! HEAD was hiding underneath our `main` branch all along."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -91,7 +93,7 @@ exports.level = {
"",
"Detaching HEAD just means attaching it to a commit instead of a branch. This is what it looks like beforehand:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -155,9 +157,9 @@ exports.level = {
"Veámoslo en acción. Acá vamos a ver a HEAD antes y después de un commit."
],
"afterMarkdowns": [
"¡Ves! HEAD estuvo oculta bajo nuestra rama `master` todo este tiempo."
"¡Ves! HEAD estuvo oculta bajo nuestra rama `main` todo este tiempo."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -169,7 +171,7 @@ exports.level = {
"",
"Detachear (_des-adjuntar_) HEAD simplemente significa adjuntarla a un commit en lugar de a un branch. Así es como se ve de antemano:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -233,9 +235,9 @@ exports.level = {
"Veámoslo en acción. A continuación vamos a ver a HEAD antes y después de un commit."
],
"afterMarkdowns": [
"¡Ves! HEAD estuvo oculta bajo nuestra rama `master` todo este tiempo."
"¡Ves! HEAD estuvo oculta bajo nuestra rama `main` todo este tiempo."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -247,7 +249,7 @@ exports.level = {
"",
"Detachear (_des-adjuntar_) HEAD simplemente significa adjuntarla a un commit en lugar de a un branch. Así es como se ve de antemano:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -311,9 +313,9 @@ exports.level = {
"Vejamos isto em ação. Aqui vamos mostrar o HEAD antes e depois de um commit."
],
"afterMarkdowns": [
"Veja! O HEAD estava se escondendo ao lado do nosso `master` esse tempo todo."
"Veja! O HEAD estava se escondendo ao lado do nosso `main` esse tempo todo."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -325,7 +327,7 @@ exports.level = {
"",
"Soltar o HEAD significa anexá-lo a um commit em vez de anexá-lo a um ramo. Antes do estado solto (\"detached\"), é assim como se parece:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -389,9 +391,9 @@ exports.level = {
"Vexamos isto en acción. Aquí imos mostrar o HEAD antes e depois dun commit."
],
"afterMarkdowns": [
"Ves! O HEAD estivo ó lado do noso `master` todo este tempo."
"Ves! O HEAD estivo ó lado do noso `main` todo este tempo."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -403,7 +405,7 @@ exports.level = {
"",
"Soltar o HEAD significa apuntar a un commit en vez de apuntar a unha rama. Antes do estado solo (\"detached\"), é así como aparece:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -467,9 +469,9 @@ exports.level = {
"Voyons cela en action. Ici nous allons indiquer où se situe HEAD avant et après un commit."
],
"afterMarkdowns": [
"Vous voyez ! HEAD était caché en dessous de la branche `master` tout le long."
"Vous voyez ! HEAD était caché en dessous de la branche `main` tout le long."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -481,7 +483,7 @@ exports.level = {
"",
"Détacher HEAD signifie simplement que l'on attache HEAD à un commit au lieu d'une branche. Voilà à quoi cela ressemble actuellement :",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -513,7 +515,7 @@ exports.level = {
"markdowns": [
"## Navigation durch Git",
"",
"Bevor wir uns einige fortgeschrittene Konzepte in Git ansehen ist es wichtig, verschiedene Wege zum Navigieren durch den Commit-Baum, der das Projekt enthält, zu kennen.",
"Bevor wir uns einige fortgeschrittene Konzepte in Git ansehen, ist es wichtig, verschiedene Wege zum Navigieren durch den Commit-Baum, der das Projekt enthält, zu kennen.",
"",
"Sobald du das drauf hast, vergrößern sich deine Möglichkeiten in allen anderen Git-Befehlen.",
"",
@ -532,7 +534,7 @@ exports.level = {
"",
"Erst mal müssen wir über `HEAD` reden. `HEAD` ist ein Alias für den Commit, der gerade ausgecheckt ist -- es ist im Prinzip der Commit, an den du deinen nächsten Commit hängst.",
"",
"`HEAD` zeigt immer auf den neuesten Commit. Die meisten Git-Befehle, die den Baum verändern, fangen damit an dass sie `HEAD` verschieben.",
"`HEAD` zeigt immer auf den neuesten Commit. Die meisten Git-Befehle, die den Baum verändern, fangen damit an, dass sie `HEAD` verschieben.",
"",
"Normalerweise zeigt `HEAD` auf einen Branch-Namen (z.B. `bugFix`). Wenn du einen Commit machst, wird `bugFix` auf diesen Commit geschoben, und `HEAD` (da es auf `bugFix` zeigt) automatisch auch."
]
@ -545,9 +547,9 @@ exports.level = {
"Schauen wir uns das mal in Aktion an. Wir werden hier `HEAD` vor und nach dem Commit anzeigen."
],
"afterMarkdowns": [
"Siehst du? `HEAD` war die ganze Zeit unter `master` versteckt."
"Siehst du? `HEAD` war die ganze Zeit unter `main` versteckt."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -559,7 +561,7 @@ exports.level = {
"",
"`HEAD` abzukoppeln bedeutet, es direkt an einen bestimmten Commit zu hängen, anstatt an einen Branch. Wir gelangen dadurch in den \"detached HEAD state\". So sieht's vorher aus:",
"",
"`HEAD` -> `master` -> `C1`",
"`HEAD` -> `main` -> `C1`",
""
],
"afterMarkdowns": [
@ -619,12 +621,12 @@ exports.level = {
"下面咱们通过实际操作看一下。我们将会观察提交前后 HEAD 的位置。"
],
"afterMarkdowns": [
"看到了吗？ HEAD 指向了 `master`，随着提交向前移动。",
"看到了吗？ HEAD 指向了 `main`，随着提交向前移动。",
"",
"（译者注：实际这些命令并不是真的在查看 HEAD 指向，看下一屏就了解了。如果想看 HEAD 指向，可以通过 `cat .git/HEAD` 查看，",
"如果 HEAD 指向的是一个引用，还可以用 `git symbolic-ref HEAD` 查看它的指向。但是该程序不支持这两个命令）"
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -636,9 +638,9 @@ exports.level = {
"",
"分离的 HEAD 就是让其指向了某个具体的提交记录而不是分支名。在命令执行之前的状态如下所示： ",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
"",
"HEAD 指向 master， master 指向 C1"
"HEAD 指向 main， main 指向 C1"
],
"afterMarkdowns": [
"现在变成了",
@ -697,9 +699,9 @@ exports.level = {
"在實際的例子中。我們將會觀察 commit 前後 HEAD 的位置。"
],
"afterMarkdowns": [
"看吧！HEAD 一直藏在 `master` 分支的後面。"
"看吧！HEAD 一直藏在 `main` 分支的後面。"
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -711,7 +713,7 @@ exports.level = {
"",
"分離 HEAD 就是讓其指向一個 commit 而不是 branch 的名稱。這是指令執行之前的樣子：",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -775,9 +777,9 @@ exports.level = {
"実際の動作を見てみましょう。ここでは、コミットの前と後のHEADの状態を確認します。"
],
"afterMarkdowns": [
"ほら、HEADが元から`master`ブランチの下に隠れていたんですね！"
"ほら、HEADが元から`main`ブランチの下に隠れていたんですね！"
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -789,7 +791,7 @@ exports.level = {
"",
"HEADの分離(detached HEAD)とは単に、ブランチではなく特定のコミットにHEADを紐づけることです。実行前の状態は次のようです:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -853,9 +855,9 @@ exports.level = {
"Посмотрим, как это работает. Обратите внимание на то, где находится HEAD до и после коммита."
],
"afterMarkdowns": [
"Вот! HEAD всё это время скрывался за веткой `master`."
"Вот! HEAD всё это время скрывался за веткой `main`."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -867,7 +869,7 @@ exports.level = {
"",
"Отделение (detaching) HEAD означает лишь присвоение его не ветке, а конкретному коммиту. Посмотрим, что было до отделения:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -931,9 +933,9 @@ exports.level = {
"직접 확인해 봅시다. 여기서 우리는 보이지 않던 HEAD를 커밋전, 후에 드러낼 것입니다."
],
"afterMarkdowns": [
"보세요! HEAD가 `master`브랜치 아래에 숨어 있던 거군요."
"보세요! HEAD가 `main`브랜치 아래에 숨어 있던 거군요."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -945,7 +947,7 @@ exports.level = {
"",
"HEAD를 분리한다는 것은 HEAD를 브랜치 대신 커밋에 붙이는 것을 의미합니다. 명령을 사용하기 전의 모습은 다음과 같습니다:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -1009,9 +1011,9 @@ exports.level = {
"Розберемось з цим на практиці. Зараз ми перевіримо HEAD до та після коміту."
],
"afterMarkdowns": [
"Ти диви! HEAD весь цей час ховався за гілкою `master`."
"Ти диви! HEAD весь цей час ховався за гілкою `main`."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -1023,7 +1025,7 @@ exports.level = {
"",
"Detached HEAD (відокремлена голова) просто означає що HEAD посилається на коміт, а не на якусь гілку. Ось як це виглядає спочатку:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -1087,9 +1089,9 @@ exports.level = {
"Xem thử thực tế nào. Ở đây ta sẽ bộc lộ HEAD trước và sau khi commit."
],
"afterMarkdowns": [
"Thấy chứ? HEAD đã ẩn dưới nhánh `master` suốt."
"Thấy chứ? HEAD đã ẩn dưới nhánh `main` suốt."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -1101,7 +1103,7 @@ exports.level = {
"",
"Tháo HEAD đơng giản nghĩa là dán nó vào một commit thay vì một nhánh. Lúc trước thì nó trông như thế này:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -1165,9 +1167,9 @@ exports.level = {
"Poglejmo to v akciji. Sedaj bomo razkrili HEAD pred in po commitu."
],
"afterMarkdowns": [
"Evo! HEAD se je vseskozi skrival pod našim `master` branchom."
"Evo! HEAD se je vseskozi skrival pod našim `main` branchom."
],
"command": "git checkout C1; git checkout master; git commit; git checkout C2",
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
@ -1179,7 +1181,7 @@ exports.level = {
"",
"Ločevanje HEAD-a pomeni samo, da ga namestno na branch sedaj pripnemo na commit. Tako je izgledalo prej:",
"",
"HEAD -> master -> C1",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
@ -1202,6 +1204,84 @@ exports.level = {
}
}
]
},
"pl": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Poruszanie się w Git",
"",
"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!",
"",
"",
"",
"",
""
]
}
},
{
"type": "ModalAlert",
"options": {
"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ś.",
"",
"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.",
"",
"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."
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Sprawdźmy to w akcji. Pokażemy HEAD przed i po commicie."
],
"afterMarkdowns": [
"Zobacz! HEAD przez cały czas ukrywał się pod naszą gałęzią `main`."
],
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
"beforeCommand": ""
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"### Odłączanie HEAD'a",
"",
"Odłączenie HEAD'a oznacza po prostu dołączenie go do commita, a nie gałęzi. Tak to wyglądało przed:",
"",
"HEAD -> main -> C1",
""
],
"afterMarkdowns": [
"A tak po:",
"",
"HEAD -> C1"
],
"command": "git checkout C1",
"beforeCommand": ""
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Aby ukończyć ten poziom, odłącz HEAD 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."
]
}
}
]
}
}
};

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

@ -73,11 +73,12 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"When the interactive rebase dialog opens, you have the ability to do 3 things:",
"When the interactive rebase dialog opens, you have the ability to do two things in our educational application:",
"",
"* You can reorder commits simply by changing their order in the UI (in our window this means dragging and dropping with the mouse).",
"* You can choose to completely omit some commits. This is designated by `pick` -- toggling `pick` off means you want to drop the commit.",
"* Lastly, you can squash commits. Unfortunately our levels don't support this for a few logistical reasons, so I'll skip over the details of this. Long story short, though -- it allows you to combine commits.",
"",
"*It is worth mentioning that in the real git interactive rebase you can do many more things like squashing (combining) commits, amending commit messages, and even editing the commits themselves. For our purposes though we will focus on these two operations above.*",
"",
"Great! Let's see an example."
]
@ -569,9 +570,9 @@ exports.level = {
"markdowns": [
"## Interaktiver Rebase",
"",
"Cherry-pick ist großartig wenn du genau weißt, welche Commits du willst (_und_ ihre jeweiligen Hashes kennst) -- es ist dann schwer an Einfachheit zu überbieten.",
"Cherry-pick ist großartig, wenn du genau weißt, welche Commits du willst (_und_ ihre jeweiligen Hashes kennst) -- es ist dann schwer an Einfachheit zu überbieten.",
"",
"Aber wie sieht es aus, wenn du die Commits nicht genau kennst, die du brauchst? Zum Glück bietet Git auch dafür eine Lösung an. Das können wir mit interaktivem Rebase machen -- die beste Art sich eine Serie von Commits in einem Rebase genau anzusehen.",
"Aber wie sieht es aus, wenn du die benötigten Commits nicht genau kennst? Zum Glück bietet Git auch dafür eine Lösung an. Das können wir mit interaktivem Rebase machen -- die beste Art sich eine Serie von Commits in einem Rebase genau anzusehen.",
"",
"Schauen wir uns die Details an ..."
]
@ -585,7 +586,7 @@ exports.level = {
"",
"Wenn du das machst, zeigt Git dir jeden einzelnen Commit, der durch den Rebase kopiert werden würde. Es zeigt dir die Hashes und Kommentare, was gut ist um einen Überblick zu bekommen.",
"",
"In echtem Git besteht dieser Dialog daraus, die Commits in einem Text-Editor angezeigt zu bekommen. Für unsere Zwecke hab ich ein kleines Dialog-Fenster gebaut, dass sich ähnlich verhält."
"Im \"echten\" Git werden die Commits in einem Text-Editor angezeigt (z.B. in `vim`). Für unsere Zwecke habe ich ein kleines Dialog-Fenster gebaut, das sich ähnlich verhält."
]
}
},
@ -596,8 +597,8 @@ exports.level = {
"Wenn sich der Dialog für den interaktiven Rebase öffnet, kannst du drei Dinge tun:",
"",
"* Du kannst die Reihenfolge der Commits durch Ziehen und Ablegen ändern.",
"* Du kannst Git sagen, einen Commit beim Rebase zu ignorieren -- im Dialog durch die Schaltfläche `pick` dargestellt.",
"* Außerdem kannst du Commit zusammenfassen (squash). Leider wird das hier nicht unterstützt, aber in echtem Git fasst es Commits zu einem zusammen.",
"* Du kannst einen Commit beim Rebase ignorieren, indem du im Dialog auf die Schaltfläche `omit` klickst. Du kannst einen Commit wieder aufnehmen, indem du auf `pick` klickst.",
"* Außerdem kannst du Commits zusammenfassen (squash). Leider wird das hier nicht unterstützt, aber im echten Git fasst es Commits zu einem zusammen.",
"",
"Super! Schauen wir uns ein Beispiel an."
]
@ -607,7 +608,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Wenn du die Schaltfläche anklickst wird sich der Rebase-Dialog öffnen. Veränder die Reihenfolge der Commits oder klick bei einigen auf `pick` und schau dir das Ergebnis an."
"Wenn du die Schaltfläche anklickst, wird sich der Rebase-Dialog öffnen. Verändere die Reihenfolge der Commits oder klicke bei einigen auf `pick` bzw. `omit` und schaue dir das Ergebnis an."
],
"afterMarkdowns": [
"Bämm! Git hat die Commits genau so kopiert, wie du es ausgewählt hast."
@ -620,7 +621,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Um dieses Level zu schaffen mach einen interaktiven Rebase, um genau die Reihenfolge zu erzeugen die im Ziel-Baum angezeigt wird. Denk daran, dass du jederzeit mit `undo` oder `reset` Fehler rückgängig machen kannst. :D"
"Um dieses Level zu schaffen mach einen interaktiven Rebase, um genau die Reihenfolge zu erzeugen, die im Ziel-Baum angezeigt wird. Denk daran, dass du jederzeit mit `undo` oder `reset` Fehler rückgängig machen kannst. :D"
]
}
}

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

@ -17,7 +17,8 @@ exports.level = {
"ko" : "상대 참조 (^) (Relative Refs)",
"uk": "Відносні посилання",
"vi": "Tham chiếu tương đối (^)",
"sl_SI": "Relativne Reference (^)"
"sl_SI": "Relativne Reference (^)",
"pl": "Referencje względne (^)",
},
"hint": {
"en_US": "Remember the Caret (^) operator!",
@ -34,7 +35,8 @@ exports.level = {
"ko" : "(^)연산자를 기억하세요!",
"uk": "Не забудь оператор `^`",
"vi": "Đừng quên dấu mũ (^)!",
"sl_SI": "Spomni se na (^) operator!"
"sl_SI": "Spomni se na (^) operator!",
"pl": "Pamiętaj o operatorze karetu (^)!",
},
"startDialog": {
"en_US": {
@ -74,16 +76,16 @@ exports.level = {
"beforeMarkdowns": [
"Let's look at the Caret (^) operator first. Each time you append that to a ref name, you are telling Git to find the parent of the specified commit.",
"",
"So saying `master^` is equivalent to \"the first parent of `master`\".",
"So saying `main^` is equivalent to \"the first parent of `main`\".",
"",
"`master^^` is the grandparent (second-generation ancestor) of `master`",
"`main^^` is the grandparent (second-generation ancestor) of `main`",
"",
"Let's check out the commit above master here."
"Let's check out the commit above main here."
],
"afterMarkdowns": [
"Boom! Done. Way easier than typing the commit hash."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -149,16 +151,16 @@ exports.level = {
"beforeMarkdowns": [
"Regardons l'opérateur circonflexe (^) d'abord. Chaque fois que vous le faites suivre un nom de référence, vous êtes en train de demander à Git de trouver le parent du commit spécifié.",
"",
"Ainsi, `master^` est équivalent à \"le premier parent de `master`\".",
"Ainsi, `main^` est équivalent à \"le premier parent de `main`\".",
"",
"`master^^` est le grand-parent (ancêtre de seconde génération) de `master`",
"`main^^` est le grand-parent (ancêtre de seconde génération) de `main`",
"",
"Faisons un checkout du commit avant master."
"Faisons un checkout du commit avant main."
],
"afterMarkdowns": [
"Boum ! Fini. Bien plus facile qu'écrire l'identifiant du commit."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -224,16 +226,16 @@ exports.level = {
"beforeMarkdowns": [
"Schauen wir uns zuerst den Dach-Operator (`^`) an. Jedes mal wenn du ihn hinter einen Referenz-Namen setzt, sagst du Git damit, dass es zum Vorgänger des angegebenen Commits gehen soll.",
"",
"Das heißt `master^` ist gleichbedeutend mit \"direkter Vorgänger des Commits, auf den `master` zeigt\".",
"Das heißt `main^` ist gleichbedeutend mit \"direkter Vorgänger des Commits, auf den `main` zeigt\".",
"",
"`master^^` ist also der Vorgänger des Vorgängers von `master`.",
"`main^^` ist also der Vorgänger des Vorgängers von `main`.",
"",
"Wir checken jetzt mal den Commit vor `master` aus:"
"Wir checken jetzt mal den Commit vor `main` aus:"
],
"afterMarkdowns": [
"Bämm! Fertig. Einfacher, als den Commit-Hash zu tippen (oder zu kopieren)."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -299,16 +301,16 @@ exports.level = {
"beforeMarkdowns": [
"Veamos el operador ^ primero. Cada vez que le agregás eso al nombre de una referencia, le estás diciendo a git que use el padre del commit especificado.",
"",
"Entonces, decir `master^` es equivalente a \"el primer padre de `master`\".",
"Entonces, decir `main^` es equivalente a \"el primer padre de `main`\".",
"",
"`master^^` es el _abuelo_ (segunda generación de ancestros) de `master`",
"`main^^` es el _abuelo_ (segunda generación de ancestros) de `main`",
"",
"Veamos el commit que está antes de master acá."
"Veamos el commit que está antes de main acá."
],
"afterMarkdowns": [
"¡Boom! Ahí está. Mucho más simple que tipear el hash de ese commit."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -374,16 +376,16 @@ exports.level = {
"beforeMarkdowns": [
"Veamos el operador ^ primero. Cada vez que le agregas eso al nombre de una referencia, le estás diciendo a git que use el padre del commit especificado.",
"",
"Entonces, decir `master^` es equivalente a \"el primer padre de `master`\".",
"Entonces, decir `main^` es equivalente a \"el primer padre de `main`\".",
"",
"`master^^` es el _abuelo_ (segunda generación de ancestros) de `master`",
"`main^^` es el _abuelo_ (segunda generación de ancestros) de `main`",
"",
"Veamos el commit que está antes de master aquí."
"Veamos el commit que está antes de main aquí."
],
"afterMarkdowns": [
"¡Zas! Ahí está. Mucho más simple que escribir el hash de ese commit."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -449,16 +451,16 @@ exports.level = {
"beforeMarkdowns": [
"Vamos dar uma olhada no operador circunflexo (^) primeiro. Cada vez que você adicioná-lo a um nome de referência, você está dizendo ao Git para encontrar o pai do commit especificado.",
"",
"Então, dizer `master^` é equivalente a \"o primeiro pai do `master`\".",
"Então, dizer `main^` é equivalente a \"o primeiro pai do `main`\".",
"",
"`master^^` é o avô (ancestral de segunda geração) do `master`",
"`main^^` é o avô (ancestral de segunda geração) do `main`",
"",
"Vamos fazer checkout do commit logo acima do master."
"Vamos fazer checkout do commit logo acima do main."
],
"afterMarkdowns": [
"Boom! Pronto. Muito mais fácil que digitar o hash do commit."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -524,16 +526,16 @@ exports.level = {
"beforeMarkdowns": [
"Votémoslle unha ollada o operador (^) primeiro. Cada vez que o engadimos a unha referencia, estaslle dicindo a commit que queres o pai de esa referencia.",
"",
"Entón, dicir `master^` é equivalente a \"o primeiro pai do `master`\".",
"Entón, dicir `main^` é equivalente a \"o primeiro pai do `main`\".",
"",
"`master^^` é o avó (ancestral de segunda xeración) do `master`",
"`main^^` é o avó (ancestral de segunda xeración) do `main`",
"",
"Imos facer checkout do commit que está enriba de master."
"Imos facer checkout do commit que está enriba de main."
],
"afterMarkdowns": [
"Boom! Ahí o tes. Moito máis rápido que por o hash do commit."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -599,16 +601,16 @@ exports.level = {
"beforeMarkdowns": [
"首先看看操作符 (^)。把这个符号加在引用名称的后面，表示让 Git 寻找指定提交记录的父提交。",
"",
"所以 `master^` 相当于“`master` 的父节点”。",
"所以 `main^` 相当于“`main` 的父节点”。",
"",
"`master^^` 是 `master` 的第二个父节点",
"`main^^` 是 `main` 的第二个父节点",
"",
"现在咱们切换到 master 的父节点"
"现在咱们切换到 main 的父节点"
],
"afterMarkdowns": [
"搞定。这种方式是不是比输入哈希值方便多了？！"
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -674,16 +676,16 @@ exports.level = {
"beforeMarkdowns": [
"首先看看插入（^）這一個符號。把這個符號接在某一個 reference 後面，就表示你告訴 git 去找到該 reference 所指向的 commit 的 parent commit。",
"",
"所以 `master^` 相當於 \"`master` 的 parent commit\"。",
"所以 `main^` 相當於 \"`main` 的 parent commit\"。",
"",
" `master^^` 是 `master` 的 grandparent commit（往前推兩代）",
" `main^^` 是 `main` 的 grandparent commit（往前推兩代）",
"",
"切換到 master的 parent commit"
],
"afterMarkdowns": [
"看吧！完成了。這種方式比輸入代表 commit 的 hash 值簡單多了！"
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -749,16 +751,16 @@ exports.level = {
"beforeMarkdowns": [
"まずはカレット(^)から始めましょう。リファレンス名にカレットを追加すると、指定コミットの親コミットを見つけるようにとgitに命令を出しています。",
"",
"なので `master^`と記述すれば、\"`master`の一個上の親\"、という意味になります。",
"なので `main^`と記述すれば、\"`main`の一個上の親\"、という意味になります。",
"",
"そして`master^^`とはその親の一つの上のコミット(２代前の親)を指します。",
"そして`main^^`とはその親の一つの上のコミット(２代前の親)を指します。",
"",
"masterの上のコミットをここで見てみましょう"
],
"afterMarkdowns": [
"やりました！コミットハッシュを書くよりずっと簡単ですね。"
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -824,16 +826,16 @@ exports.level = {
"beforeMarkdowns": [
"Для начала рассмотрим оператор каретки (^). Когда мы добавляем его к имени ссылки, Git воспринимает это как указание найти родителя указанного коммита.",
"",
"Так что `master^` означает \"первый родитель ветки `master`\".",
"Так что `main^` означает \"первый родитель ветки `main`\".",
"",
"`master^^` означает прародитель (родитель родителя) `master`",
"`main^^` означает прародитель (родитель родителя) `main`",
"",
"Давайте переключимся на коммит Выше `master`"
"Давайте переключимся на коммит Выше `main`"
],
"afterMarkdowns": [
"Опачки! Готово. Сильно проще, чем поиск и указание хеша."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -899,16 +901,16 @@ exports.level = {
"beforeMarkdowns": [
"먼저 캐럿 (^) 연산자 부터 알아보겠습니다. 참조 이름에 하나씩 추가할 때마다, 명시한 커밋의 부모를 찾게 됩니다.",
"",
"`master^`는 \"`master`의 부모\"와 같은 의미 입니다.",
"`main^`는 \"`main`의 부모\"와 같은 의미 입니다.",
"",
"`master^^` 는 \"`master`의 조부모(부모의 부모)\"를 의미합니다",
"`main^^` 는 \"`main`의 조부모(부모의 부모)\"를 의미합니다",
"",
"master 위에 있는 부모를 체크아웃 해 봅시다."
"main 위에 있는 부모를 체크아웃 해 봅시다."
],
"afterMarkdowns": [
"Boom! 됬습니다. 커밋의 해시를 입력하는 것보다 훨씬 쉬운 방법입니다."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -974,16 +976,16 @@ exports.level = {
"beforeMarkdowns": [
"Розберемось спочатку з оператором каретки (^). Кожна каретка додана до посилання (напр. до імені коміту) вказує git що потрібно знайти батька посилання до якого застосована каретка.",
"",
"Тож `master^` тотожнє до \"перший предок посилання `master`\".",
"Тож `main^` тотожнє до \"перший предок посилання `main`\".",
"",
"`master^^` це дідусь (предок другого покоління) посилання `master`",
"`main^^` це дідусь (предок другого покоління) посилання `main`",
"",
"Давайте перейдемо на коміт трохи вище від master:"
"Давайте перейдемо на коміт трохи вище від main:"
],
"afterMarkdowns": [
"Бум! Готово. Трохи простіше ніж набирати хеш коміту"
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -1049,16 +1051,16 @@ exports.level = {
"beforeMarkdowns": [
"Xem thử cái dấu mũ (^) trước nào. Mỗi lần bạn nối nó với một cái tên tham chiếu, bạn đang ra lệnh cho Git tìm kiếm cha của một commit cụ thể.",
"",
"Cho nên `master^` nghĩa là \"cha đầu tiên của `master`\".",
"Cho nên `main^` nghĩa là \"cha đầu tiên của `main`\".",
"",
"`master^^` là ông nội (tổ tiên thế hệ 2) của `master`",
"`main^^` là ông nội (tổ tiên thế hệ 2) của `main`",
"",
"Thử nhảy sang commit trước master nào"
"Thử nhảy sang commit trước main nào"
],
"afterMarkdowns": [
"BÙUM! Đã xong. Đơn giản hơn gõ mã băm nhiều"
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -1124,16 +1126,16 @@ exports.level = {
"beforeMarkdowns": [
"Poglejmo najprej operator `^`. Vsakič, ko pripneš to imenu reference, poveš Gitu, naj najde starša tega commita.",
"",
"Torej `master^` je isto kot \"prvi starš brancha `master`\".",
"Torej `main^` je isto kot \"prvi starš brancha `main`\".",
"",
"`master^^` je stari starš (prednik druge generacije) `master`.",
"`main^^` je stari starš (prednik druge generacije) `main`.",
"",
"Checkoutajmo sedaj commit nad masterjem."
],
"afterMarkdowns": [
"Boom! Narejeno. Veliko enostavneje kot tipkanje hasha commita."
],
"command": "git checkout master^",
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
@ -1161,6 +1163,81 @@ exports.level = {
}
}
]
}
},
"pl": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"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.",
"",
"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ć!",
"",
"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."
]
}
},
{
"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!",
"",
"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>`"
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"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`\".",
"",
"`main^^` to dziadek (przodek drugiego stopnia) gałęzi `main`",
"",
"Zcheckoutujmy commit powyżej `main`."
],
"afterMarkdowns": [
"Boom! Zrobione. O wiele łatwiej niż wpisując hasz commitu."
],
"command": "git checkout main^",
"beforeCommand": "git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"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^`"
],
"command": "git checkout C3; git checkout HEAD^; git checkout HEAD^; git checkout HEAD^",
"beforeCommand": "git commit; git commit"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"Aby ukończyć ten poziom, zcheckoutuj commit'a-rodzica z gałęzi `bugFix`. To spowoduje odczepienie `HEAD`a.",
"",
"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!"
]
}
}
]
},
}
};

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

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C6\",\"id\":\"master\"},\"bugFix\":{\"target\":\"C0\",\"id\":\"bugFix\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C2\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C3\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"}},\"HEAD\":{\"target\":\"C1\",\"id\":\"HEAD\"}}",
"solutionCommand": "git branch -f master C6;git checkout HEAD~1;git branch -f bugFix HEAD~1",
"solutionCommand": "git branch -f main C6;git checkout HEAD~1;git branch -f bugFix HEAD~1",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C4\",\"id\":\"master\"},\"bugFix\":{\"target\":\"C5\",\"id\":\"bugFix\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C2\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C3\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"}},\"HEAD\":{\"target\":\"C2\",\"id\":\"HEAD\"}}",
"hint": {
"en_US": "You'll need to use at least one direct reference (hash) to complete this level",
@ -17,7 +17,8 @@ exports.level = {
"ko" : "이번 레벨을 완료하려면 최소 한번은 직접 참조(해시)를 사용해야 합니다.",
"uk": "Тобі потрібно використати як мінімум одне пряме посилання (хеш) щоб пройти цей рівень",
"vi": "Bạn sẽ cần dùng ít nhất một tham chiếu trực tiếp (mã băm) để hoàn thành cấp độ này",
"sl_SI": "Moral boš uporabiti vsaj eno direktno referenco (hash) za dokončanje te stopnje."
"sl_SI": "Moral boš uporabiti vsaj eno direktno referenco (hash) za dokončanje te stopnje.",
"pl": "Aby ukończyć ten poziom, musisz użyć co najmniej jednego bezpośredniej referencji (hasza).",
},
"name": {
"en_US": "Relative Refs #2 (~)",
@ -34,7 +35,8 @@ exports.level = {
"ko" : "상대 참조 #2 (~)",
"uk": "Відносні посилання №2",
"vi": "Tham chiếu tương đối #2 (~)",
"sl_SI": "Relativne Reference #2 (~)"
"sl_SI": "Relativne Reference #2 (~)",
"pl": "Referencje względne #2 (~)"
},
"startDialog": {
"en_US": {
@ -75,9 +77,9 @@ exports.level = {
"",
"One of the most common ways I use relative refs is to move branches around. You can directly reassign a branch to a commit with the `-f` option. So something like:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"moves (by force) the master branch to three parents behind HEAD."
"moves (by force) the main branch to three parents behind HEAD."
]
}
},
@ -90,7 +92,7 @@ exports.level = {
"afterMarkdowns": [
"There we go! Relative refs gave us a concise way to refer to `C1` and branch forcing (`-f`) gave us a way to quickly move a branch to that location."
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -100,7 +102,7 @@ exports.level = {
"markdowns": [
"Now that you have seen relative refs and branch forcing in combination, let's use them to solve the next level.",
"",
"To complete this level, move `HEAD`, `master`, and `bugFix` to their goal destinations shown."
"To complete this level, move `HEAD`, `main`, and `bugFix` to their goal destinations shown."
]
}
}
@ -144,9 +146,9 @@ exports.level = {
"",
"Una de las formas más comunes en que uso las referencias relativas es para mover las ramas. Podés reasignar directamente una rama a un commit usando la opción `-f`. Así que algo como:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"Mueve (forzadamente) la rama master tres padres atrás de HEAD."
"Mueve (forzadamente) la rama main tres padres atrás de HEAD."
]
}
},
@ -159,7 +161,7 @@ exports.level = {
"afterMarkdowns": [
"¡Ahí vamos! Las referencias relativas nos dieron una manera concisa de referenciar a `C1`, y forzar la rama (`-f`) nos dio una manera rápida de mover la rama a esa ubicación"
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -169,7 +171,7 @@ exports.level = {
"markdowns": [
"Ahora que viste las referencias relativas y el forzar ramas combinados, usémoslos para resolver el siguiente nivel.",
"",
"Para completar este nivel, mové `HEAD`, `master` y `bugFix` a sus destinos finales."
"Para completar este nivel, mové `HEAD`, `main` y `bugFix` a sus destinos finales."
]
}
}
@ -213,9 +215,9 @@ exports.level = {
"",
"Una de las formas más comunes en que uso las referencias relativas es para mover las ramas. Puedes reasignar directamente una rama a un commit usando la opción `-f`. Algo así como:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"Mueve (forzadamente) la rama master tres padres por detrás de HEAD."
"Mueve (forzadamente) la rama main tres padres por detrás de HEAD."
]
}
},
@ -228,7 +230,7 @@ exports.level = {
"afterMarkdowns": [
"¡Allá vamos! Las referencias relativas nos proporcionaron una manera concisa de referenciar a `C1`, y forzar la rama (`-f`) nos dio una manera rápida de mover la rama a esa ubicación"
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -238,7 +240,7 @@ exports.level = {
"markdowns": [
"Ahora que viste las referencias relativas y el forzar ramas combinados, usémoslos para resolver el siguiente nivel.",
"",
"Para completar este nivel, mueve `HEAD`, `master` y `bugFix` a sus destinos finales."
"Para completar este nivel, mueve `HEAD`, `main` y `bugFix` a sus destinos finales."
]
}
}
@ -282,9 +284,9 @@ exports.level = {
"",
"Uma das situações mais comuns na qual eu uso referências relativas é quando quero trocar ramos de lugar. Você pode redefinir diretamente o commit para o qual um ramo aponta com a opção `-f`. Desta forma, o seguinte comando:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"Move (à força) o ramo master 3 ancestrais acima do HEAD."
"Move (à força) o ramo main 3 ancestrais acima do HEAD."
]
}
},
@ -297,7 +299,7 @@ exports.level = {
"afterMarkdowns": [
"Aqui vamos nós! As referências relativas nos deram uma forma concisa de nos referirmos ao `C1`, e a movimentação de ramos (com `-f`) nos deu uma forma de apontar rapidamente um ramo para esse local."
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -307,7 +309,7 @@ exports.level = {
"markdowns": [
"Agora que você viu referências relativas e movimentação de ramos combinadas, vamos usá-las para resolver o próximo nível.",
"",
"Para completar este nível, mova o `HEAD` e os ramos `master` e `bugFix` para os destinos mostrados no objetivo."
"Para completar este nível, mova o `HEAD` e os ramos `main` e `bugFix` para os destinos mostrados no objetivo."
]
}
}
@ -351,9 +353,9 @@ exports.level = {
"",
"Un dos usos máis comúns para o uso das referencias relativas é para movelas ramas de lugar. Ti podes reasignar directamente unha rama a un commit usando a opción `-f`. Así que con algo coma:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"Move (de forma forzosa) a rama master 3 commits enriba do HEAD."
"Move (de forma forzosa) a rama main 3 commits enriba do HEAD."
]
}
},
@ -364,9 +366,9 @@ exports.level = {
"Vexamos o comando anterior en acción"
],
"afterMarkdowns": [
"¡Agora é o a nosa quenda! As referencias relativas nos darán unha forma concisa de nos referír a `C1`, e forzar a rama (con `-f`) deunos unha forma rápida de movela rama `master` a esa posición."
"¡Agora é o a nosa quenda! As referencias relativas nos darán unha forma concisa de nos referír a `C1`, e forzar a rama (con `-f`) deunos unha forma rápida de movela rama `main` a esa posición."
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -376,7 +378,7 @@ exports.level = {
"markdowns": [
"Xa viches as referencias relativas e o movemento de ramas combinadas, ímolas usar para resolver o próximo exercicio.",
"",
"Para completar este nivel, mova o `HEAD` e as ramas `master` e `bugFix` para os destinos mostrados no obxectivo."
"Para completar este nivel, mova o `HEAD` e as ramas `main` e `bugFix` para os destinos mostrados no obxectivo."
]
}
}
@ -420,9 +422,9 @@ exports.level = {
"",
"L'une des principales façons dont j'utilise les références relatives est pour réorganiser les branches. Vous pouvez directement réassigner les branches à un commit avec l'option `-f`. Ainsi quelque chose comme :",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"bouge (de force) la branche master à trois parents derrière HEAD."
"bouge (de force) la branche main à trois parents derrière HEAD."
]
}
},
@ -435,7 +437,7 @@ exports.level = {
"afterMarkdowns": [
"On y est ! Les références relatives nous donnent une méthode concise pour référencer `C1` et le forçage de branche (`-f`) nous donne une méthode rapide pour bouger une branche à cet emplacement."
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -445,7 +447,7 @@ exports.level = {
"markdowns": [
"Maintenant que vous avez vu les références relatives et le forçage de branche, utilisons-les pour résoudre le niveau suivant.",
"",
"Pour compléter ce niveau, bouger `HEAD`, `master`, et `bugFix` à leurs destinations désignées."
"Pour compléter ce niveau, bouger `HEAD`, `main`, et `bugFix` à leurs destinations désignées."
]
}
}
@ -459,7 +461,7 @@ exports.level = {
"markdowns": [
"### Der \"~\"-Operator",
"",
"Nehmen wir an du willst viele Schritte im Commit-Baum zurückgehen. Dann wird es schnell mühsam immer wieder `^` einzugeben; deswegen gibt es in Git den Tilde-Operator `~`.",
"Nehmen wir an, du willst viele Schritte im Commit-Baum zurückgehen. Dann wird es schnell mühsam immer wieder `^` einzugeben; deswegen gibt es in Git den Tilde-Operator `~`.",
"",
"Der Tilde-Operator akzeptiert optional eine Zahl, mit der du angeben kannst, wieviele Vorgänger du zurückgehen willst. Keine Anzahl anzugeben, bewirkt dasselbe wie `~1`."
]
@ -469,7 +471,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Geben wir mit `~` an wieviele Commits wir zurückgehen wollen."
"Geben wir mit `~` an, wieviele Commits wir zurückgehen wollen."
],
"afterMarkdowns": [
"Peng! So einfach -- relative Referenzen sind super."
@ -486,11 +488,11 @@ exports.level = {
"",
"Du bist jetzt Experte in Sachen relative Referenzen, also lass sie uns mal richtig einsetzen.",
"",
"Das Verschieben von Branches ist einer der häufigsten Anwendungsfälle dafür. Du kannst einen Branchnamen direkt auf einen bestimmten Commit setzen (_ohne_ ihn vorher ausgecheckt haben zu müssen!) indem du den Parameter `-f` benutzt. So in etwa:",
"Das Verschieben von Branches ist einer der häufigsten Anwendungsfälle dafür. Du kannst einen Branchnamen direkt auf einen bestimmten Commit setzen (_ohne_ ihn vorher ausgecheckt haben zu müssen!), indem du den Parameter `-f` benutzt. So in etwa:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"Das bewegt (erzwungenermaßen) den `master` auf den Commit drei Vorgänger vor `HEAD`."
"Das bewegt (erzwungenermaßen) den `main` auf den Commit drei Vorgänger vor `HEAD`."
]
}
},
@ -503,7 +505,7 @@ exports.level = {
"afterMarkdowns": [
"Das war's schon! Relative Referenzen ermöglichen es uns den Commit `C1` sehr einfach anzugeben und `git branch -f` ermöglicht es uns, den Branch sehr schnell auf diesen Commit zu setzen."
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -513,7 +515,7 @@ exports.level = {
"markdowns": [
"Jetzt wo du relative Referenzen und erzwungenes Branching in Kombination gesehen hast können wir damit den nächsten Level bewältigen.",
"",
"Bewege `HEAD`, `master` und `bugFix` an die jeweils angegebenen Positionen, um diesen Level abzuschließen."
"Bewege `HEAD`, `main` und `bugFix` an die jeweils angegebenen Positionen, um diesen Level abzuschließen."
]
}
}
@ -557,9 +559,9 @@ exports.level = {
"",
"我使用相对引用最多的就是移动分支。可以直接使用 `-f` 选项让分支指向另一个提交。例如:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"上面的命令会将 master 分支强制指向 HEAD 的第 3 级父提交。"
"上面的命令会将 main 分支强制指向 HEAD 的第 3 级父提交。"
]
}
},
@ -572,7 +574,7 @@ exports.level = {
"afterMarkdowns": [
"这就对了! 相对引用为我们提供了一种简洁的引用提交记录 `C1` 的方式， 而 `-f` 则容许我们将分支强制移动到那个位置。"
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -582,7 +584,7 @@ exports.level = {
"markdowns": [
"既然你已经看过相对引用与强制移动分支的演示了，那么赶快使用这些技巧来挑战这一关吧！",
"",
"要完成此关，移动 `HEAD`，`master` 和 `bugFix` 到目标所示的位置。"
"要完成此关，移动 `HEAD`，`main` 和 `bugFix` 到目标所示的位置。"
]
}
}
@ -626,9 +628,9 @@ exports.level = {
"",
"我使用相對引用最多的就是移動分支。你可以使用 `-f` 選項直接讓分支指向另一個 commit。舉個例子:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"（強制）移動 master 指向從 HEAD 往上數的第三個 parent commit。"
"（強制）移動 main 指向從 HEAD 往上數的第三個 parent commit。"
]
}
},
@ -636,7 +638,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"要完成這一關，移動 `HEAD`，`master` 和 `bugFix` 到目標所示的位置。"
"要完成這一關，移動 `HEAD`，`main` 和 `bugFix` 到目標所示的位置。"
]
}
}
@ -680,7 +682,7 @@ exports.level = {
"",
"相対リファレンスのよくある使い方としてあるのは、ブランチの移動です。`-f`オプションを使ってブランチを直接コミットに関連付けられます。次のようになります",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"masterブランチを（強制的に）HEADより親三代前へと移動します。"
]
@ -695,7 +697,7 @@ exports.level = {
"afterMarkdowns": [
"できました！相対リファレンスを使うことで、手短く`C1`を指定することができ、`-f`でブランチを強制的にそこへ移動することができました。"
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -705,7 +707,7 @@ exports.level = {
"markdowns": [
"相対リファレンスとブランチの強制関連付けを見ましたので、いまここでそれらの方法を使ってみましょう。",
"",
"このレベルをクリアするには`HEAD`、`master`、`bugFix`をゴールで指定されている目的位置まで移動してください。"
"このレベルをクリアするには`HEAD`、`main`、`bugFix`をゴールで指定されている目的位置まで移動してください。"
]
}
}
@ -749,9 +751,9 @@ exports.level = {
"",
"Одна из наиболее распространённых целей, для которых используются относительные ссылки - это перемещение веток. Можно напрямую прикрепить ветку к коммиту при помощи опции `-f`. Например, команда:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"Переместит (принудительно) ветку `master` на три родителя назад от `HEAD`."
"Переместит (принудительно) ветку `main` на три родителя назад от `HEAD`."
]
}
},
@ -764,7 +766,7 @@ exports.level = {
"afterMarkdowns": [
"Вуаля! Относительная ссылка дала нам возможность просто сослаться на `C1`, а branch forcing (`-f`) позволил быстро переместить указатель ветки на этот коммит."
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -774,7 +776,7 @@ exports.level = {
"markdowns": [
"Мы рассмотрели относительные ссылки и branch forcing вкупе, так что теперь пришло время пройти следующий уровень.",
"",
"Чтобы пройти этот уровень, передвинь `HEAD`, `master` и `bugFix` так, как показано на визуализации."
"Чтобы пройти этот уровень, передвинь `HEAD`, `main` и `bugFix` так, как показано на визуализации."
]
}
}
@ -818,9 +820,9 @@ exports.level = {
"",
"제가 상대 참조를 사용하는 가장 일반적인 방법은 브랜치를 옮길 때 입니다. `-f` 옵션을 이용해서 브랜치를 특정 커밋에 직접적으로 재지정 할 수 있습니다. 이런 식으로 말이죠:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"(강제로) master 브랜치를 HEAD에서 세번 뒤로 옮겼습니다. (three parents behind HEAD)."
"(강제로) main 브랜치를 HEAD에서 세번 뒤로 옮겼습니다. (three parents behind HEAD)."
]
}
},
@ -832,7 +834,7 @@ exports.level = {
],
"afterMarkdowns": [
"됬네요! 우리는 상대 참조를 통해 `C1`을 간결한 방법으로 참조할 수 있었고 브랜치 강제(`-f`)를 통해 브랜치를 저 위치로 빠르게 옮길 수 있었습니다." ],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -842,7 +844,7 @@ exports.level = {
"markdowns": [
"자 이제 상대 참조와 브랜치 강제의 조합을 봤으니 다음 레벨을 해결해 봅시다.",
"",
"이 레벨을 통과하기 위해서, `HEAD`와 `master`와 `bugFix`를 제시되는 골지점으로 옮겨 주십시오."
"이 레벨을 통과하기 위해서, `HEAD`와 `main`과 `bugFix`를 제시되는 골지점으로 옮겨 주십시오."
]
}
}
@ -886,9 +888,9 @@ exports.level = {
"",
"Один з найуживаніших прийомів де я використовую відносні посилання це переміщення гілок. Ти можеш напряму переспрямувати бранч на якийсь коміт використавши опцію `-f` (force, тобто насильно). Щось на зразок:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"Переміщує (насильно) гілку master на три предки позад HEAD."
"Переміщує (насильно) гілку main на три предки позад HEAD."
]
}
},
@ -901,7 +903,7 @@ exports.level = {
"afterMarkdowns": [
"Ось і маєш! Відносні посилання дають нам зручний спосіб доступу до коміту`C1` крім того форсування бранчів (`-f`) дає нам можливість швидко перемістити гілку на цей коміт"
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -911,7 +913,7 @@ exports.level = {
"markdowns": [
"Тепер, коли ти побачив відносні посилання та форсування гілок в купі, давай використаємо це щоб пройти поточний рівень.",
"",
"Щоб пройти цей рівень, перемісти `HEAD`, `master` та `bugFix` так як показано в візуалізації."
"Щоб пройти цей рівень, перемісти `HEAD`, `main` та `bugFix` так як показано в візуалізації."
]
}
}
@ -955,9 +957,9 @@ exports.level = {
"",
"Tôi thì hay thường dùng tham chiếu tương đối để dịch chuyển nhánh. Bạn có thể trực tiếp gán lại nhánh cho commit với cú pháp `-f`. Kiểu như thế này:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"dịch chuyển (ép buộc) nhánh master lên 3 commit phía trên HEAD."
"dịch chuyển (ép buộc) nhánh main lên 3 commit phía trên HEAD."
]
}
},
@ -970,7 +972,7 @@ exports.level = {
"afterMarkdowns": [
"Đóóóó! Tham chiếu tương đối cho chúng ta một cách chuẩn xác để trỏ tới `C1` và ép nhánh bằng (`-f`) thì dịch chuyển nhanh chóng nhánh tới đó."
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -980,7 +982,7 @@ exports.level = {
"markdowns": [
"Giờ thì bạn đã thấy cách kết hợp tham chiếu tương đối và ép nhánh, dùng chúng để vượt level tiếp thôi.",
"",
"Để hoàn thành cấp độ này, chuyển `HEAD`, `master`, và `bugFix` đến mục tiêu được xác định của chúng."
"Để hoàn thành cấp độ này, chuyển `HEAD`, `main`, và `bugFix` đến mục tiêu được xác định của chúng."
]
}
}
@ -1024,9 +1026,9 @@ exports.level = {
"",
"Eden izmed najpogostejših načinov, kjer uporabljam relativne reference je za premikanje branchev naokoli. Direktno lahko premakneš branch na nek commit z `-f` opcijo. Takole nekako:",
"",
"`git branch -f master HEAD~3`",
"`git branch -f main HEAD~3`",
"",
"premakne (s force-om) master branch tri commite za HEAD."
"premakne (s force-om) main branch tri commite za HEAD."
]
}
},
@ -1039,7 +1041,7 @@ exports.level = {
"afterMarkdowns": [
"Tako ja! Relativne reference so nam dale jedrnat način s katerim se lahko nanašamo na `C1` in branch force-anje (`-f`) nam je omogočilo, da hitro prestavimo branch na to lokacijo."
],
"command": "git branch -f master HEAD~3",
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
@ -1049,11 +1051,80 @@ exports.level = {
"markdowns": [
"Sedaj ko smo si pogledali relativne reference in force branchanje v kombinaciji, uporabimo to, da rešimo naslednjo stopnjo.",
"",
"Za dokončanje te stopnje, premakni `HEAD`, `master` in `bugFix` na njihove ciljne prikazane destinacije."
"Za dokončanje te stopnje, premakni `HEAD`, `main` in `bugFix` na njihove ciljne prikazane destinacije."
]
}
}
]
}
},
"pl": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"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ę (~).",
"",
"",
"Operator tyldy (opcjonalnie) przyjmuje numer porządkowy, który określa liczbę rodziców o ile chcesz się wspiąć. Zobaczmy to w akcji."
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Podajmy liczbę commitów, które chcemy przeskoczyć za `~`."
],
"afterMarkdowns": [
"Boom! Tak szybko - referencje względne są czadowe."
],
"command": "git checkout HEAD~4",
"beforeCommand": "git commit; git commit; git commit"
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"### Forsowanie branczy",
"",
"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:",
"",
"`git branch -f main HEAD~3`",
"",
"przenosi (na siłę) gałąź `main` trzy commity wstecz za HEADa."
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Sprawdźmy poprzednią komendę w akcji."
],
"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."
],
"command": "git branch -f main HEAD~3",
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
}
},
{
"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.",
"",
"Aby ukończyć ten poziom przenieś `HEAD`, `main` oraz `bugFix` do wyświetlonych celów."
]
}
}
]
},
}
};

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

@ -18,7 +18,8 @@ exports.level = {
"ru_RU": "Отмена изменений в Git",
"uk": "Відміна змін в Git",
"vi": "Hoàn tác thay đổi trong Git",
"sl_SI": "Revertanje Sprememb v Gitu"
"sl_SI": "Revertanje Sprememb v Gitu",
"pl": "Odwracanie zmian w Gitcie",
},
"hint": {
"en_US": "Notice that revert and reset take different arguments.",
@ -35,7 +36,8 @@ exports.level = {
"ru_RU": "Обрати внимание, что revert и reset принимают разные параметры.",
"uk": "Зверни увагу на те що revert та reset приймають різні параметри",
"vi": "Lưu ý rằng hoàn tác(revert) và đặt lại(reset) có những đối số khác nhau.",
"sl_SI": "Revert in reset sprejmeta različne argumente."
"sl_SI": "Revert in reset sprejmeta različne argumente.",
"pl": "Zauważ, że revert i reset przyjmują różne argumenty",
},
"startDialog": {
"en_US": {
@ -64,7 +66,7 @@ exports.level = {
"Let's see what that looks like:"
],
"afterMarkdowns": [
"Nice! Git moved the master branch reference back to `C1`; now our local repository is in a state as if `C2` had never happened."
"Nice! Git moved the main branch reference back to `C1`; now our local repository is in a state as if `C2` had never happened."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -127,7 +129,7 @@ exports.level = {
"Veamos cómo es eso:"
],
"afterMarkdowns": [
"¡Genial! git simplemente movió la referencia de la rama master atrás hacia `C1`. Ahora tu repositorio local está en un estado como si `C2` nunca hubiera ocurrido."
"¡Genial! git simplemente movió la referencia de la rama main atrás hacia `C1`. Ahora tu repositorio local está en un estado como si `C2` nunca hubiera ocurrido."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -190,7 +192,7 @@ exports.level = {
"Veamos cómo es eso:"
],
"afterMarkdowns": [
"¡Genial! git simplemente movió la referencia de la rama master atrás hacia `C1`. Ahora tu repositorio local está en un estado como si `C2` nunca hubiera ocurrido."
"¡Genial! git simplemente movió la referencia de la rama main atrás hacia `C1`. Ahora tu repositorio local está en un estado como si `C2` nunca hubiera ocurrido."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -253,7 +255,7 @@ exports.level = {
"Vejamos como funciona:"
],
"afterMarkdowns": [
"Legal! O Git simplesmente moveu a referência do ramo master de volta para `C1`; agora o nosso repositório local está em um estado como se o `C2` nunca tivesse acontecido."
"Legal! O Git simplesmente moveu a referência do ramo main de volta para `C1`; agora o nosso repositório local está em um estado como se o `C2` nunca tivesse acontecido."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -316,7 +318,7 @@ exports.level = {
"Vexamos o seu funcionamento:"
],
"afterMarkdowns": [
"¡Bye bye! Git moveu a referencia da rama master cara atrás, ata o commit `C1`; agora o teu repositorio local está coma se o commit `C2` nunca acontecera."
"¡Bye bye! Git moveu a referencia da rama main cara atrás, ata o commit `C1`; agora o teu repositorio local está coma se o commit `C2` nunca acontecera."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -361,9 +363,9 @@ exports.level = {
"markdowns": [
"## Änderungen in Git rückgängig machen",
"",
"Es gibt viele Möglichkeiten, Änderungen in Git zurückzunehmen. Und ebenso wie das Committen hat auch das rückgängig Machen eine Basis-Komponente (Dateien und Inhalte vormerken) und einen übergeordneten Aspekt (wie die Änderungen tatsächlich zurückgenommen werden). Diese Applikation beschäftigt sich wiederum mit den übergeordneten Vorgängen.",
"Es gibt viele Möglichkeiten, Änderungen in Git zurückzunehmen. Und ebenso wie das Committen hat auch das rückgängig Machen eine Basis-Komponente (Dateien und Inhalte vormerken) und einen übergeordneten Aspekt (wie die Änderungen tatsächlich zurückgenommen werden). Dieses Level beschäftigt sich mit den übergeordneten Vorgängen.",
"",
"Es gibt grundsätzlich zwei Arten in Git etwas rückgängig zu machen -- einerseits `git reset` und andererseit `git revert`. Wir schauen uns beide mal an.",
"Es gibt grundsätzlich zwei Arten in Git etwas rückgängig zu machen -- einerseits `git reset` und andererseits `git revert`. Wir schauen uns beide mal an.",
""
]
}
@ -374,12 +376,12 @@ exports.level = {
"beforeMarkdowns": [
"## Git Reset",
"",
"`git reset` nimm Änderungen zurück, indem es eine Branch-Referenz auf einen anderen Commit setzt. Es ist ein bisschen (aber nicht wirklich) wie \"Geschichte umschreiben\"; `git reset` bewegt einen Branch auf einen anderen Commit, als hätte er nie anders ausgesehen.",
"`git reset` nimmt Änderungen zurück, indem es eine Branch-Referenz auf einen anderen Commit setzt. Es ist ein bisschen (aber nicht wirklich) wie \"Geschichte umschreiben\"; `git reset` bewegt einen Branch auf einen anderen Commit, als hätte er nie anders ausgesehen.",
"",
"Schauen wir, wie das aussieht:"
],
"afterMarkdowns": [
"Schick! Git hat den `master` einfach auf `C1` gesetzt; unser lokales Repository sieht nun so aus, als hätte `C2` nie stattgefunden."
"Schick! Git hat den `main` einfach auf `C1` gesetzt; unser lokales Repository sieht nun so aus, als hätte `C2` nie stattgefunden."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -505,7 +507,7 @@ exports.level = {
"Regardons à quoi cela ressemble :"
],
"afterMarkdowns": [
"Bravo ! Git a simplement déplacé la référence de la branche master en la faisant revenir sur `C1`; désormais notre dépôt est dans le même état que si `C2` n'avait jamais eu lieu."
"Bravo ! Git a simplement déplacé la référence de la branche main en la faisant revenir sur `C1`; désormais notre dépôt est dans le même état que si `C2` n'avait jamais eu lieu."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -569,7 +571,7 @@ exports.level = {
],
"command": "git reset HEAD~1",
"afterMarkdowns": [
"漂亮! Git 把 master 分支移回到 `C1`；现在我们的本地代码库根本就不知道有 `C2` 这个提交了。",
"漂亮! Git 把 main 分支移回到 `C1`；现在我们的本地代码库根本就不知道有 `C2` 这个提交了。",
"",
"（译者注：在reset后， `C2` 所做的变更还在，但是处于未加入暂存区状态。）"
],
@ -634,7 +636,7 @@ exports.level = {
],
"command": "git reset HEAD~1",
"afterMarkdowns": [
"太好了! Git 把 master branch 簡單地移回到 `C1`；現在在我們的 local 已經退回到沒有 commit 過 `C2` 的狀態了。"
"太好了! Git 把 main branch 簡單地移回到 `C1`；現在在我們的 local 已經退回到沒有 commit 過 `C2` 的狀態了。"
],
"beforeCommand": "git commit"
}
@ -696,7 +698,7 @@ exports.level = {
"어떤 그림인지 한번 보죠:"
],
"afterMarkdowns": [
"그림에서처럼 master 브랜치가 가리키던 커밋을 `C1`로 다시 옮겼습니다; 이러면 로컬 저장소에는 마치 `C2`커밋이 아예 없었던 것과 마찬가지 상태가 됩니다."
"그림에서처럼 main 브랜치가 가리키던 커밋을 `C1`로 다시 옮겼습니다; 이러면 로컬 저장소에는 마치 `C2`커밋이 아예 없었던 것과 마찬가지 상태가 됩니다."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -759,7 +761,7 @@ exports.level = {
"Посмотрим, как это работает:"
],
"afterMarkdowns": [
"Неплохо! Git просто перенёс ссылку на `master` обратно на коммит `C1`. Теперь наш локальный репозиторий в состоянии, как будто `C2` никогда не существовал."
"Неплохо! Git просто перенёс ссылку на `main` обратно на коммит `C1`. Теперь наш локальный репозиторий в состоянии, как будто `C2` никогда не существовал."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -822,7 +824,7 @@ exports.level = {
"Давайте подивимося, як це виглядає:"
],
"afterMarkdowns": [
"Чудово! Git перемістив посилання гілки master назад до `C1`; тепер наш локальний репозиторій в такому стані, наче коміту `C2` ніколи не було."
"Чудово! Git перемістив посилання гілки main назад до `C1`; тепер наш локальний репозиторій в такому стані, наче коміту `C2` ніколи не було."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -885,7 +887,7 @@ exports.level = {
"Cùng xem thử nó trông thế nào nào:"
],
"afterMarkdowns": [
"Hay! Git chuyển tham chiếu của master trở lại `C1`; bây giờ kho cá nhân của ta trông như thể commit `C2` chưa bao giờ xảy ra vậy."
"Hay! Git chuyển tham chiếu của main trở lại `C1`; bây giờ kho cá nhân của ta trông như thể commit `C2` chưa bao giờ xảy ra vậy."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -948,7 +950,7 @@ exports.level = {
"Poglejmo kako to izgleda:"
],
"afterMarkdowns": [
"Lepo! Git je premaknil master branch referenco nazaj na `C1`; sedaj je naš lokalen repozitorij v stanju, kot da se `C2` sploh ni nikoli zgodil."
"Lepo! Git je premaknil main branch referenco nazaj na `C1`; sedaj je naš lokalen repozitorij v stanju, kot da se `C2` sploh ni nikoli zgodil."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
@ -984,6 +986,59 @@ exports.level = {
}
}
]
},
"pl": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Odwracanie zmian w Gitcie",
"",
"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.",
"",
"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",
""
]
}
},
{
"type": "GitDemonstrationView",
"options": {
"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.",
"",
"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ł."
],
"command": "git reset HEAD~1",
"beforeCommand": "git commit"
}
},
{
"type": "GitDemonstrationView",
"options": {
"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.",
"",
"W celu odwrócenia zmian i *podzielenia się* tymi odwróconymi zmianami z innymi, musimy użyć `git revert`. Zobaczmy to w akcji."
],
"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`.",
"",
"Dzięki `git revert`, możesz wypchnąć swoje zmiany, by podzielić się nimi z innymi."
],
"command": "git revert HEAD",
"beforeCommand": "git commit"
}
},
]
}
}
};

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

@ -5,7 +5,7 @@ exports.level = {
"git cherry-pick": true
},
"goalTreeString": "%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C7%27%22%2C%22id%22%3A%22master%22%7D%2C%22bugFix%22%3A%7B%22target%22%3A%22C3%27%22%2C%22id%22%3A%22bugFix%22%7D%2C%22side%22%3A%7B%22target%22%3A%22C6%27%22%2C%22id%22%3A%22side%22%7D%2C%22another%22%3A%7B%22target%22%3A%22C7%27%22%2C%22id%22%3A%22another%22%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C4%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C4%22%7D%2C%22C5%22%3A%7B%22parents%22%3A%5B%22C4%22%5D%2C%22id%22%3A%22C5%22%7D%2C%22C6%22%3A%7B%22parents%22%3A%5B%22C5%22%5D%2C%22id%22%3A%22C6%22%7D%2C%22C7%22%3A%7B%22parents%22%3A%5B%22C5%22%5D%2C%22id%22%3A%22C7%22%7D%2C%22C3%27%22%3A%7B%22parents%22%3A%5B%22C2%22%5D%2C%22id%22%3A%22C3%27%22%7D%2C%22C4%27%22%3A%7B%22parents%22%3A%5B%22C3%27%22%5D%2C%22id%22%3A%22C4%27%22%7D%2C%22C5%27%22%3A%7B%22parents%22%3A%5B%22C4%27%22%5D%2C%22id%22%3A%22C5%27%22%7D%2C%22C6%27%22%3A%7B%22parents%22%3A%5B%22C5%27%22%5D%2C%22id%22%3A%22C6%27%22%7D%2C%22C7%27%22%3A%7B%22parents%22%3A%5B%22C6%27%22%5D%2C%22id%22%3A%22C7%27%22%7D%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%7D",
"solutionCommand": "git rebase master bugFix;git rebase bugFix side;git rebase side another;git rebase another master",
"solutionCommand": "git rebase main bugFix;git rebase bugFix side;git rebase side another;git rebase another main",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\"},\"bugFix\":{\"target\":\"C3\",\"id\":\"bugFix\"},\"side\":{\"target\":\"C6\",\"id\":\"side\"},\"another\":{\"target\":\"C7\",\"id\":\"another\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C0\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C4\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"},\"C7\":{\"parents\":[\"C5\"],\"id\":\"C7\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}",
"name": {
"en_US": "Rebasing over 9000 times",
@ -22,24 +22,26 @@ exports.level = {
"ru_RU": "Rebase over 9000 раз",
"uk" : "Rebase over 9000 разів",
"vi" : "Rebase hơn 9000 lần",
"sl_SI": "Več kot 9000 Rebaseov"
"sl_SI": "Več kot 9000 Rebaseov",
"pl" : "Ponad 9000 podbić"
},
"hint": {
"en_US": "Remember, the most efficient way might be to only update master at the end...",
"de_DE": "Nicht vergessen: nur den master zu aktualisieren könnte die effizienteste Möglichkeit sein ...",
"es_AR": "Acordate, la manera más eficiente podría ser actualizar master sólo al final...",
"es_ES": "Recuerda, la manera más eficiente podría ser actualizar master sólo al final...",
"pt_BR": "Lembre-se, a forma mais eficiente pode ser atualizar o master por último...",
"gl" : "Lembra, a forma máis eficiente pode ser actualizar a rama master ó final...",
"fr_FR": "Rappelez-vous, la façon la plus efficace peut être de mettre à jour master seulement à la fin ...",
"en_US": "Remember, the most efficient way might be to only update main at the end...",
"de_DE": "Nicht vergessen: nur den main zu aktualisieren könnte die effizienteste Möglichkeit sein ...",
"es_AR": "Acordate, la manera más eficiente podría ser actualizar main sólo al final...",
"es_ES": "Recuerda, la manera más eficiente podría ser actualizar main sólo al final...",
"pt_BR": "Lembre-se, a forma mais eficiente pode ser atualizar o main por último...",
"gl" : "Lembra, a forma máis eficiente pode ser actualizar a rama main ó final...",
"fr_FR": "Rappelez-vous, la façon la plus efficace peut être de mettre à jour main seulement à la fin ...",
"ja" : "最も効率的なやり方はmasterを最後に更新するだけかもしれない・・・",
"ko": "아마도 master를 마지막에 업데이트하는 것이 가장 효율적인 방법일 것입니다...",
"zh_CN": "记住，最后更新 master 分支可能是最高效的方法……",
"zh_TW": "要記住喔! 把 master branch 留到最後更新可能是最有效率的方法。",
"ko": "아마도 main을 마지막에 업데이트하는 것이 가장 효율적인 방법일 것입니다...",
"zh_CN": "记住，最后更新 main 分支可能是最高效的方法……",
"zh_TW": "要記住喔! 把 main branch 留到最後更新可能是最有效率的方法。",
"ru_RU": "Не забудь, что лучше всего сдвинуть мастер в самом конце...",
"uk" : "Не забувай, що краще всього буде перемістити master в самому кінці... ",
"vi" : "Hãy nhớ rằng, cách tốt nhất có lẽ là nên cuối cùng mới cập nhật nhánh `master`... ",
"sl_SI": "Pomni, morda je najbolj učinkovit način posodabljanje masterja samo na koncu ..."
"uk" : "Не забувай, що краще всього буде перемістити main в самому кінці... ",
"vi" : "Hãy nhớ rằng, cách tốt nhất có lẽ là nên cuối cùng mới cập nhật nhánh `main`... ",
"sl_SI": "Pomni, morda je najbolj učinkovit način posodabljanje masterja samo na koncu ...",
"pl" : "Pamiętaj, że najskuteczniejszym sposobem może być aktualizacja `main` na końcu..."
},
"startDialog": {
"en_US": {
@ -50,7 +52,7 @@ exports.level = {
"markdowns": [
"### Rebasing Multiple Branches",
"",
"Man, we have a lot of branches going on here! Let's rebase all the work from these branches onto master.",
"Man, we have a lot of branches going on here! Let's rebase all the work from these branches onto main.",
"",
"Upper management is making this a bit trickier though -- they want the commits to all be in sequential order. So this means that our final tree should have `C7'` at the bottom, `C6'` above that, and so on, all in order.",
"",
@ -68,7 +70,7 @@ exports.level = {
"markdowns": [
"### Rebaseando múltiples ramas",
"",
"Man, ¡hay un montón de ramas acá! Rebaseemos todo el trabajo de esas ramas sobre master.",
"Man, ¡hay un montón de ramas acá! Rebaseemos todo el trabajo de esas ramas sobre main.",
"",
"La gente de administración nos está haciendo las cosas un poco complicadas, igual -- quieren que nuestros commits estén todos en orden secuencial. Esto significa que nuestro árbol final tendría que tener `C7` al final, `C6` antes de ese, y así siguiendo, todos en orden.",
"",
@ -86,7 +88,7 @@ exports.level = {
"markdowns": [
"### Rebaseando múltiples ramas",
"",
"Fíjate, ¡hay un montón de ramas aquí! Rebaseemos todo el trabajo de esas ramas sobre master.",
"Fíjate, ¡hay un montón de ramas aquí! Rebaseemos todo el trabajo de esas ramas sobre main.",
"",
"La gente de administración nos está haciendo las cosas un poco complicadas, igual -- quieren que nuestros commits estén todos en orden secuencial. Esto significa que nuestro árbol final tendría que tener `C7` al final, `C6` antes de ese, y así siguiendo, todos en orden.",
"",
@ -104,7 +106,7 @@ exports.level = {
"markdowns": [
"### Fazendo rebase em múltiplos ramos",
"",
"Cara, temos um monte de ramos aqui! Vamos fazer um rebase de todo o trabalho contido nesses ramos para o master.",
"Cara, temos um monte de ramos aqui! Vamos fazer um rebase de todo o trabalho contido nesses ramos para o main.",
"",
"No entanto, a cúpula da administração está tornando as coisas mais difíceis -- eles querem que os commits estejam todos em ordem sequencial. Isso significa que a nossa árvore final precisa ter o `C7'` por último, `C6'` acima disso, e assim por diante, tudo ordenado.",
"",
@ -122,7 +124,7 @@ exports.level = {
"markdowns": [
"### Fazendo rebase en múltiples ramas",
"",
"Neno, temos unha chea de ramas aquí! Imos facer rebase de todo o traballo contido nesas ramas para a master.",
"Neno, temos unha chea de ramas aquí! Imos facer rebase de todo o traballo contido nesas ramas para a main.",
"",
"A xente de administración estanos a facer as cousas complicadas, igual eles queren que os commits estén todos en orde secuencial. Isto significa que a nosa árbore final precisa ter `C7'` de último, `C6'` inda por riba, está por adiante, todo ordeado.",
"",
@ -140,7 +142,7 @@ exports.level = {
"markdowns": [
"### Rebaser plusieurs branches",
"",
"Dis-donc, nous avons beaucoup de branches par ici ! Rebasons tout le travail de ces branches dans master.",
"Dis-donc, nous avons beaucoup de branches par ici ! Rebasons tout le travail de ces branches dans main.",
"",
"Les patrons rendent cela encore plus compliqué -- ils veulent que les commits soient fait de manière séquentielle. Cela signifie donc que dans votre arbre final `C7'` est tout en bas, `C6'` juste au-dessus, et ainsi de suite, tout dans cet ordre.",
"",
@ -158,11 +160,11 @@ exports.level = {
"markdowns": [
"### Mehrere Branches rebasen",
"",
"Wow, wir haben hier ja eine Menge Branches! Lass uns mal die ganze Arbeit, die in diesen Branches steckt, auf den `master` packen, um sie auf Stand zu bringen.",
"Wow, wir haben hier ja eine Menge Branches! Lass uns mal die ganze Arbeit, die in diesen Branches steckt, auf den `main` packen, um sie auf Stand zu bringen.",
"",
"Die Führungsetage macht die Sache allerdings etwas trickreicher -- die möchten, dass alle Commits in aufsteigender Reihenfolge geordnet sind. Das heißt unser fertiger Baum sollte `C7` ganz unten haben, darüber `C6` und so weiter und so fort.",
"Die Führungsetage macht die Sache allerdings etwas trickreicher -- sie möchte, dass alle Commits in aufsteigender Reihenfolge geordnet sind. Das heißt unser fertiger Baum sollte `C7` ganz unten haben, darüber `C6` und so weiter und so fort.",
"",
"Wenn du irgendwo einen Fehler machst, benütze ruhig `reset` um wieder von vorne anzufangen oder `undo` um einen Schritt zurückzugehen. Schau dir die Lösung an und versuch es in weniger Schritten hinzubekommen."
"Wenn du irgendwo einen Fehler machst, benütze ruhig `reset` um wieder von vorne anzufangen oder `undo` um einen Schritt zurückzugehen. Schau dir die Lösung an und versuche es in weniger Schritten hinzubekommen."
]
}
}
@ -194,7 +196,7 @@ exports.level = {
"markdowns": [
"### 多分支 rebase",
"",
"哥们儿，我们准备了很多分支！咱们把这些分支 rebase 到 master 上吧。",
"哥们儿，我们准备了很多分支！咱们把这些分支 rebase 到 main 上吧。",
"",
"但是你的领导给你提了点要求 —— 他们希望得到有序的提交历史，也就是我们最终的结果应该是 `C6'` 在 `C7'` 上面， `C5'` 在 `C6'` 上面，依此类推。",
"",
@ -212,7 +214,7 @@ exports.level = {
"markdowns": [
"### rebase 多個 branch",
"",
"嗨！現在我們有很多 branch 了啦！讓我們做一下 rebase，將這些分支接到 master branch 上吧。",
"嗨！現在我們有很多 branch 了啦！讓我們做一下 rebase，將這些分支接到 main branch 上吧。",
"",
"但是你的主管找了點麻煩，他們希望得到有序的 commit history，也就是我們最終的結果是 `C7'` 在最下面，`C6'` 在它上面，以此類推。",
"",
@ -230,7 +232,7 @@ exports.level = {
"markdowns": [
"### 여러 브랜치를 리베이스(rebase)하기 ",
"",
"음, 여기 꽤 여러개의 브랜치가 있습니다! 이 브랜치들의 모든 작업내역을 master에 리베이스 해볼까요?",
"음, 여기 꽤 여러개의 브랜치가 있습니다! 이 브랜치들의 모든 작업내역을 `main` 브랜치에 리베이스 해볼까요?",
"",
"윗선에서 일을 복잡하게 만드네요 -- 그 분들이 이 모든 커밋들을 순서에 맞게 정렬하라고 합니다. 그럼 결국 우리의 최종 목표 트리는 제일 아래에 `C7'` 커밋, 그 위에 `C6'` 커밋, 또 그 위에 순서대로 보여합니다.",
"",
@ -266,7 +268,7 @@ exports.level = {
"markdowns": [
"### Ребейсимо кілька гілок",
"",
"В нас тут до біса гілок! Перенесімо всі зміни з різних гілок в master.",
"В нас тут до біса гілок! Перенесімо всі зміни з різних гілок в main.",
"",
"Але вище керівництво нам не полегшує життя -- вони хочуть, щоб всі коміти були впорядковані. Це означає, що в результаті коміт `C7'` має бути з самого низу, `C6'` трохи вище, і так далі, все за порядком.",
"",
@ -284,7 +286,7 @@ exports.level = {
"markdowns": [
"### Rebase nhiều nhánh",
"",
"Giời ạ, sao mà nhiều nhánh thế khôn biết! Chuyển hết chúng vào `master` thôi.",
"Giời ạ, sao mà nhiều nhánh thế khôn biết! Chuyển hết chúng vào `main` thôi.",
"",
"Nhưng mà cha quản lý lại muốn oái oăm hơn cơ -- hắn muốn tất cả commit xếp thẳng hàng. Nghĩa là cây lịch sử của ta sẽ có `C7'` ở cuối, phía trên là`C6'`, và cứ thế theo đúng thứ tự.",
"",
@ -301,7 +303,7 @@ exports.level = {
"markdowns": [
"### Rebasing Večih Branchev",
"",
"Uf, tu imamo pa res veliko branchev! Pojdimo in rebaseajmo vse delo iz teh branchev na master.",
"Uf, tu imamo pa res veliko branchev! Pojdimo in rebaseajmo vse delo iz teh branchev na main.",
"",
"Toda vodstvo se je odločilo, da le ne bo tako preprosto -- žeijo da so vsi commiti v zaporednem vrstnem redu. To pomeni, da bo naše ciljno drevo moralo imeti `C7'` na dnu, `C6'` nad njim, in tako dalje po vrsti.",
"",

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

@ -51,7 +51,7 @@ exports.level = {
"",
"WOAHHHhhh Nelly! We have quite the goal to reach in this level.",
"",
"Here we have `master` that is a few commits ahead of branches `one` `two` and `three`. For whatever reason, we need to update these three other branches with modified versions of the last few commits on master.",
"Here we have `main` that is a few commits ahead of branches `one` `two` and `three`. For whatever reason, we need to update these three other branches with modified versions of the last few commits on main.",
"",
"Branch `one` needs a re-ordering and a deletion of `C5`. `two` needs pure reordering, and `three` only needs one commit!",
"",
@ -71,7 +71,7 @@ exports.level = {
"",
"WOAHHHhhh ! Nous avons pas mal d'objectifs dans ce niveau.",
"",
"Actuellement nous avons `master` qui se situe quelques commits devant les branches `one` `two` et `three`. Pour une raison quelconque, nous avons besoin de mettre ces trois branches à jour avec les modifications des derniers commits sur master.",
"Actuellement nous avons `main` qui se situe quelques commits devant les branches `one` `two` et `three`. Pour une raison quelconque, nous avons besoin de mettre ces trois branches à jour avec les modifications des derniers commits sur main.",
"",
"La branche `one` a besoin d'une réorganisation et de la suppression de `C5`. `two` doit simplement être réordonnée, et `three` ne nécessite qu'un commit !",
"",
@ -91,7 +91,7 @@ exports.level = {
"",
"¡WOAHHHhhh Nelly! Tenemos un _pequeño_ objetivo al que llegar en este nivel.",
"",
"Tenemos un `master` que está algunos commits adelante de `one`, `two` y `three`. Por alguna razón, necesitamos actualizar esas tres ramas con versiones modificadas de los últimos commits de master.",
"Tenemos un `main` que está algunos commits adelante de `one`, `two` y `three`. Por alguna razón, necesitamos actualizar esas tres ramas con versiones modificadas de los últimos commits de main.",
"",
"La rama `one` necesita reordenarse, y eliminar `C5`. `two` necesita sólo reordenamiento, y `three` ¡sólo necesita un commit!",
"",
@ -111,7 +111,7 @@ exports.level = {
"",
"¡Vaya, vaya! Tenemos un _pequeño_ objetivo al que llegar en este nivel.",
"",
"La rama `master` se encuentra algunos commits por delante de `one`, `two` y `three`. Por alguna razón, necesitamos actualizar esas tres ramas con versiones modificadas de los últimos commits de master.",
"La rama `main` se encuentra algunos commits por delante de `one`, `two` y `three`. Por alguna razón, necesitamos actualizar esas tres ramas con versiones modificadas de los últimos commits de main.",
"",
"La rama `one` necesita reordenarse, y eliminar `C5`. `two` necesita sólo reordenamiento, y `three` ¡sólo necesita un commit!",
"",
@ -131,7 +131,7 @@ exports.level = {
"",
"Uhuuuuu Nelly! Temos um belo de um objetivo para alcançar neste nível.",
"",
"Temos aqui um `master` que está alguns commits atrás dos ramos `one`, `two` e `three`. Seja lá por qual razão, precisamos atualizar esses três outros ramos com versões modificadas dos últimos commits do master.",
"Temos aqui um `main` que está alguns commits atrás dos ramos `one`, `two` e `three`. Seja lá por qual razão, precisamos atualizar esses três outros ramos com versões modificadas dos últimos commits do main.",
"",
"O ramo `one` precisa de uma reordenação e da exclusão do `C5`. O `two` precisa apenas de reordenação. O `three` precisa de um único commit!",
"",
@ -151,7 +151,7 @@ exports.level = {
"",
"¡Íscalle lura! Temos un _pequeno_ obxectivo que acadar neste nivel.",
"",
"Temos aquí un `master` que está algúns commits por detrás das ramas `one`, `two` e `three`. Por algunha razón, precisamos atualizar esas tres ramas con versións modificadas dos últimos commits de master.",
"Temos aquí un `main` que está algúns commits por detrás das ramas `one`, `two` e `three`. Por algunha razón, precisamos atualizar esas tres ramas con versións modificadas dos últimos commits de main.",
"",
"A rama `one` precisa de unha reordenación, e votar fora a `C5`. O `two` precisa apenas de reordenacións. O `three` precisa dun único commit!",
"",
@ -171,7 +171,7 @@ exports.level = {
"",
"Puh! Wir haben ein ganz schön schweres Ziel für dieses Level.",
"",
"Wir haben hier einen `master`, der ein paar Commits weiter ist als die Branche `one`, `two` und `three`. Aus welchem Grund auch immer müssen wir diese drei anderen Branches mit modifizierten Versionen der paar letzten Commits von `master` aktualisieren.",
"Wir haben hier einen `main`, der ein paar Commits weiter ist als die Branche `one`, `two` und `three`. Aus welchem Grund auch immer müssen wir diese drei anderen Branches mit modifizierten Versionen der paar letzten Commits von `main` aktualisieren.",
"",
"Branch `one` benötigt eine Umsortierung und `C5` muss gelöscht werden. `two` muss nur umsortiert werden und `three` braucht nur einen Commit!",
"",
@ -191,7 +191,7 @@ exports.level = {
"",
"なんということでしょう。今回のレベルクリアのために、やることがたくさんあります。",
"",
"いま`master`が指しているコミットの数個前のコミットに、ブランチ`one`、`two`それから`three`があります。何か事情があって、これらの3つのブランチをmasterが指している最新の状態に更新したいケースを考えます。",
"いま`main`が指しているコミットの数個前のコミットに、ブランチ`one`、`two`それから`three`があります。何か事情があって、これらの3つのブランチをmasterが指している最新の状態に更新したいケースを考えます。",
"",
"ブランチ`one`に対しては、順序の変更と`C5`の削除が必要です。`two`では順序の変更のみ、`three`に対しては1回だけコミットすればOKです。",
"",
@ -211,7 +211,7 @@ exports.level = {
"",
"哇塞大神！这关我们要来点不同的！",
"",
"现在我们的 `master` 分支是比 `one`、`two` 和 `three` 要多几个提交。出于某种原因，我们需要把 `master` 分支上最近的几次提交做不同的调整后，分别添加到各个的分支上。",
"现在我们的 `main` 分支是比 `one`、`two` 和 `three` 要多几个提交。出于某种原因，我们需要把 `main` 分支上最近的几次提交做不同的调整后，分别添加到各个的分支上。",
"",
"`one` 需要重新排序并删除 `C5`，`two` 仅需要重排排序，而 `three` 只需要提交一次。",
"",
@ -231,7 +231,7 @@ exports.level = {
"",
"哇塞大神！這關我們要來點不同的！",
"",
"現在我們的 `master` branch 是比 `one` `two` 和 `three` 這三個 branch 多了幾個 commit。由於某種原因，我們需要將 master 所新增的幾個 commit 套用到其它三個 branch 上面。",
"現在我們的 `main` branch 是比 `one` `two` 和 `three` 這三個 branch 多了幾個 commit。由於某種原因，我們需要將 main 所新增的幾個 commit 套用到其它三個 branch 上面。",
"",
"`one` branch 需要重新排序和取消 `C5` 這一個 commit， `two` 需要完全重排，而 `three` 只需要再一個 commit。",
"",
@ -251,7 +251,7 @@ exports.level = {
"",
"음, 이번에는 만만치 않습니다!",
"",
"여기 `master` 브랜치의 몇 번 이전 커밋에 `one`, `two`,`three` 총 3개의 브랜치가 있습니다. 어떤 이유인지는 몰라도, master의 최근 커밋 몇 개를 나머지 세 개의 브랜치에 반영하려고 합니다.",
"여기 `main` 브랜치의 몇 번 이전 커밋에 `one`, `two`,`three` 총 3개의 브랜치가 있습니다. 어떤 이유인지는 몰라도, main의 최근 커밋 몇 개를 나머지 세 개의 브랜치에 반영하려고 합니다.",
"",
"`one` 브랜치는 순서를 바꾸고 `C5`커밋을 삭제하고, `two`브랜치는 순서만 바꾸며, `three`브랜치는 하나의 커밋만 가져옵시다!",
"",
@ -271,7 +271,7 @@ exports.level = {
"",
"УОУ! В этом уровне придётся попотеть!",
"",
"У нас тут по несколько коммитов в ветках `one`, `two` и `three`. Не важно почему, но нам надо видоизменить эти три ветки при помощи более поздних коммитов из ветки `master`.",
"У нас тут по несколько коммитов в ветках `one`, `two` и `three`. Не важно почему, но нам надо видоизменить эти три ветки при помощи более поздних коммитов из ветки `main`.",
"",
"Ветка `one` нуждается в изменении порядка и удалении `C5`. `two` требует полного перемешивания, а `three` хочет получить только один коммит",
"",
@ -291,7 +291,7 @@ exports.level = {
"",
"Ооо Неля! Ну й завданнячко.",
"",
"Ми маємо гілку `master`, яка на кілька комітів попереду гілок `one`, `two` та `three`. З незрозумілих причин, нам потрібно оновити ці гілки більш пізніми змінами з мастеру.",
"Ми маємо гілку `main`, яка на кілька комітів попереду гілок `one`, `two` та `three`. З незрозумілих причин, нам потрібно оновити ці гілки більш пізніми змінами з мастеру.",
"",
"Гілку `one` потрібно впорядкувати і видалити `C5`. Гілку `two` також потрібно впорядкувати, а в гілку `three` потрібно додати ще один коміт!",
"",
@ -311,7 +311,7 @@ exports.level = {
"",
"Chààà, anh bạn! Thử thách lần này hơi khoai đây.",
"",
"Hiện tại thì nhánh `master` đang có nhiều commit hơn các nhánh `one`, `two` và `three`. Vì một lý do nào đó, ta cần cập nhật những commit trên nhánh `master` lên các nhánh còn lại kèm với một vài điều chỉnh .",
"Hiện tại thì nhánh `main` đang có nhiều commit hơn các nhánh `one`, `two` và `three`. Vì một lý do nào đó, ta cần cập nhật những commit trên nhánh `main` lên các nhánh còn lại kèm với một vài điều chỉnh .",
"",
"Nhánh `one` thì cần sắp xếp lại và xóa commit `C5`, trong khi đó nhánh `two` thì đơn giản sắp xếp, còn `three` thì chỉ cần một commit!",
"",
@ -330,7 +330,7 @@ exports.level = {
"",
"WOAHHHhhh Miško! Ta stopnja bo pa pravi izziv.",
"",
"Tu imamo `master`, ki je nekaj commitov pred branchi `one`, `two` in `three`. Iz neznanega razloga moramo posodobiti te tri druge branche z modificiranimi različicami zadnjih nekaj commitov na masterju.",
"Tu imamo `main`, ki je nekaj commitov pred branchi `one`, `two` in `three`. Iz neznanega razloga moramo posodobiti te tri druge branche z modificiranimi različicami zadnjih nekaj commitov na masterju.",
"",
"Branch `one` potrebuje prerazporeditev in izbris `C5`. `two` rabi samo prerazporeditev, `three` pa potrebuje samo en commit!",
"",

6
src/levels/remote/clone.js
View file

@ -503,9 +503,9 @@ exports.level = {
"",
"Nichts desto weniger haben entfernte Repositorys eine Menge toller Eigenschaften:",
"",
"- Vor allem: sie sind ein super Backup! Lokale Git-Repositorys können deine Arbeitskopie ein jeden beliebigen früheren Zustand versetzen (wie du ja weißt), aber all diese Informationen liegen eben bei dir lokal. Wenn es Kopien von deinem Repository auf anderen Rechnern gibt, kannst du ruhig all deine Daten verlieren und trotzdem genau da weitermachen, wo du aufgehört hast.",
"- Vor allem: sie sind ein super Backup! Lokale Git-Repositorys können deine Arbeitskopie in jeden beliebigen früheren Zustand versetzen (wie du ja weißt), aber all diese Informationen liegen eben bei dir lokal. Wenn es Kopien von deinem Repository auf anderen Rechnern gibt, kannst du ruhig all deine Daten verlieren und trotzdem genau da weitermachen, wo du aufgehört hast.",
"",
"- Noch wichtiger: Remotes geben dem Entwickeln eine soziale Komponente! Wenn eine Kopie deines Projekts woanders liegt können deine Freunde sehr einfach etwas zu dem Projekt beitragen (oder sich deine neuesten Änderungen holen).",
"- Noch wichtiger: Remotes geben dem Entwickeln eine soziale Komponente! Wenn eine Kopie deines Projekts woanders liegt, können deine Freunde sehr einfach etwas zu dem Projekt beitragen (oder sich deine neuesten Änderungen holen).",
"",
"Websites, die die Aktivitäten um diese entfernten Repositorys darstellen (wie [GitHub](https://github.com/) oder [Phabricator](http://phabricator.org/)) erfreuen sich zunehmender Beliebtheit, aber entfernte Repositorys sind _immer_ das Rückgrat für diese Werkzeuge. Deshalb ist es wichtig, sie zu verstehen."
]
@ -519,7 +519,7 @@ exports.level = {
"",
"Bis jetzt hat sich Learn Git Branching darauf konzentriert, die Grundlagen der _lokalen_ Arbeit mit Repositorys zu vermitteln (Branche anlegen, zusammenführen, Rebasen etc). Jetzt wollen wir allerdings lernen mit entfernten Repositorys zu arbeiten und brauchen für die Level eine entsprechende Umgebung. Die schaffen wir mit `git clone`.",
"",
"In der Realität ist `git clone` eigentlich der Befehl, mit dem du eine _lokale_ Kopie eines _entfernten_ Repositorys erstellst (das zum Beispiel auf GitHub liegt). Wir benutzen diesen Befehl in Learn Git Branching allerdings ein wenig anders -- hier macht `git clone` tatsächlich eine Kopie von deinem lokalen Repository auf einem \"entfernten Server\". Klar, das ist eigentlich genau das Gegenteil von dem was der echte Befehl macht, aber es hilft den Zusammenhang zwischen Cloning und der Arbeit mit entfernten Repositorys herzustellen, also machen wir's einfach so.",
"In der Realität ist `git clone` eigentlich der Befehl, mit dem du eine _lokale_ Kopie eines _entfernten_ Repositorys erstellst (das zum Beispiel auf GitHub liegt). Wir benutzen diesen Befehl in Learn Git Branching allerdings ein wenig anders -- hier macht `git clone` stattdessen eine Kopie von deinem lokalen Repository auf einem \"entfernten Server\". Klar, das ist eigentlich genau das Gegenteil von dem, was der echte Befehl macht, aber es hilft den Zusammenhang zwischen Cloning und der Arbeit mit entfernten Repositorys herzustellen, also machen wir's einfach so.",
""
]
}

30
src/levels/remote/fakeTeamwork.js
View file

@ -57,7 +57,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"The default behavior of `fakeTeamwork` is to simply plop down a commit on master."
"The default behavior of `fakeTeamwork` is to simply plop down a commit on main."
],
"afterMarkdowns": [
"There we go -- the remote was updated with a new commit, and we haven't downloaded that commit yet because we haven't run `git fetch`."
@ -111,7 +111,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Le comportement par défaut de `fakeTeamwork` est tout simplement de faire apparaître un commit sur le master distant :"
"Le comportement par défaut de `fakeTeamwork` est tout simplement de faire apparaître un commit sur le main distant :"
],
"afterMarkdowns": [
"Voilà : le dépôt distant a été mis à jour avec un nouveau commit, et nous n'avons pas encore téléchargé ce commit parce que nous n'avons pas exécuté la commande `git fetch`."
@ -165,7 +165,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"El comportamiento por default de `fakeTeamwork` es simplemente crear un commit en master."
"El comportamiento por default de `fakeTeamwork` es simplemente crear un commit en main."
],
"afterMarkdowns": [
"Ahí está: el remoto se actualizó con un nuevo commit, y todavía no nos bajamos ese commit porque aún no hicimos `git fetch`."
@ -219,7 +219,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"El comportamiento por default de `fakeTeamwork` es simplemente crear un commit en master."
"El comportamiento por default de `fakeTeamwork` es simplemente crear un commit en main."
],
"afterMarkdowns": [
"Ahí está: el remoto se actualizó con un nuevo commit, y todavía no nos bajamos ese commit porque aún no hicimos `git fetch`."
@ -273,7 +273,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"O comportamento padrão do `fakeTeamwork` é simplesmente fazer aparecer um commit no master."
"O comportamento padrão do `fakeTeamwork` é simplesmente fazer aparecer um commit no main."
],
"afterMarkdowns": [
"Aqui vamos nos -- o repositório remoto foi atualizado com um novo commit, e ainda não baixamos esse commit porque não executamos um `git fetch`."
@ -327,7 +327,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"O comportamento por defecto de `fakeTeamwork` é simplemente crear un commit en master na rama remota."
"O comportamento por defecto de `fakeTeamwork` é simplemente crear un commit en main na rama remota."
],
"afterMarkdowns": [
"Ahí o tes: a rama remota actualizouse cun novo commit, e aínda non nos baixamos ese commit porque inda non fixemos `git fetch`."
@ -381,7 +381,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"`fakeTeamwork` 的預設行為是在送一個 commit 給 master 分支"
"`fakeTeamwork` 的預設行為是在送一個 commit 給 main 分支"
],
"afterMarkdowns": [
"我就說吧！remote 已經藉由一個新的 commit 而更新了，而且因為我們還沒有用 `git fetch`，所以表示我們還沒有下載該 commit。"
@ -435,7 +435,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"`fakeTeamwork` 默认操作就是在远程仓库的 master 分支上做一次提交。"
"`fakeTeamwork` 默认操作就是在远程仓库的 main 分支上做一次提交。"
],
"afterMarkdowns": [
"完成了 —— 远程仓库增加了一个新提交，我们还没有下载它，因为我们还没有执行 `git fetch`。"
@ -479,7 +479,7 @@ exports.level = {
"",
"Hier ist das Problem -- für einige der folgenden Level müssen wir lernen, wie man Änderungen vom entfernten Server holt.",
"",
"Das heißt wir müssen im Grunde \"so tun\" also ob der Server von einem Kollegen / Freund / Mitarbeiter aktualisiert worden wäre, manchmal ein bestimmter Branch oder eine bestimmte Anzahl von Commits.",
"Das heißt wir müssen im Grunde \"so tun\", als ob der Server von einem Kollegen / Freund / Mitarbeiter aktualisiert worden wäre, manchmal ein bestimmter Branch oder eine bestimmte Anzahl von Commits.",
"",
"Um das zu tun führen wir den passend benannten Befehl `git fakeTeamwork` ein! Er ist ziemlich selbsterklärend, schauen wir uns ihn an ..."
]
@ -489,10 +489,10 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Das normale Verhalten von `fakeTeamwork` ist es, einen Commit auf den entfernten `master` zu machen."
"Das normale Verhalten von `fakeTeamwork` ist es, einen Commit auf den entfernten `main` zu machen."
],
"afterMarkdowns": [
"Da haben wir's -- der Server ist mit einem neuen Commit aktualisiert worden und wir haben ihn noch nicht lokal, weil wir nicht `git fetch` oder `git pull` ausgeführt haben."
"Da haben wir's -- der Server ist mit einem neuen Commit aktualisiert worden und wir haben ihn noch nicht lokal, weil wir weder `git fetch` noch `git pull` ausgeführt haben."
],
"command": "git fakeTeamwork",
"beforeCommand": "git clone"
@ -543,7 +543,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Поведение команды `fakeTeamwork` по умолчанию заключается в том, чтобы просто \"инициировать\" коммит на master-е"
"Поведение команды `fakeTeamwork` по умолчанию заключается в том, чтобы просто \"инициировать\" коммит на main-е"
],
"afterMarkdowns": [
"Ну вот - удалённый репозиторий был изменён при помощи добавления нового коммита, и мы ещё не скачали этот коммит, потому что не запустили команду `git fetch`."
@ -653,7 +653,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"За замовчуванням `fakeTeamwork` просто додасть коміт в гілку `master`."
"За замовчуванням `fakeTeamwork` просто додасть коміт в гілку `main`."
],
"afterMarkdowns": [
"Є -- до віддаленого репозиторію додався ще один коміт, проте ми ще його не звантажили, оскільки ще не виконали `git fetch`."
@ -761,7 +761,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Hành xử mặc định của `fakeTeamwork` đơn giản là tạo ra một commit ở trên nhánh master từ xa."
"Hành xử mặc định của `fakeTeamwork` đơn giản là tạo ra một commit ở trên nhánh main từ xa."
],
"afterMarkdowns": [
"Đó -- kho chứa từ xa đã được cập nhật thêm một commit, và ta chưa tải commit đó xuống vì ta chưa hề chạy lệnh `git fetch`."
@ -815,7 +815,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Privzeto delovanje `fakeTeamwork` je, da samo doda commit na master:"
"Privzeto delovanje `fakeTeamwork` je, da samo doda commit na main:"
],
"afterMarkdowns": [
"Tako -- oddaljen repo je bil posodobljen z novim commitom, katerega še nismo potegnili k sebi, ker še nismo pognali ukaza `git fetch`."

98
src/levels/remote/fetch.js
View file

@ -60,7 +60,7 @@ exports.level = {
"Before getting into the details of `git fetch`, let's see it in action! Here we have a remote repository that contains two commits that our local repository does not have."
],
"afterMarkdowns": [
"There we go! Commits `C2` and `C3` were downloaded to our local repository, and our remote branch `o/master` was updated to reflect this."
"There we go! Commits `C2` and `C3` were downloaded to our local repository, and our remote branch `o/main` was updated to reflect this."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -75,7 +75,7 @@ exports.level = {
"`git fetch` performs two main steps, and two main steps only. It:",
"",
"* downloads the commits that the remote has but are missing from our local repository, and...",
"* updates where our remote branches point (for instance, `o/master`)",
"* updates where our remote branches point (for instance, `o/main`)",
"",
"`git fetch` essentially brings our _local_ representation of the remote repository into synchronization with what the _actual_ remote repository looks like (right now).",
"",
@ -92,7 +92,7 @@ exports.level = {
"markdowns": [
"### What fetch doesn't do",
"",
"`git fetch`, however, does not change anything about _your_ local state. It will not update your `master` branch or change anything about how your file system looks right now.",
"`git fetch`, however, does not change anything about _your_ local state. It will not update your `main` branch or change anything about how your file system looks right now.",
"",
"This is important to understand because a lot of developers think that running `git fetch` will make their local work reflect the state of the remote. It may download all the necessary data to do that, but it does _not_ actually change any of your local files. We will learn commands in later lessons to do just that :D",
"",
@ -133,7 +133,7 @@ exports.level = {
"Avant d'aller dans les détails de `git fetch`, voyons-le en action ! Ici nous avons un dépôt distant qui contient deux commits que notre dépôt local n'a pas."
],
"afterMarkdowns": [
"Voilà ! Les commits `C2` et `C3` ont été téléchargés dans notre dépôt local, et notre branche distante `o/master` a été mise à jour pour refléter cela."
"Voilà ! Les commits `C2` et `C3` ont été téléchargés dans notre dépôt local, et notre branche distante `o/main` a été mise à jour pour refléter cela."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -148,7 +148,7 @@ exports.level = {
"`git fetch` procède en deux étapes principales, ni plus ni moins. Cela :",
"",
"* télécharge les commits que le dépôt distant possède mais qui ne sont pas dans le nôtre, puis...",
"* met à jour nos branches distantes (par exemple, `o/master`).",
"* met à jour nos branches distantes (par exemple, `o/main`).",
"",
"`git fetch` prend en fait notre représentation _locale_ du dépôt distant pour la synchroniser avec ce à quoi le dépôt distant ressemble _réellement_ (à ce moment-là).",
"",
@ -165,7 +165,7 @@ exports.level = {
"markdowns": [
"### Ce que fetch ne fait pas",
"",
"`git fetch`, cependant, ne change rien à _votre_ état local. Il ne met pas à jour votre branche `master` et ne va pas changer quelque chose aux fichiers qui se trouvent actuellement dans votre répertoire de travail.",
"`git fetch`, cependant, ne change rien à _votre_ état local. Il ne met pas à jour votre branche `main` et ne va pas changer quelque chose aux fichiers qui se trouvent actuellement dans votre répertoire de travail.",
"",
"C'est important à comprendre car un nombre important de développeurs pensent qu'exécuter `git fetch` va mettre leur dépôt local dans le même état que le distant. Cela peut télécharger toutes les données nécessaires pour faire cela, mais cela ne change en réalité _rien_ sur vos fichiers locaux. Les prochains niveaux seront justement dédiés aux commandes qui permettent de faire cela :D",
"",
@ -206,7 +206,7 @@ exports.level = {
"Antes de entrar en los detalles de `git fetch`, veámoslo en acción. Acá tenemos un repositorio remoto que contiene dos commits que nuestro repositorio local no tiene."
],
"afterMarkdowns": [
"¡Ahí vamos! Bajamos los commits `C2` y `C3` a nuestro repositorio local, y nuestra rama remota `o/master` fue actualizada para reflejar este cambio."
"¡Ahí vamos! Bajamos los commits `C2` y `C3` a nuestro repositorio local, y nuestra rama remota `o/main` fue actualizada para reflejar este cambio."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -221,7 +221,7 @@ exports.level = {
"`git fetch` hace dos simples pasos, y sólo dos simples pasos:",
"",
"* baja los commits que el remoto tiene pero no están en nuestro repositorio local, y...",
"* actualiza a dónde apuntan nuestras ramas remotas (por ejemplo, `o/master`)",
"* actualiza a dónde apuntan nuestras ramas remotas (por ejemplo, `o/main`)",
"",
"`git fetch` esencialmente sincroniza nuestra representación _local_ del repositorio remoto con el _verdadero_ estado del repositorio remoto (en este momento).",
"",
@ -238,7 +238,7 @@ exports.level = {
"markdowns": [
"### ¿Qué *no* hace fetch?",
"",
"Sin embargo, `git fetch` no modifica en absoluto _tu_ estado local. No va a actualizar tu rama `master` ni va a cambiar nada sobre cómo se ve tu sistema de archivos en este momento.",
"Sin embargo, `git fetch` no modifica en absoluto _tu_ estado local. No va a actualizar tu rama `main` ni va a cambiar nada sobre cómo se ve tu sistema de archivos en este momento.",
"",
"Es importante entender esto, porque un montón de desarrolladores piensan que correr `git fetch` hará que su estado local refleje el estado del remoto. `git fetch` puede descargar los datos necesarios para hacerlo, pero *no* cambia ninguno de tus archivos locales. Vamos a aprender otros comandos para hacer eso más adelante :D",
"",
@ -279,7 +279,7 @@ exports.level = {
"Antes de entrar en los detalles de `git fetch`, veámoslo en acción. Aquí tenemos un repositorio remoto que contiene dos commits que nuestro repositorio local no tiene."
],
"afterMarkdowns": [
"¡Allá vamos! Bajamos los commits `C2` y `C3` a nuestro repositorio local, y nuestra rama remota `o/master` fue actualizada para reflejar este cambio."
"¡Allá vamos! Bajamos los commits `C2` y `C3` a nuestro repositorio local, y nuestra rama remota `o/main` fue actualizada para reflejar este cambio."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -294,7 +294,7 @@ exports.level = {
"`git fetch` hace dos simples pasos, y sólo dos simples pasos:",
"",
"* baja los commits que el remoto tiene pero no están en nuestro repositorio local, y...",
"* actualiza a dónde apuntan nuestras ramas remotas (por ejemplo, `o/master`)",
"* actualiza a dónde apuntan nuestras ramas remotas (por ejemplo, `o/main`)",
"",
"`git fetch` escencialmente sincroniza nuestra representación _local_ del repositorio remoto con el _verdadero_ estado del repositorio remoto (en este momento).",
"",
@ -311,7 +311,7 @@ exports.level = {
"markdowns": [
"### ¿Qué *no* hace fetch?",
"",
"Sin embargo, `git fetch` no modifica en absoluto _tu_ estado local. No va a actualizar tu rama `master` ni va a cambiar nada sobre cómo se ve tu sistema de archivos en este momento.",
"Sin embargo, `git fetch` no modifica en absoluto _tu_ estado local. No va a actualizar tu rama `main` ni va a cambiar nada sobre cómo se ve tu sistema de archivos en este momento.",
"",
"Es importante entender esto, porque un montón de desarrolladores piensan que correr `git fetch` hará que su estado local refleje el estado del remoto. `git fetch` puede descargar los datos necesarios para hacerlo, pero *no* cambia ninguno de tus archivos locales. Vamos a aprender otros comandos para hacer eso más adelante :D",
"",
@ -352,7 +352,7 @@ exports.level = {
"Antes de entrar nos detalhes do `git fetch`, vejamo-no em ação! Aqui temos um repositório remoto que contém dois commits que nosso repositório local não possui."
],
"afterMarkdowns": [
"Lá vamos nós! Os commits `C2` e `C3` foram baixados para o nosso repositório local, e nosso ramo remoto `o/master` foi atualizado para refletir esse fato."
"Lá vamos nós! Os commits `C2` e `C3` foram baixados para o nosso repositório local, e nosso ramo remoto `o/main` foi atualizado para refletir esse fato."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -367,7 +367,7 @@ exports.level = {
"O `git fetch` realiza dois passos principais, e somente estes dois passos principais. Ele:",
"",
"* Baixa os commits que o repositório remoto possui mas que estão faltando no repositório local, e...",
"* Atualiza a referência para a qual os ramos remotos (por exemplo, `o/master`) estão apontando",
"* Atualiza a referência para a qual os ramos remotos (por exemplo, `o/main`) estão apontando",
"",
"O `git fetch` essencialmente faz com que nossa representação _local_ do repositório remoto fique sincronizada com a forma com que o repositório remoto _de fato_ se parece (naquele momento).",
"",
@ -384,7 +384,7 @@ exports.level = {
"markdowns": [
"### O que o fetch NÃO faz",
"",
"O `git fetch`, no entanto, não muda nada do estado _local_ do repositório. Ele não atualiza o seu ramo `master` nem muda nada na forma como o seu sistema de arquivos está no momento.",
"O `git fetch`, no entanto, não muda nada do estado _local_ do repositório. Ele não atualiza o seu ramo `main` nem muda nada na forma como o seu sistema de arquivos está no momento.",
"",
"É importante entender isso, pois muitos desenvolvedores pensam que executar `git fetch` fará com que o trabalho local reflita o estado do repositório remoto. Ele pode até baixar todos os dados necessários para fazê-lo, mas ele _não_ muda de fato nenhum dos arquivos locais. Vamos aprender comandos para fazê-lo nas lições a seguir :D",
"",
@ -425,7 +425,7 @@ exports.level = {
"Ántes de entrar nos detalles de `git fetch`, vexámolo en acción! Aquí temos un repositorio remoto que contén dous commits que o noso repositorio local non ten."
],
"afterMarkdowns": [
"Alá imos! Os commits `C2` e `C3` baixáronse ó noso repositorio local, e a nosa rama `o/master` actualizouse para reflexar ese cambio."
"Alá imos! Os commits `C2` e `C3` baixáronse ó noso repositorio local, e a nosa rama `o/main` actualizouse para reflexar ese cambio."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -440,7 +440,7 @@ exports.level = {
"`git fetch` fai dous pasos pasos principais, e soamente estes dous pasos princpipais. Son:",
"",
"* Baixa os commits que o repositório remoto contén pero non temos nos no noso repositoiro local, e...",
"* Actualiza a referencia nas ramas remotas (por exemplo, `o/master`) nas que se está apuntando",
"* Actualiza a referencia nas ramas remotas (por exemplo, `o/main`) nas que se está apuntando",
"",
"`git fetch` esencialmente fai que a nosa representación _local_ do repositorio remoto se sincronice ca forma que posúe o repositorio remoto, _de feito_ parecese (nese momento).",
"",
@ -457,7 +457,7 @@ exports.level = {
"markdowns": [
"### O que fetch NON fai",
"",
"`git fetch`, por agora, non cambia nada no estado _local_ do repositorio. El solo actualiza a rama `master` sen facer cambios na forma de cómo está o teu sistema de arquivos nese momento.",
"`git fetch`, por agora, non cambia nada no estado _local_ do repositorio. El solo actualiza a rama `main` sen facer cambios na forma de cómo está o teu sistema de arquivos nese momento.",
"",
"É importante entender iso, xa que moitos desenvolvedores pensan que executar `git fetch` fará que o traballo local se vexa modificado polo repositorio remoto. El pode que baixara todos os cambios necesarios para facelo, pero, o comando _non_ cambia cómo están os teus arquivos locais. Imos aprender comandos para facer esas conexións :D",
"",
@ -498,7 +498,7 @@ exports.level = {
"在講到 `git fetch` 的細節之前，我們要先來看一下例子！在這裡我們有一個新增了兩個 commit 的 remote repository，而且我們的 local repository 並沒有包含這兩個 commit。"
],
"afterMarkdowns": [
"看吧！commit `C2` 以及 `C3` 已經被下載到我們的 local repository，而且我們的 remote branch `o/master` 也更新了。"
"看吧！commit `C2` 以及 `C3` 已經被下載到我們的 local repository，而且我們的 remote branch `o/main` 也更新了。"
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -513,7 +513,7 @@ exports.level = {
"`git fetch` 只有執行了兩個主要步驟，包含：",
"",
"* 下載 remote 有的 commit，但是在我們的 local repository 是沒有該 commit。還有...",
"* 更新我們 remote branch 所指向的地方（例如， `o/master`）",
"* 更新我們 remote branch 所指向的地方（例如， `o/main`）",
"",
"基本上，`git fetch` 同步了我們的 local repository 以及 remote repository 的最新狀態。",
"",
@ -530,7 +530,7 @@ exports.level = {
"markdowns": [
"### fetch 沒有做的事情",
"",
"然而，`git fetch` 並不會影響到在你的 local repository 中的 `master` branch，他並不會將你的 `master` branch 更新到最新的狀態。",
"然而，`git fetch` 並不會影響到在你的 local repository 中的 `main` branch，他並不會將你的 `main` branch 更新到最新的狀態。",
"",
"這個觀念很重要，因為很多程式設計師以為 `git fetch` 可以讓他們在 local repository 上面的工作跟 remote repository 的工作可以同步。它是會下載同步所需的資料，但是不會更新任何的檔案，我們會在後面的教學中提到如何做到這件事情。:D",
"",
@ -560,7 +560,7 @@ exports.level = {
"",
"本节课我们将学习如何从远程仓库获取数据 —— 命令如其名，它就是 `git fetch`。",
"",
"你会看到当我们从远程仓库获取数据时, 远程分支也会更新以反映最新的远程仓库。在上一了我们已经提及过这一点了。"
"你会看到当我们从远程仓库获取数据时, 远程分支也会更新以反映最新的远程仓库。在上一节课程中我们已经提及过这一点了。"
]
}
},
@ -571,7 +571,7 @@ exports.level = {
"在解释 `git fetch` 前，我们先看看实例。这里我们有一个远程仓库, 它有两个我们本地仓库中没有的提交。"
],
"afterMarkdowns": [
"就是这样了! `C2`,`C3` 被下载到了本地仓库，同时远程分支 `o/master` 也被更新，反映到了这一变化"
"就是这样了! `C2`,`C3` 被下载到了本地仓库，同时远程分支 `o/main` 也被更新，反映到了这一变化"
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -586,7 +586,7 @@ exports.level = {
"`git fetch` 完成了仅有的但是很重要的两步:",
"",
"* 从远程仓库下载本地仓库中缺失的提交记录",
"* 更新远程分支指针(如 `o/master`)",
"* 更新远程分支指针(如 `o/main`)",
"",
"`git fetch` 实际上将本地仓库中的远程分支更新成了远程仓库相应分支最新的状态。",
"",
@ -603,7 +603,7 @@ exports.level = {
"markdowns": [
"### git fetch 不会做的事",
"",
"`git fetch` 并不会改变你本地仓库的状态。它不会更新你的 `master` 分支，也不会修改你磁盘上的文件。",
"`git fetch` 并不会改变你本地仓库的状态。它不会更新你的 `main` 分支，也不会修改你磁盘上的文件。",
"",
"理解这一点很重要，因为许多开发人员误以为执行了 `git fetch` 以后，他们本地仓库就与远程仓库同步了。它可能已经将进行这一操作所需的所有数据都下载了下来，但是**并没有**修改你本地的文件。我们在后面的课程中将会讲解能完成该操作的命令 :D",
"",
@ -631,7 +631,7 @@ exports.level = {
"",
"In Git mit entfernten Repositorys zu arbeiten lässt sich wirklich auf das Hin- und Zurückübertragen von Daten reduzieren. Solange wir Commits hin und her schicken können, können wir jede Art Update teilen, das von Git getrackt wird (und somit Arbeit, neue Dateien, neue Ideen, Liebesbriefe etc. teilen).",
"",
"In diesem Level werden wir lernen, wie man Daten _von_ einem entfernten Repository holt -- der entsprechende Befehl heißt praktischerweise `git fetch`.",
"In diesem Level werden wir lernen, wie man Daten _von_ einem entfernten Repository holt -- der entsprechende Befehl heißt `git fetch`.",
"",
"Dir wird auffallen, dass mit der Aktualisierung unserer Darstellung des entfernten Repositorys die _Remote_ Branches auf den neuesten Stand gebracht werden. Das passt zum vorherigen Level über Remote Branches."
]
@ -641,10 +641,10 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Bevor wir uns die Einzelheiten von `git fetch` ansehen wollen wir es mal in Aktion sehen. Wir haben hier ein entferntes Repository, das zwei Commits hat die in unserem lokalen Repository fehlen."
"Bevor wir uns die Einzelheiten von `git fetch` ansehen wollen wir es mal in Aktion sehen. Wir haben hier ein entferntes Repository, das zwei Commits hat, die in unserem lokalen Repository fehlen."
],
"afterMarkdowns": [
"Das war's! Die Commits `C2` und `C3` wurden zu unserem Repository heruntergeladen und unser Remote Branch `o/master` wurde aktualisiert."
"Das war's! Die Commits `C2` und `C3` wurden zu unserem Repository heruntergeladen und unser Remote Branch `o/main` wurde aktualisiert."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -659,9 +659,9 @@ exports.level = {
"`git fetch` führt genau zwei Schritte aus:",
"",
"* Es lädt die Commits herunter, die im lokalen Repository fehlen, und ...",
"* aktualisiert die Remote Branches wo nötig (zum Beispiel, `o/master`).",
"* aktualisiert die Remote Branches wo nötig (zum Beispiel `o/main`).",
"",
"`git fetch` synchronisiert im Prinzip unsere _lokale_ Abbildung des entfernten Repositorys mit dem wie das entfernte Repository _tatsächlich_ aussieht (in diesem Moment).",
"`git fetch` synchronisiert im Prinzip unsere _lokale_ Abbildung des entfernten Repositorys mit dem, wie das entfernte Repository _tatsächlich_ aussieht (in diesem Moment).",
"",
"Wie du dich vielleicht erinnerst, haben wir im letzten Level gesagt, dass die Remote Branches den Zustand der Branches auf dem entfernten Repository darstellen _seit_ du das letzte Mal dieses Repository angesprochen hast. `git fetch` ist die Methode mit der du das Repository ansprichst! Der Zusammenhang zwischen Remote Branches und `git fetch` ist damit hoffentlich klar.",
"",
@ -676,9 +676,9 @@ exports.level = {
"markdowns": [
"### Was Fetch nicht tut",
"",
"`git fetch` ändert allerdings überhaupt nichts an _deinen_ lokalen Branches. Es aktualisiert nicht deinen `master` oder ändert irgendetwas an deinem Checkout.",
"`git fetch` ändert allerdings überhaupt nichts an _deinen_ lokalen Branches. Es aktualisiert nicht deinen `main` oder ändert irgendetwas an deinem Checkout.",
"",
"Das ist wichtig zu wissen, denn eine Menge Entwickler glauben, wenn sie `git fetch` ausführen würden ihre lokalen Branches auf den Stand des entfernten Repositorys gebracht. Es lädt zwar alle Daten herunter, damit man diese Aktualisierung durchführen kann, aber es ändert _nichts_ an deinen lokalen Branches. Wir werden in späteren Level Befehle genau dafür kennenlernen. :D",
"Das ist wichtig zu wissen, denn eine Menge Entwickler glauben, wenn sie `git fetch` ausführen, würden ihre lokalen Branches auf den Stand des entfernten Repositorys gebracht. Es lädt zwar alle Daten herunter, damit man diese Aktualisierung durchführen kann, aber es ändert _nichts_ an deinen lokalen Branches. Wir werden in späteren Level Befehle genau dafür kennenlernen. :D",
"",
"Am Ende des Tages kannst du dir `git fetch` also als den Download-Schritt vorstellen."
]
@ -717,7 +717,7 @@ exports.level = {
"`git fetch`の説明に入る前に、その動作を見てみましょう。ここに、ローカルリポジトリにない二個のコミットを含んでいるリモートブランチがあります。"
],
"afterMarkdowns": [
"やりました！`C2`、`C3`コミットがローカルリポジトリにダウンロードされ、`o/master`リモートブランチに反映されました。"
"やりました！`C2`、`C3`コミットがローカルリポジトリにダウンロードされ、`o/main`リモートブランチに反映されました。"
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -732,7 +732,7 @@ exports.level = {
"`git fetch`は、主に二つのステップだけで動作します。それは以下のようなものです:",
"",
"* リモートにあってローカルリポジトリにないコミットをダウンロードする",
"* リモートブランチの位置を更新する（例えば、`o/master`）",
"* リモートブランチの位置を更新する（例えば、`o/main`）",
"",
"`git fetch`は本質的には、_実際_のリモートリポジトリと同じように見えるような形でリモートリポジトリの_ローカル_の情報に同期します（ちょうど今のように）。",
"",
@ -749,7 +749,7 @@ exports.level = {
"markdowns": [
"### fetchがしてくれないもの",
"",
"`git fetch`は、しかしながら、_あなたの_ローカルの状態は変更しません。あなたの`master`ブランチや他のもの、今現在のあなたのファイルシステムが見せているものを更新しないのです。",
"`git fetch`は、しかしながら、_あなたの_ローカルの状態は変更しません。あなたの`main`ブランチや他のもの、今現在のあなたのファイルシステムが見せているものを更新しないのです。",
"",
"これは理解する上で重要なことです。なぜなら、多くの技術者は`git fetch`がリモートの状態をローカルの作業場に反映してくれると思っているからです。必要なデータはダウンロードされるかもしれませんが、ローカルのファイルを実際に変更するというようなことは_してくれない_のです。私たちは、この後のレッスンでもこのようなコマンドを学びます :D",
"",
@ -790,7 +790,7 @@ exports.level = {
"Прежде чем углубляться в детали команды `git fetch`, давайте взглянем на её визуализацию в действии! Здесь у нас имеется удалённый репозиторий, который содержит в себе два коммита, отсутствующих в нашем локальном репозитории."
],
"afterMarkdowns": [
"Вот и всё! Коммиты `C2` и `C3` были успешно скачаны в наш локальный репозиторий, и наша удалённая ветка `o/master` отобразила эти изменения соответствующим образом."
"Вот и всё! Коммиты `C2` и `C3` были успешно скачаны в наш локальный репозиторий, и наша удалённая ветка `o/main` отобразила эти изменения соответствующим образом."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -805,7 +805,7 @@ exports.level = {
"`git fetch` выполняет две и только две основные операции. А именно:",
"",
"* связывается с указанным удалённым репозиторием и забирает все те данные проекта, которых у вас ещё нет, при этом...",
"* у вас должны появиться ссылки на все ветки из этого удалённого репозитория (например, `o/master`)",
"* у вас должны появиться ссылки на все ветки из этого удалённого репозитория (например, `o/main`)",
"",
"Фактически, `git fetch` синхронизирует _локальное_ представление удалённых репозиториев с тем, что является _актуальным_ на текущий момент времени.",
"",
@ -863,7 +863,7 @@ exports.level = {
"Перед тим, як почати розбиратися з `git fetch`, спробуймо його в дії! Тут ми маємо віддалений репозиторій, що містить два коміти, яких немає в нашому локальному сховищі."
],
"afterMarkdowns": [
"Ось, маєш! Коміти `C2` та `C3` було завантажено до нашого локального сховища й наша віддалена гілка `o/master` була відповідно оновлена."
"Ось, маєш! Коміти `C2` та `C3` було завантажено до нашого локального сховища й наша віддалена гілка `o/main` була відповідно оновлена."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -878,7 +878,7 @@ exports.level = {
"`git fetch` виконує дві основні дії, і тільки дві дії. Він:",
"",
"* звантажує коміти, які містить віддалене сховище, але яких немає в локальному сховищі, та...",
"* оновлює посилання віддаленого бранчу (наприклад, `o/master`)",
"* оновлює посилання віддаленого бранчу (наприклад, `o/main`)",
"",
"Якщо коротко, `git fetch` приводить репрезентацію віддаленого репозиторію в локальному сховищі до _актуального_ стану справжнього віддаленого репозиторію.",
"",
@ -895,7 +895,7 @@ exports.level = {
"markdowns": [
"### Чого не робить fetch",
"",
"Тим не менш, `git fetch` нічого не змінює в _твоєму_ локальному стані. Він не оновить твою гілку `master` і не змінить того, як наразі виглядає локальна файлова система.",
"Тим не менш, `git fetch` нічого не змінює в _твоєму_ локальному стані. Він не оновить твою гілку `main` і не змінить того, як наразі виглядає локальна файлова система.",
"",
"Це важливо зрозуміти, тому що багато розробників думають, що `git fetch` оновить їхні локальні данні до стану віддаленого репозиторію. Він дійсно звантажить всі потрібні дані, щоб це зробити, але він _не змінить_ автоматично жодних локальних файлів. Ми вивчимо команди, які це роблять, в наступних уроках :D",
"",
@ -936,7 +936,7 @@ exports.level = {
"`git fetch`의 세부사항을 알아보기 전에 일단 눈으로 먼저 확인해 봅시다! 여기 로컬 저장소에는 없는 두개의 커밋이 있는 원격 저장소가 있습니다."
],
"afterMarkdowns": [
"됐습니다! 커밋 `C2` 와 `C3`가 우리의 로컬 저장소로 다운로드 되었고, 원격 브랜치 `o/master`가 이것을 반영하기 위해 업데이트 되었습니다."
"됐습니다! 커밋 `C2` 와 `C3`가 우리의 로컬 저장소로 다운로드 되었고, 원격 브랜치 `o/main`가 이것을 반영하기 위해 업데이트 되었습니다."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -951,7 +951,7 @@ exports.level = {
"`git fetch`는 두가지의 중요한 단계를 수행합니다. 사실 이 두 단계만을 진행합니다. 그것은 :",
"",
"* 원격 저장소에는 있지만 로컬에는 없는 커밋들을 다운로드 받습니다. 그리고... ",
"* 우리의 원격 브랜치가 가리키는곳을 업데이트합니다 (예를들어, `o/master`)",
"* 우리의 원격 브랜치가 가리키는곳을 업데이트합니다 (예를들어, `o/main`)",
"",
"`git fetch`는 본질적으로 _로컬_에서 나타내는 원격 저장소의 상태를 _실제_ 원격 저장소의 (지금)상태와 동기화합니다.",
"",
@ -968,7 +968,7 @@ exports.level = {
"markdowns": [
"### fetch는 무엇을 하지 않는가",
"",
"`git fetch`는 그러나, _여러분의_ 로컬 상태는 전혀 바꾸지 않는습니다. 여러분의 `master` 브랜치도 업데이트하지 않고 파일 시스템의 모습이던 그 어떤것도 바꾸지 않습니다.",
"`git fetch`는 그러나, _여러분의_ 로컬 상태는 전혀 바꾸지 않는습니다. 여러분의 `main` 브랜치도 업데이트하지 않고 파일 시스템의 모습이던 그 어떤것도 바꾸지 않습니다.",
"",
"이것을 이해하는게 아주 중요한데, 왜냐하면 수 많은 개발자들이 `git fetch`를 하면 자신의 로컬 작업이 변경되어 원격 저장소의 모습을 반영해 업데이트 될것이라고 생각하기 때문입니다. 앞의 과정에 필요한 데이터를 다운로드는 하지만, 실제로 로컬 파일들이나 브랜치를 변경하지는 않습니다. 이것을 하기위한 명령어들은 뒤에서 배우겠습니다 :D",
"",
@ -1009,7 +1009,7 @@ exports.level = {
"Trước khi đi vào chi tiết về `git fetch`, hãy xem cách nó hoạt động! Ở đây ta có một kho chứa từ xa trong đó chứa 2 commit mà kho chứa địa phương của ta không có."
],
"afterMarkdowns": [
"Đó! Commit `C2` và `C3` đã được tải xuống kho chứa cục bộ của ta, và nhánh từ xa `o/master` của ta đã được cập nhật để phản ánh điều này."
"Đó! Commit `C2` và `C3` đã được tải xuống kho chứa cục bộ của ta, và nhánh từ xa `o/main` của ta đã được cập nhật để phản ánh điều này."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -1024,7 +1024,7 @@ exports.level = {
"`git fetch` thực hiện 2 bước chính, và chỉ 2 bước chính. Nó:",
"",
"* tải xuống commit có trên kho chứa từ xa mà kho chứa cục bộ của ta không có, và...",
"* cập nhật nơi mà nhánh từ xa của ta trỏ tới (ví dụ nhánh `o/master`)",
"* cập nhật nơi mà nhánh từ xa của ta trỏ tới (ví dụ nhánh `o/main`)",
"",
"Về căn bản thì `git fetch` đưa đại diện _địa phương_ của kho chứa từ xa của ta về trạng thái đồng bộ với trạng thái _thực tế_ của kho chứa từ xa (ngay lúc này).",
"",
@ -1041,7 +1041,7 @@ exports.level = {
"markdowns": [
"### fetch không làm gì",
"",
"Tuy nhiên, `git fetch` không hề thay đổi trạng thái kho chứa _địa phương_ của bạn. Nó sẽ không cập nhật nhánh `master` hay thay đổi bất kỳ điều gì trong hệ thống tập tin hiện tại của bạn.",
"Tuy nhiên, `git fetch` không hề thay đổi trạng thái kho chứa _địa phương_ của bạn. Nó sẽ không cập nhật nhánh `main` hay thay đổi bất kỳ điều gì trong hệ thống tập tin hiện tại của bạn.",
"",
"Điều này rất quan trọng, vì nhiều nhà phát triển nghĩ rằng `git fetch` sẽ làm kho chứa địa phương của họ phản ánh trạng thái của kho chúa từ xa. Nó có thể tải xuống tất cả dữ liệu cần thiết, nhưng nó thực tế _không_ thay đổi bất cứ thứ gì trên tập tin địa phương của bạn. Ta sẽ học lệnh để làm điều đó sau :D",
"",
@ -1082,7 +1082,7 @@ exports.level = {
"Preden se spustimo v podrobnosti `git fetch` ga poglejmo v akciji! Tu imamo oddaljen repozitorij, ki vsebuje dva commita, ki jih naš lokalen repozitorij nima."
],
"afterMarkdowns": [
"Tako! Commita `C2` in `C3` sta bila prenesena v naš lokalen repozitorij in naš oddaljen branch `o/master` je bil posodobljen, da to odraža."
"Tako! Commita `C2` in `C3` sta bila prenesena v naš lokalen repozitorij in naš oddaljen branch `o/main` je bil posodobljen, da to odraža."
],
"command": "git fetch",
"beforeCommand": "git clone; git fakeTeamwork 2"
@ -1097,7 +1097,7 @@ exports.level = {
"`git fetch` naredi dve stvari. In sicer:",
"",
"* prenese commite, ki jih ima oddaljeni repo ampak manjkajo v našem lokalnem in ...",
"* posodobi, kam kaže naš oddaljeni branch (naprimer `o/master`)",
"* posodobi, kam kaže naš oddaljeni branch (naprimer `o/main`)",
"",
"`git fetch` v bistvu našo lokalno predstavitev oddaljenega repozitorija uskladi z dejanskim stanjem na oddaljenem repozitoriju.",
"",
@ -1114,7 +1114,7 @@ exports.level = {
"markdowns": [
"### Kaj fetch ne naredi",
"",
"`git fetch` ne spremeni ničesar glede tvojega lokalnega stanja. Ne bo posodobil tvojega `master` brancha ali spremenil česarkoli v tvojih datotekah.",
"`git fetch` ne spremeni ničesar glede tvojega lokalnega stanja. Ne bo posodobil tvojega `main` brancha ali spremenil česarkoli v tvojih datotekah.",
"",
"To je pomembno razumeti, ker veliko razvijalcev misli, da bo `git fetch` posodobil njihovo lokalno stanje s stanjem na oddaljenem repozitoriju. Lahko bo prenesel vse potrebne podatke, da to izvede, ampak v bistvu _ne_ spremeni tvojih datotek. V kasnejših lekcijah se bomo naučili ukaze, ki pa naredijo točno to. :D",
"",

44
src/levels/remote/fetchArgs.js
View file

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C6\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"foo\":{\"target\":\"C7\",\"id\":\"foo\",\"remoteTrackingBranchID\":\"o/foo\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"o/foo\":{\"target\":\"C1\",\"id\":\"o/foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"},\"C5\":{\"parents\":[\"C1\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"},\"C7\":{\"parents\":[\"C3\",\"C6\"],\"id\":\"C7\"}},\"HEAD\":{\"target\":\"foo\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C4\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"foo\":{\"target\":\"C6\",\"id\":\"foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C1\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"}},\"HEAD\":{\"target\":\"foo\",\"id\":\"HEAD\"}}}",
"solutionCommand": "git fetch origin master~1:foo;git fetch origin foo:master;git checkout foo;git merge master",
"solutionCommand": "git fetch origin main~1:foo;git fetch origin foo:main;git checkout foo;git merge main",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"foo\":{\"target\":\"C1\",\"id\":\"foo\",\"remoteTrackingBranchID\":\"o/foo\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"o/foo\":{\"target\":\"C1\",\"id\":\"o/foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"}},\"HEAD\":{\"target\":\"C1\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C4\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"foo\":{\"target\":\"C6\",\"id\":\"foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C1\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"}},\"HEAD\":{\"target\":\"foo\",\"id\":\"HEAD\"}}}",
"name": {
"en_US": "Fetch arguments",
@ -145,7 +145,7 @@ exports.level = {
"Pretty simple, but worth going over just once."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -268,7 +268,7 @@ exports.level = {
"Assez simple, mais ce n'était pas inutile de voir en action."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -391,7 +391,7 @@ exports.level = {
"Bastante simple, pero vale la pena verlo al menos una vez."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -514,7 +514,7 @@ exports.level = {
"Bastante simple, pero merece la pena verlo al menos una vez."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -637,7 +637,7 @@ exports.level = {
"Bastante simples, mas importante de rever ao menos uma vez."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -760,7 +760,7 @@ exports.level = {
"Moi sinxelo, pero vale a pena velo ó menos unha vez."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -883,7 +883,7 @@ exports.level = {
"超簡單，但是所有的更新只做一次，很值得。"
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -1006,7 +1006,7 @@ exports.level = {
"相当简单，但是仅需更新一次，值得你去做！"
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -1029,11 +1029,11 @@ exports.level = {
"markdowns": [
"## Git Fetch Optionen",
"",
"Nun haben wir also alles über `git push` Optionen gelernt, diesen coolen `<Ort>`-Parameter, and sogar über mit Doppelpunkt getrennte Ref-Spezifikationen (`<Quelle>:<Ziel>`). Können wir all dieses neu erworbene Wissen auch auf `git fetch` anwenden?",
"Nun haben wir also alles gelernt über `git push` Optionen, diesen coolen `<Ort>`-Parameter und sogar mit Doppelpunkt getrennte Ref-Spezifikationen (`<Quelle>:<Ziel>`). Können wir all dieses neu erworbene Wissen auch auf `git fetch` anwenden?",
"",
"Jede Wette! Die Optionen für `git fetch` sind wirklicht *sehr, sehr* ähnlich denen von `git push`. Es sind dieselben Verfahren, nur in die andere Richtung angewendet (da man bei `fetch` herunterlädt anstatt hochzuladen).",
"",
"Gehen wir die verschiedenen Verfahrensweise mal eine nach der anderen durch ..."
"Gehen wir die verschiedenen Verfahrensweisen mal eine nach der anderen durch ..."
]
}
},
@ -1070,9 +1070,9 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Du wunderst dich vielleicht warum Git diese Commits auf den `o/foo` Branch gepacht hat, anstatt einfach direkt auf den lokalen Branch `foo`? Zeigt der Parameter `<Ort>` nicht einen Ort an, der sowohl lokal als auch entfernt existiert?",
"Du wunderst dich vielleicht, warum Git diese Commits auf den `o/foo` Branch gepackt hat, anstatt einfach direkt auf den lokalen Branch `foo`? Zeigt der Parameter `<Ort>` nicht einen Ort an, der sowohl lokal als auch entfernt existiert?",
"",
"Nun ja, Git geht diesen Schritt weil du auf `foo` ja noch Commits haben könntest, die nicht auf dem Server sind, und da will es nichts durcheinander bringen. Ähnlich wie beim früheren Level zu `git fetch` -- es aktualisiert nicht deine lokalen Arbeits-Branches, es lädt die Commits nur in die `o` (bzw. `origin`) Branches, damit du sie dir in Ruhe anschauen und integrieren kannst.",
"Nun ja, Git geht diesen Schritt, weil du auf `foo` ja noch Commits haben könntest, die nicht auf dem Server sind, und da will es nichts durcheinander bringen. Ähnlich wie beim früheren Level zu `git fetch` -- es aktualisiert nicht deine lokalen Arbeits-Branches, es lädt die Commits nur in die `o` (bzw. `origin`) Branches, damit du sie dir in Ruhe anschauen und integrieren kannst.",
""
]
}
@ -1098,7 +1098,7 @@ exports.level = {
"Schauen wir uns den Quatsch mal in Aktion an:"
],
"afterMarkdowns": [
"Wow! Siehst du, git löst `foo~1` als Ort auf dem Server `origin` auf und lädt dessen Commits herunter in `bar` hinein. Beachte wie `foo` und `o/foo` *nicht* aktualisiert wurden, da wir ein Ziel angegeben haben."
"Wow! Siehst du, Git löst `foo~1` als Ort auf dem Server `origin` auf und lädt dessen Commits herunter in `bar` hinein. Beachte wie `foo` und `o/foo` *nicht* aktualisiert wurden, da wir ein Ziel angegeben haben."
],
"command": "git fetch origin foo~1:bar",
"beforeCommand": "git branch foo; git clone; git branch bar; git fakeTeamwork foo 2"
@ -1108,10 +1108,10 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Was ist denn wenn das Ziel nicht existiert, für das ich den Befehl ausführe? Schauen wir uns das letzte Beispiel noch mal an, nur dass `bar` jetzt noch nicht existiert."
"Was ist denn, wenn das Ziel nicht existiert, für das ich den Befehl ausführe? Schauen wir uns das letzte Beispiel noch mal an, nur dass `bar` jetzt noch nicht existiert."
],
"afterMarkdowns": [
"Siehst du, es ist *genau* wie `git push`. Git erstellt das Ziel lokal bevor es den `fetch` ausführt, genauso wie Git erst das Ziel auf dem Remote erstellt, befor es pusht (falls das Ziel nicht existiert)."
"Siehst du, es ist *genau* wie `git push`. Git erstellt das Ziel lokal bevor es den `fetch` ausführt, genauso wie Git erst das Ziel auf dem Remote erstellt, bevor es pusht (falls das Ziel nicht existiert)."
],
"command": "git fetch origin foo~1:bar",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
@ -1129,7 +1129,7 @@ exports.level = {
"Ziemlich einfach, aber man sollte es mal gesehen haben."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -1252,7 +1252,7 @@ exports.level = {
"Достаточно просто, после того как мы пережили все эти технические тонкости."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -1375,7 +1375,7 @@ exports.level = {
"간단하지만, 짚고 넘어갑시다."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -1498,7 +1498,7 @@ exports.level = {
"Все дуже просто, але варто було згадати ще раз."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -1621,7 +1621,7 @@ exports.level = {
"Khá là đơn giản, nhưng mà cũng nên xem qua thử."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{
@ -1744,7 +1744,7 @@ exports.level = {
"Precej enostavno, ampak vredno, da gremo čez vsaj enkrat."
],
"command": "git fetch",
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork master"
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
}
},
{

68
src/levels/remote/fetchRebase.js
View file

@ -96,7 +96,7 @@ exports.level = {
"afterMarkdowns": [
"Boom! We updated our local representation of the remote with `git fetch`, rebased our work to reflect the new changes in the remote, and then pushed them with `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -121,7 +121,7 @@ exports.level = {
"afterMarkdowns": [
"Boom! We updated our local representation of the remote with `git fetch`, *merged* the new work into our work (to reflect the new changes in the remote), and then pushed them with `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -239,7 +239,7 @@ exports.level = {
"afterMarkdowns": [
"Boum ! Nous avons mis à jour notre représentation locale du dépôt avec `git fetch`, rebasé notre travail pour refléter les nouveaux changements, et enfin les avons envoyés avec `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -264,7 +264,7 @@ exports.level = {
"afterMarkdowns": [
"Boum ! Nous avons mis à jour notre représentation locale du dépôt distant avec `git fetch`, *fusionné* les nouveaux commits dans notre copie de travail (pour refléter les nouveaux changements du dépôt distant), et les avons ensuite envoyés avec `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -382,7 +382,7 @@ exports.level = {
"afterMarkdowns": [
"¡Boom! Actualizamos nuestra representación local del remoto con `git fetch`, rebaseamos nuestro trabajo para reflejar los nuevos cambios del remoto, y después los pusheamos con `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -407,7 +407,7 @@ exports.level = {
"afterMarkdowns": [
"¡Boom! Actualizamos nuestra representación local del remoto usando `git fetch`, *mergeamos* el nuevo trabajo junto con el nuestro (para reflejar los nuevos cambios en el remoto), y después los pusheamos usando `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -525,7 +525,7 @@ exports.level = {
"afterMarkdowns": [
"¡Zas! Actualizamos nuestra representación local del remoto con `git fetch`, hacemos rebase de nuestro trabajo para reflejar los nuevos cambios del remoto, y después los subimos con `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -550,7 +550,7 @@ exports.level = {
"afterMarkdowns": [
"¡Zas! Actualizamos nuestra representación local del remoto usando `git fetch`, *mergeamos* el nuevo trabajo junto con el nuestro (para reflejar los nuevos cambios en el remoto), y después los subimos usando `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -668,7 +668,7 @@ exports.level = {
"afterMarkdowns": [
"Boom! Nós atualizamos a representação local do repositório remoto com `git fetch`, fizemos rebase do nosso trabalho para refletir as novas mudanças no repositório remoto, e então enviamos nossas mudanças com `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -693,7 +693,7 @@ exports.level = {
"afterMarkdowns": [
"Boom! Atualizamos nossa representação local do repositório remoto com `git fetch`, fizemos *merge* do novo trabalho com o nosso (para refletir as novas mudanças no repositório remoto), e então fizemos push deles com `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -812,7 +812,7 @@ exports.level = {
"afterMarkdowns": [
"¡Boom! Actualizamos a nosa representación local do remoto con `git fetch`, rebasamos o noso traballo para reflexar os novos cambios do remoto, e despois os empurramos con `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -837,7 +837,7 @@ exports.level = {
"afterMarkdowns": [
"¡Boom! Actualizamos a nosa representación local do remoto usando `git fetch`, *mesturamos* ou *mergeamos* o novo traballo xunto co noso (para reflexar os novos cambios no remoto), e despois os empurramos empregando `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -955,7 +955,7 @@ exports.level = {
"afterMarkdowns": [
"看吧！我們利用 `git fetch` 下載了 remote 上面的 commit，並且 rebase 我們的 commit，使得我們的 commit 可以接在 remote 上面最新的版本的後面，接著透過 `git push` 就可以上傳更新了。"
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -980,7 +980,7 @@ exports.level = {
"afterMarkdowns": [
"看吧！我們藉由 `git fetch` 把 remote 上的 commit 下載下來，並且 *merged* 該 commit 到我們目前的 branch（這樣就表示我們產生的 merge commit 有包含了 remote　上的 commit），接著再透過 `git push` 上傳到 remote。"
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1098,7 +1098,7 @@ exports.level = {
"afterMarkdowns": [
"我们用 `git fetch` 更新了本地仓库中的远程分支，然后用 rebase 将我们的工作移动到最新的提交记录下，最后再用 `git push` 推送到远程仓库。"
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1123,7 +1123,7 @@ exports.level = {
"afterMarkdowns": [
"我们用 `git fetch` 更新了本地仓库中的远程分支，然后**合并**了新变更到我们的本地分支（为了包含远程仓库的变更），最后我们用 `git push` 把工作推送到远程仓库"
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1205,7 +1205,7 @@ exports.level = {
"",
"In diesem Fall ist ein `git push` problematisch. Wenn du es ausführst, soll Git das entfernte Repository in den Zustand von Montag zurückversetzen? Soll es versuchen deinen Code auf die aktuelle Version zu packen? Oder soll es deine Änderungen einfach ignorieren, weil sie total veraltet sind?",
"",
"Da es in dieser Situation so viele Mehrdeutigkeiten gibt (da die Historys divergent sind) erlaubt Git dir nicht, deine Änderungen einfach zu `push`en. Es zwingt dich, zuerst die neuesten Änderungen vom Server zu holen und in deine zu integrieren bevor du deine Arbeit mit anderen teilen kannst."
"Da es in dieser Situation so viele Mehrdeutigkeiten gibt (da die Historys divergieren), erlaubt Git dir nicht, deine Änderungen einfach zu `push`en. Es zwingt dich, zuerst die neuesten Änderungen vom Server zu holen und in deine zu integrieren, bevor du deine Arbeit mit anderen teilen kannst."
]
}
},
@ -1228,7 +1228,7 @@ exports.level = {
"markdowns": [
"Wie sollen wir das auflösen? Es ist ganz einfach, du musst deinen Commit nur von der aktuellsten Version des Remotes ableiten.",
"",
"Es gibt verschiedene Möglichkeiten wie man das erreichen kann, aber die offensichtlichste ist es, deine Commits per Rebase zu verschieben. Schauen wir mal wie das abläuft:"
"Es gibt verschiedene Möglichkeiten, wie man das erreichen kann, aber die offensichtlichste ist, deine Commits per Rebase zu verschieben. Schauen wir mal wie das abläuft:"
]
}
},
@ -1241,7 +1241,7 @@ exports.level = {
"afterMarkdowns": [
"Bämm! Wir haben unsere lokale Abbildung des entfernten Repositorys mit `git fetch` auf den neuesten Stand gebracht, unsere Arbeit auf die neueste Version des Remotes drauf gepackt und dann mit `git push` auf den Server geschoben."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1249,9 +1249,9 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Gibt es noch weitere Möglichkeiten deine Arbeit zu aktualisieren wenn das entfernte Repository neue Commits bekommen hat? Klar! Schauen wir uns dasselbe an, aber diesmal arbeiten wir mit `merge`.",
"Gibt es noch weitere Möglichkeiten deine Arbeit zu aktualisieren, wenn das entfernte Repository neue Commits bekommen hat? Klar! Schauen wir uns dasselbe an, aber diesmal arbeiten wir mit `merge`.",
"",
"Obwohl `git merge` deine Arbeit nicht verschiebt (und stattdessen einen Merge Commit erzeugt) ist es eine Möglichkeit Git dazu zu bringen, alle Änderungen vom Remote in deine Sachen zu integrieren. Denn durch den Merge wird der Remote Branch zu einem *Vorgänger* deines Branches, was bedeutet dass dein Commit alle Commits des entfernten Branches beinhaltet.",
"Obwohl `git merge` deine Arbeit nicht verschiebt (und stattdessen einen Merge Commit erzeugt) ist es eine Möglichkeit Git dazu zu bringen, alle Änderungen vom Remote in deine Sachen zu integrieren. Denn durch den Merge wird der Remote Branch zu einem *Vorgänger* deines Branches, was bedeutet, dass dein Commit alle Commits des entfernten Branches beinhaltet.",
"",
"Zur Demonstration ..."
]
@ -1266,7 +1266,7 @@ exports.level = {
"afterMarkdowns": [
"Ok. Wir haben die lokale Abbildung des entfernen Repositorys mit `git fetch` aktualisiert, die neuen Änderungen per *Merge* in deine integriert, und letztere dann mit `git push` auf den Server gebracht."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1384,7 +1384,7 @@ exports.level = {
"afterMarkdowns": [
"Опа! Мы только что обновили наш локальный образ удалённого репозитория средствами `git fetch`. Ещё мы перебазировали наши наработки, чтобы они отражали все изменения с удалённого репозитория, и опубликовали их с помощью `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1409,7 +1409,7 @@ exports.level = {
"afterMarkdowns": [
"Опа! Мы обновили наше локальное представление удалённого репозитория с помощью `git fetch`, *объединили* ваши новые наработки с нашими наработками (чтобы отразить изменения в удалённом репозитории) и затем опубликовали их с помощью `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1527,7 +1527,7 @@ exports.level = {
"afterMarkdowns": [
"わお！私たちは`git fetch`でローカルのリモートブランチを更新し、私たちの作業をリベースさせてリモートの新しい変更に適用させ、`git push`でそれをプッシュしました。"
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1552,7 +1552,7 @@ exports.level = {
"afterMarkdowns": [
"わお！私たちは`git fetch`でローカルのリモートブランチを更新し、私たちの作業を*マージ*して（リモートの新しい変更を反映するために）、`git push`でそれをプッシュしました。"
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1670,7 +1670,7 @@ exports.level = {
"afterMarkdowns": [
"Ка-бум! Ми оновили наш локальний образ віддаленого репозиторію за допомогою `git fetch`, заребейсили наші напрацювання відповідно до змін у віддаленому репо, й завантажили їх за допомогою `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1695,7 +1695,7 @@ exports.level = {
"afterMarkdowns": [
"Ка-бум! Ми оновили наш локальний образ віддаленої гілки за допомогою `git fetch`, *змерджили* нові напрацювання з власними (щоб відобразити останні зміни у віддаленій гілці), й відіслали їх за допомогою `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1813,7 +1813,7 @@ exports.level = {
"afterMarkdowns": [
"Boom! `git fetch`로 원격 저장소의 변경정보를 가져오고, 새 변경들로 우리 작업을 리베이스 했습니다, 이제 `git push`하면 끝!"
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1838,7 +1838,7 @@ exports.level = {
"afterMarkdowns": [
"Boom! `git fetch`로 원격 저장소의 변경정보를 가져오고, 새 작업을 우리 작업으로 *병합*했습니다 (원격 저장소의 변경을 반영하기 위해서죠), 이제 `git push`하면 끝!"
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1956,7 +1956,7 @@ exports.level = {
"afterMarkdowns": [
"Bùùm! Ta đã cập nhật nhánh từ xa trong kho chứ cục bộ với `git fetch`, dịch chuyển thành quả của mình để phản ánh thay đổi mới của kho chứa từ xa, sau đó đẩy chúng lên với `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -1981,7 +1981,7 @@ exports.level = {
"afterMarkdowns": [
"Bùùm! Ta đã cập nhật đại diện nhánh từ xa tại kho chứa địa phương với `git fetch`, *hợp nhất* (*merge*) thành quả mới vào thành quả của ta (để phản ánh thay đổi ở nhánh từ xa), sau đó đẩy chúng lên với `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -2099,7 +2099,7 @@ exports.level = {
"afterMarkdowns": [
"Boom! Posodobili smo našo lokalno reprezentacijo oddaljenega repozitorija z `git fetch`, rebaseali naše delo, da vsebuje nove spremembe iz oddaljenega repota, nato pa naložili svoje delo z `git push`."
],
"command": "git fetch; git rebase o/master; git push",
"command": "git fetch; git rebase o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},
@ -2124,7 +2124,7 @@ exports.level = {
"afterMarkdowns": [
"Boom! Posodobili smo našo lokalno sliko oddaljenega repozitorija z `git fetch`, *zmergali* novo delo v naše delo (kot odraz novih sprememb na oddaljenem branchu) in jih nato naložili z `git push`."
],
"command": "git fetch; git merge o/master; git push",
"command": "git fetch; git merge o/main; git push",
"beforeCommand": "git clone; git fakeTeamwork; git commit"
}
},

189
src/levels/remote/lockedMaster.js
View file

@ -1,26 +1,30 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"feature\":{\"target\":\"C2\",\"id\":\"feature\",\"remoteTrackingBranchID\":\"o/feature\"},\"o/feature\":{\"target\":\"C2\",\"id\":\"o/feature\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"}},\"tags\":{},\"HEAD\":{\"target\":\"feature\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"feature\":{\"target\":\"C2\",\"id\":\"feature\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"}},\"tags\":{},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"solutionCommand": "git reset --hard o/master;git checkout -b feature C2; git push origin feature",
"solutionCommand": "git reset --hard o/main;git checkout -b feature C2; git push origin feature",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"}},\"tags\":{},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"}},\"tags\":{},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"hint": {
"en_US": "Make the feature branch from the local master before resetting it back to be the same as origin's master",
"de_DE": "Erstelle einen Feature-Branch ausgehend vom lokalen Master-Branch, bevor du den Master-Branch auf den origin/master zurücksetzt.",
"ru_RU": "Создайте новую feature ветвь от master перед тем, как откатить изменения в master до состояния o/master.",
"en_US": "Make the feature branch from the local main before resetting it back to be the same as origin's main",
"de_DE": "Erstelle einen Feature-Branch ausgehend vom lokalen Master-Branch, bevor du den Master-Branch auf den origin/main zurücksetzt.",
"ru_RU": "Создайте новую feature ветвь от main перед тем, как откатить изменения в main до состояния o/main.",
"uk": "Створіть нову feature гілку від локального main перед тим, як відкотити зміни в main до стану o/main.",
"zh_CN": "从本地的master创建一个feature分支, 然后重置master和origin master保持一致。",
"es_ES": "Crea la rama feature desde la rama master en local antes de restablecerlo para que sea el mismo que la rama master de origen",
"fr_FR": "Créer la branche feature à partir du master local, avant de la restaurer dans le même état que o/master",
"ko" : "로컬 저장소의 master 브랜치로부터 feature 브랜치를 만드세요. 그리고 o/master와 같아질 수 있도록 로컬 저장소의 master 브랜치를 reset 하세요.",
"sl_SI": "Naredi feature branch iz lokalnega masterja preden ga ponastaviš, da bo enak kot origin master.",
"es_AR": "Crea la rama feature desde la rama master en local antes de restablecerlo para que sea el mismo que la rama master de origen."
"es_ES": "Crea la rama feature desde la rama main en local antes de restablecerlo para que sea el mismo que la rama main de origen",
"pt_BR": "Crie o ramo feature a partir do ramo main no local antes de reestabelecê-lo para que seja o mesmo que o ramo main de origem",
"fr_FR": "Créer la branche feature à partir du main local, avant de la restaurer dans le même état que o/main",
"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."
},
"name": {
"en_US": "Locked Master",
"de_DE": "Gesperrter Master-Branch",
"ru_RU": "Заблокированная ветвь master",
"ru_RU": "Заблокированная ветвь main",
"uk": "Заблокована гілка main",
"zh_CN": "锁定的Master(Locked Master)",
"es_ES": "Master bloqueado",
"pt_BR": "Master bloqueado",
"fr_FR": "Master verrouillé",
"ko" : "잠겨버린 Master",
"ko" : "잠겨버린 main 브랜치",
"sl_SI": "Zaklenjen Master",
"es_AR": "Master bloqueado"
},
@ -33,10 +37,10 @@ exports.level = {
"markdowns": [
"## Remote Rejected!",
"",
"If you work on a large collaborative team its likely that master is locked and requires some Pull Request process to merge changes. If you commit directly to master locally and try pushing you will be greeted with a message similar to this:",
"If you work on a large collaborative team its likely that main is locked and requires some Pull Request process to merge changes. If you commit directly to main locally and try pushing you will be greeted with a message similar to this:",
"",
"```",
" ! [remote rejected] master -> master (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```"
]
}
@ -47,9 +51,9 @@ exports.level = {
"markdowns": [
"## Why was it rejected?",
"",
"The remote rejected the push of commits directly to master because of the policy on master requiring pull requests to instead be used.",
"The remote rejected the push of commits directly to main because of the policy on main requiring pull requests to instead be used.",
"",
"You meant to follow the process creating a branch then pushing that branch and doing a pull request, but you forgot and committed directly to master. Now you are stuck and cannot push your changes."
"You meant to follow the process creating a branch then pushing that branch and doing a pull request, but you forgot and committed directly to main. Now you are stuck and cannot push your changes."
]
}
},
@ -59,7 +63,7 @@ exports.level = {
"markdowns": [
"## The solution",
"",
"Create another branch called feature and push that to the remote. Also reset your master back to be in sync with the remote otherwise you may have issues next time you do a pull and someone else's commit conflicts with yours."
"Create another branch called feature and push that to the remote. Also reset your main back to be in sync with the remote otherwise you may have issues next time you do a pull and someone else's commit conflicts with yours."
]
}
}
@ -76,7 +80,7 @@ exports.level = {
"Wenn du in einem großen Team zusammen arbeitest, ist der Master-Branch mit hoher Wahrscheinlichkeit für direkte Änderungen gesperrt. Um Änderungen am Remote-Branch einpflegen zu können, ist ein Pull-Request-Prozess notwendig. Wenn du lokal in deinem Master-Branch einen Commit durchführst und diesen versuchst auf den serverseitigen Master-Branch zu pushen, wirst du folgende Fehlermeldung bekommen:",
"",
"```",
" ! [remote rejected] master -> master (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```"
]
}
@ -99,7 +103,7 @@ exports.level = {
"markdowns": [
"## Die Lösung",
"",
"Erstelle einen Branch der feature heißt und pushe diesen auf den Server. Setze den lokalen Master-Branch zurück, dass er mit dem Origin-Master-Branch synchron ist. Dies könnte sonst später zu weiteren Komplikationen führen, wenn weiter pulls durchgeführt und Commits von anderen mit deinen in Konflikt stehen."
"Erstelle einen Branch der feature heißt und pushe diesen auf den Server. Setze den lokalen Master-Branch zurück, dass er mit dem Origin-Master-Branch synchron ist. Dies könnte sonst später zu Komplikationen führen, wenn weitere `pull`s durchgeführt und Commits von anderen mit deinen in Konflikt stehen."
]
}
}
@ -116,7 +120,7 @@ exports.level = {
"如果你是在一个大的合作团队中工作, 很可能是master被锁定了, 需要一些Pull Request流程来合并修改。如果你直接提交(commit)到本地master, 然后试图推送(push)修改, 你将会收到这样类似的信息:",
"",
"```",
" ! [远程服务器拒绝] master -> master (TF402455: 不允许推送(push)这个分支; 你必须使用pull request来更新这个分支.)",
" ! [远程服务器拒绝] main -> main (TF402455: 不允许推送(push)这个分支; 你必须使用pull request来更新这个分支.)",
"```"
]
}
@ -153,14 +157,14 @@ exports.level = {
"markdowns": [
"## Remote Rejected!",
"",
"Когда вы работаете в составе большой команды разработчиков над проектом, то, вероятнее всего, ветвь `master` будет _заблокирована_. Для внесения изменений в неё в git существует понятие запроса на слияние `Pull Request`. В такой ситуации если вы закоммитите свои наработки непосредственно в `master` ветвь, а после выполните `git push`, то будет сгенерировано сообщение об ошибке:",
"Когда вы работаете в составе большой команды разработчиков над проектом, то, вероятнее всего, ветвь `main` будет _заблокирована_. Для внесения изменений в неё в git существует понятие запроса на слияние `Pull Request`. В такой ситуации если вы закоммитите свои наработки непосредственно в `main` ветвь, а после выполните `git push`, то будет сгенерировано сообщение об ошибке:",
"",
"```",
" ! [remote rejected] master -> master (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```",
"",
"```",
" ! [удалённо отклонено] master -> master (TF402455: Изменение этой ветви запрещены; вы можете использовать pull request для обновления этой ветви.)",
" ! [удалённо отклонено] main -> main (TF402455: Изменение этой ветви запрещены; вы можете использовать pull request для обновления этой ветви.)",
"```"
]
}
@ -171,9 +175,9 @@ exports.level = {
"markdowns": [
"## Почему произошло отклонение моих изменений?",
"",
"Удалённый репозиторий отклонил загруженные коммиты непосредственно в `master` ветку потому, что на `master` _настроена политика_, которая требует использование `Pull request` вместо обычного `git push`.",
"Удалённый репозиторий отклонил загруженные коммиты непосредственно в `main` ветку потому, что на `main` _настроена политика_, которая требует использование `Pull request` вместо обычного `git push`.",
"",
"Эта политика подразумевает процесс создания новой ветви разработки, внесение в неё всех необходимых коммитов, загрузка изменений в удалённый репозиторий и _открытие нового_ `Pull request`. Однако вы забыли про это и закоммитили наработки непосредственно в `master` ветвь. Теперь вы застряли и не можете запушить свои изменения :(. "
"Эта политика подразумевает процесс создания новой ветви разработки, внесение в неё всех необходимых коммитов, загрузка изменений в удалённый репозиторий и _открытие нового_ `Pull request`. Однако вы забыли про это и закоммитили наработки непосредственно в `main` ветвь. Теперь вы застряли и не можете запушить свои изменения :(. "
]
}
},
@ -183,7 +187,52 @@ exports.level = {
"markdowns": [
"## Решение:",
"",
"Создайте ещё одну ветвь под названием `feature` и отправьте изменения на удалённый репозиторий. Так же не забудьте вернуть вашу локальную `master` ветвь в исходное состояние (чтобы она была синхронизирована с удалённой). В противном случае у вас могут возникнуть проблемы при следующем выполнении `git pull`."
"Создайте ещё одну ветвь под названием `feature` и отправьте изменения на удалённый репозиторий. Также не забудьте вернуть вашу локальную `main` ветвь в исходное состояние (чтобы она была синхронизирована с удалённой). В противном случае у вас могут возникнуть проблемы при следующем выполнении `git pull`."
]
}
}
]
},
"uk": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Remote Rejected!",
"",
"Коли ви працюєте над проектом в складі великої команди розробників, то, швидше за все, гілка `main` буде _заблокована_. Для внесення до неї змін в git існує поняття запиту на злиття `Pull Request`. В такій ситуації, якщо ви закомітите свої зміни безпосередньо в гілку `main`, а потім виконаєте `git push`, то буде згенероване повідомлення про помилку:",
"",
"```",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```",
"",
"```",
" ! [віддалено відхилено] main -> main (TF402455: Зміни (push-запити) цієї гілки заборонені; ви повинні використовувати pull-запит для оновлення цієї гілки.)",
"```"
]
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Чому мої зміни були відхилені?",
"",
"Віддалений репозиторій відхилив коміти завантажені безпосередньо в гілку `main` через те, що на `main` _налаштована політика_, яка вимагає використання `Pull request` замість звичайного `git push`.",
"",
"Ця політика має на увазі процес створення нової гілки розробки, внесення до неї всіх потрібних комітів, завантаження змін в віддалений репозиторій і _відкриття нового_ `Pull request`. Але ви про це забули (чи не знали) і закомітили свої доробки безпосередньо в гілку `main`. Тепер ви застрягли і не можене запушити свої зміни :(. "
]
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Рішення:",
"",
"Створіть ще одну гілку з назвою `feature` і відправте зміни у віддалений репозиторій. Також не забудьте повернути вашу локальну гілку `main` в вихідне положення (щоб вона була синхронізована з віддаленою). Інакше у вас можуть виникнути складнощі при наступному виконанні запиту `git pull`, коли коміти інших розробників конфліктуватимуть з вашими."
]
}
}
@ -197,10 +246,10 @@ exports.level = {
"markdowns": [
"## Remote Rejected!",
"",
"Si trabajas en un equipo colaborativo, es probable que la rama `master` esté bloqueada y requiera algún proceso de `Pull Request` para poder `mergear` los cambios. Si haces `commit` directamente a `master` e intentas realizar `push`, recibirás un mensaje similar a este:",
"Si trabajas en un equipo colaborativo, es probable que la rama `main` esté bloqueada y requiera algún proceso de `Pull Request` para poder `mergear` los cambios. Si haces `commit` directamente a `main` e intentas realizar `push`, recibirás un mensaje similar a este:",
"",
"```",
" ! [remote rejected] master -> master (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```"
]
}
@ -211,9 +260,9 @@ exports.level = {
"markdowns": [
"## ¿Por qué fue rechazado?",
"",
"Se rechazó el `push` del `commit` a la rama `master` debido a la política en la rama `master` que requiere el uso de `Pull Requests`.",
"Se rechazó el `push` del `commit` a la rama `main` debido a la política en la rama `main` que requiere el uso de `Pull Requests`.",
"",
"Trataste de crear una rama y luego hacer `pushs` creando un `Pull Request`, pero te olvidaste e hiciste `commit` directamente a `master`. Ahora estás atascado y no puedes hacer `push` de tus cambios."
"Trataste de crear una rama y luego hacer `pushs` creando un `Pull Request`, pero te olvidaste e hiciste `commit` directamente a `main`. Ahora estás atascado y no puedes hacer `push` de tus cambios."
]
}
@ -224,7 +273,47 @@ exports.level = {
"markdowns": [
"## La solución",
"",
"Crea otra rama llamada `feature` y haz `push` a remoto. También restablece su rama `master` nuevamente para que esté sincronizado con el repositorio remoto; de lo contrario, puedes tener problemas la próxima vez que realices un `pull` y el `commit` de otra persona entre en conflicto con el tuyo."
"Crea otra rama llamada `feature` y haz `push` a remoto. También restablece su rama `main` nuevamente para que esté sincronizado con el repositorio remoto; de lo contrario, puedes tener problemas la próxima vez que realices un `pull` y el `commit` de otra persona entre en conflicto con el tuyo."
]
}
}
]
},
"pt_BR": {
"childViews": [
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## Remote Rejected!",
"",
"Se você trabalha em uma grande equipe colaborativa é provável que o main seja bloqueado e precise de alguns processos de Pull Request para unir mudanças. Se você commitar diretamente para o main localmente e tentar fazer um push você visualizará uma mensagem similar a essa:",
"",
"```",
" ! [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": [
"## Por que foi rejeitado?",
"",
"O repositório remoto rejeitou o push dos commits diretamente para o main por causa da política do main necessitando do uso dos pull requests.",
"",
"Você pretendia seguir o processo de criação de uma ramificação, fazendo um push dessa ramificação e fazendo um pull request, mas você esqueceu e commitou diretamente para o main. Agora você está preso e não consegue publicar suas mudanças."
]
}
},
{
"type": "ModalAlert",
"options": {
"markdowns": [
"## A solução",
"",
"Crie outro branch chamado feature e faça um push dele para o repositório remoto. Além disso, resete o main de volta a estar sincronizado com o repositório remoto para não ter problemas da próxima vez que fizer um pull e os commits de alguém mais conflitarem com o seu."
]
}
}
@ -238,10 +327,10 @@ exports.level = {
"markdowns": [
"## Remote Rejected!",
"",
"Si vous travaillez dans une équipe de grande taille, il est probable que `master` soit verrouillée, et que le mécanisme de `Pull Request` soit nécessaire pour `merge` des changements. Si vous faites un `commit` directement sur le master local, et essayez de `push`, vous serez reçu avec un message de la sorte :",
"Si vous travaillez dans une équipe de grande taille, il est probable que `main` soit verrouillée, et que le mécanisme de `Pull Request` soit nécessaire pour `merge` des changements. Si vous faites un `commit` directement sur le main local, et essayez de `push`, vous serez reçu avec un message de la sorte :",
"",
"```",
" ! [remote rejected] master -> master (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```"
]
}
@ -252,9 +341,9 @@ exports.level = {
"markdowns": [
"## Pourquoi est-ce rejeté?",
"",
"Le dépôt distant a rejeté le `push` de `commit` directement sur `master`, à cause de la stratégie mise en place sur `master`, imposant plutôt l'usage des `pull requests`.",
"Le dépôt distant a rejeté le `push` de `commit` directement sur `main`, à cause de la stratégie mise en place sur `main`, imposant plutôt l'usage des `pull requests`.",
"",
"Vous étiez censé suivre le processus suivant : créer une branche, `push`, et faire une `pull request`. Mais vous avez oublié et avez fait un `commit` directement sur `master`. Maintenant vous êtes coincé et ne pouvez pas faire un `push` de vos modifications."
"Vous étiez censé suivre le processus suivant : créer une branche, `push`, et faire une `pull request`. Mais vous avez oublié et avez fait un `commit` directement sur `main`. Maintenant vous êtes coincé et ne pouvez pas faire un `push` de vos modifications."
]
}
},
@ -264,7 +353,7 @@ exports.level = {
"markdowns": [
"## La solution",
"",
"Créer une autre branche appelée feature, et poussez la sur le serveur distant. Réinitialisez (`reset`) également votre `master` pour être en cohérence avec l'état du serveur distant, sinon vous pourriez avoir des problèmes la prochaine fois que vous faites un `pull`, et que quelqu'un d'autre `commit` des choses en conflit avec vos modifications."
"Créer une autre branche appelée feature, et poussez la sur le serveur distant. Réinitialisez (`reset`) également votre `main` pour être en cohérence avec l'état du serveur distant, sinon vous pourriez avoir des problèmes la prochaine fois que vous faites un `pull`, et que quelqu'un d'autre `commit` des choses en conflit avec vos modifications."
]
}
}
@ -278,10 +367,10 @@ exports.level = {
"markdowns": [
"## 원격저장소 거부! (Remote Rejected!)",
"",
"규모가 큰 개발팀에서 일하는 경우, 보통 원격저장소의 `master` 브랜치는 잠겨있습니다(locked). 그래서 변경사항을 적용하려면 pull request 과정을 거쳐야하죠. 만약에 여러분이 로컬 저장소의 `master`브랜치에서 커밋을 한 후 `push`하려고 시도한다면, 다음과 같은 오류를 받게 될겁니다. :",
"규모가 큰 개발팀에서 일하는 경우, 보통 원격저장소의 `main` 브랜치는 잠겨있습니다(locked). 그래서 변경사항을 적용하려면 pull request 과정을 거쳐야하죠. 만약에 여러분이 로컬 저장소의 `main`브랜치에서 커밋을 한 후 `push`하려고 시도한다면, 다음과 같은 오류를 받게 될겁니다. :",
"",
"```",
" ! [remote rejected] master -> master (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```"
]
}
@ -292,9 +381,9 @@ exports.level = {
"markdowns": [
"## 왜 거부됐나요?",
"",
"원격 저장소는 자신의 `master` 브랜치에 대한 직접적인 커밋을 제한합니다. 왜냐하면 `push` 대신에 pull request가 쓰여야 한다는 규칙이 원격 저장소의 `master` 브랜치에는 적용되어 있기 때문이죠.",
"원격 저장소는 자신의 `main` 브랜치에 대한 직접적인 커밋을 제한합니다. 왜냐하면 `push` 대신에 pull request가 쓰여야 한다는 규칙이 원격 저장소의 `main` 브랜치에는 적용되어 있기 때문이죠.",
"",
"여러분은 브랜치를 따로 만들어 작업한 다음, 그것을 `push`하고 pull request를 하려 했습니다. 하지만 그걸 잊고 실수로 `master` 브랜치에서 직접 커밋을 해버렸네요! 이제 변경 사항을 `push` 하지도 못하고 옴짝달싹 못하는 상황이 되어버렸습니다."
"여러분은 브랜치를 따로 만들어 작업한 다음, 그것을 `push`하고 pull request를 하려 했습니다. 하지만 그걸 잊고 실수로 `main` 브랜치에서 직접 커밋을 해버렸네요! 이제 변경 사항을 `push` 하지도 못하고 옴짝달싹 못하는 상황이 되어버렸습니다."
]
}
},
@ -304,7 +393,7 @@ exports.level = {
"markdowns": [
"## 해결책",
"",
"`feature` 라는 이름의 다른 브랜치를 만들어 원격 저장소에 `push` 하세요. 그리고 원격 저장소와 동기화될 수 있도록 로컬 저장소의 `master` 브랜치를 `reset`하세요. 그렇지 않으면 여러분이 다음에 `pull`을 시도할 때 문제가 발생하거나, 다른 협업자들의 커밋이 여러분의 커밋과 충돌할 수도 있습니다."
"`feature` 라는 이름의 다른 브랜치를 만들어 원격 저장소에 `push` 하세요. 그리고 원격 저장소와 동기화될 수 있도록 로컬 저장소의 `main` 브랜치를 `reset`하세요. 그렇지 않으면 여러분이 다음에 `pull`을 시도할 때 문제가 발생하거나, 다른 협업자들의 커밋이 여러분의 커밋과 충돌할 수도 있습니다."
]
}
}
@ -318,10 +407,10 @@ exports.level = {
"markdowns": [
"## Remote Rejected!",
"",
"Si trabajas en un equipo colaborativo, es probable que la rama `master` esté bloqueada y requiera algún proceso de `Pull Request` para poder `mergear` los cambios. Si haces `commit` directamente a `master` e intentas realizar `push`, recibirás un mensaje similar a este:",
"Si trabajas en un equipo colaborativo, es probable que la rama `main` esté bloqueada y requiera algún proceso de `Pull Request` para poder `mergear` los cambios. Si haces `commit` directamente a `main` e intentas realizar `push`, recibirás un mensaje similar a este:",
"",
"```",
" ! [remote rejected] master -> master (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```"
]
}
@ -332,9 +421,9 @@ exports.level = {
"markdowns": [
"## ¿Por qué fue rechazado?",
"",
"Se rechazó el `push` del `commit` a la rama `master` debido a la política en la rama `master` que requiere el uso de `Pull Requests`.",
"Se rechazó el `push` del `commit` a la rama `main` debido a la política en la rama `main` que requiere el uso de `Pull Requests`.",
"",
"Trataste de crear una rama y luego hacer `pushs` creando un `Pull Request`, pero te olvidaste e hiciste `commit` directamente a `master`. Ahora estás atascado y no puedes hacer `push` de tus cambios."
"Trataste de crear una rama y luego hacer `pushs` creando un `Pull Request`, pero te olvidaste e hiciste `commit` directamente a `main`. Ahora estás atascado y no puedes hacer `push` de tus cambios."
]
}
@ -345,7 +434,7 @@ exports.level = {
"markdowns": [
"## La solución",
"",
"Crea otra rama llamada `feature` y haz `push` a remoto. También restablece su rama `master` nuevamente para que esté sincronizado con el repositorio remoto; de lo contrario, puedes tener problemas la próxima vez que realices un `pull` y el `commit` de otra persona entre en conflicto con el tuyo."
"Crea otra rama llamada `feature` y haz `push` a remoto. También restablece su rama `main` nuevamente para que esté sincronizado con el repositorio remoto; de lo contrario, puedes tener problemas la próxima vez que realices un `pull` y el `commit` de otra persona entre en conflicto con el tuyo."
]
}
}
@ -359,10 +448,10 @@ exports.level = {
"markdowns": [
"## Oddaljena Zavrnitev!",
"",
"Če delaš v veliki ekipi je verjetno, da je master zaklenjen in zahteva Pull Request postopek za merganje sprememb. Če commitaš direktno na master lokalno, poizkusi pushati in dobil boš sporočilo podobno temu:",
"Če delaš v veliki ekipi je verjetno, da je main zaklenjen in zahteva Pull Request postopek za merganje sprememb. Če commitaš direktno na main lokalno, poizkusi pushati in dobil boš sporočilo podobno temu:",
"",
"```",
" ! [remote rejected] master -> master (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
" ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
"```"
]
}
@ -373,9 +462,9 @@ exports.level = {
"markdowns": [
"## Zakaj je bil zavrnjen?",
"",
"Oddaljen repo je zavrnil pushanje commitov direktno na master zaradi politike, da se uporabljajo le pull requesti.",
"Oddaljen repo je zavrnil pushanje commitov direktno na main zaradi politike, da se uporabljajo le pull requesti.",
"",
"Mišljeno je, da slediš temu procesu, da narediš branch, ga pushaš, nato pa narediš pull request, ampak si pozabil in commital direktno na master. Sedaj si zataknjen in ne moreš pushati svojih sprememb."
"Mišljeno je, da slediš temu procesu, da narediš branch, ga pushaš, nato pa narediš pull request, ampak si pozabil in commital direktno na main. Sedaj si zataknjen in ne moreš pushati svojih sprememb."
]
}
},
@ -385,7 +474,7 @@ exports.level = {
"markdowns": [
"## Rešitev",
"",
"Naredi še en branch imenovan feature in ga pushaj na remote. Prav tako resetiraj master nazaj, da bo v enakem stanju kot na oddaljenem repozitoriju, drugače imaš lahko težave naslednjič, ko boš pullal spremembe in bo konflikt s commitom nekoga drugega."
"Naredi še en branch imenovan feature in ga pushaj na remote. Prav tako resetiraj main nazaj, da bo v enakem stanju kot na oddaljenem repozitoriju, drugače imaš lahko težave naslednjič, ko boš pullal spremembe in bo konflikt s commitom nekoga drugega."
]
}
}

36
src/levels/remote/mergeManyFeatures.js
View file

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C11\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\",\"localBranchesThatTrackThis\":null},\"o/master\":{\"target\":\"C11\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":[\"master\"]},\"side1\":{\"target\":\"C2\",\"id\":\"side1\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null},\"side2\":{\"target\":\"C4\",\"id\":\"side2\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null},\"side3\":{\"target\":\"C7\",\"id\":\"side3\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C1\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"},\"C7\":{\"parents\":[\"C6\"],\"id\":\"C7\"},\"C8\":{\"parents\":[\"C1\"],\"id\":\"C8\"},\"C9\":{\"parents\":[\"C2\",\"C8\"],\"id\":\"C9\"},\"C10\":{\"parents\":[\"C4\",\"C9\"],\"id\":\"C10\"},\"C11\":{\"parents\":[\"C10\",\"C7\"],\"id\":\"C11\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C11\",\"id\":\"master\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C8\":{\"parents\":[\"C1\"],\"id\":\"C8\"},\"C5\":{\"parents\":[\"C1\"],\"id\":\"C5\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"},\"C9\":{\"parents\":[\"C2\",\"C8\"],\"id\":\"C9\"},\"C7\":{\"parents\":[\"C6\"],\"id\":\"C7\"},\"C10\":{\"parents\":[\"C4\",\"C9\"],\"id\":\"C10\"},\"C11\":{\"parents\":[\"C10\",\"C7\"],\"id\":\"C11\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"solutionCommand": "git checkout master;git pull;git merge side1;git merge side2;git merge side3;git push",
"solutionCommand": "git checkout main;git pull;git merge side1;git merge side2;git merge side3;git push",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\",\"localBranchesThatTrackThis\":null},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":[\"master\"]},\"side1\":{\"target\":\"C2\",\"id\":\"side1\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null},\"side2\":{\"target\":\"C4\",\"id\":\"side2\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null},\"side3\":{\"target\":\"C7\",\"id\":\"side3\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C1\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"},\"C7\":{\"parents\":[\"C6\"],\"id\":\"C7\"}},\"HEAD\":{\"target\":\"side3\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C8\",\"id\":\"master\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C8\":{\"parents\":[\"C1\"],\"id\":\"C8\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"name": {
"en_US": "Merging with remotes",
@ -46,7 +46,7 @@ exports.level = {
"markdowns": [
"## Why not merge?",
"",
"In order to push new updates to the remote, all you need to do is *incorporate* the latest changes from the remote. That means you can either rebase *or* merge in the remote branch (e.g. `o/master`).",
"In order to push new updates to the remote, all you need to do is *incorporate* the latest changes from the remote. That means you can either rebase *or* merge in the remote branch (e.g. `o/main`).",
"",
"So if you can do either method, why have the lessons focused on rebasing so far? Why is there no love for `merge` when working with remotes?",
""
@ -91,7 +91,7 @@ exports.level = {
"markdowns": [
"## Pourquoi pas merge ?",
"",
"Dans le but d'envoyer de nouvelles modifications sur le dépôt distant, la seule étape préliminaire est *d'incorporer* les derniers changements de ce dépôt dans le nôtre. Concrètement, vous pouvez faire un rebase *ou* un merge de la branche distante (c'est à dire de `o/master`).",
"Dans le but d'envoyer de nouvelles modifications sur le dépôt distant, la seule étape préliminaire est *d'incorporer* les derniers changements de ce dépôt dans le nôtre. Concrètement, vous pouvez faire un rebase *ou* un merge de la branche distante (c'est à dire de `o/main`).",
"",
"Donc si l'on peut faire les deux méthodes, pourquoi les leçons se sont-elles concentrées sur rebase jusqu'à présent ? Pourquoi préfère-t-on souvent éviter `merge` lorsque l'on travaille avec les branches distantes ?",
""
@ -136,7 +136,7 @@ exports.level = {
"markdowns": [
"## ¿Por qué no mergear?",
"",
"Para pushear tus novedades al remoto, todo lo que tenés que hacer es *integrar* los últimos cambios del remoto con los tuyos. Eso significa que podés hacer tanto rebase como merge con la rama remota (por ejemplo, `o/master`).",
"Para pushear tus novedades al remoto, todo lo que tenés que hacer es *integrar* los últimos cambios del remoto con los tuyos. Eso significa que podés hacer tanto rebase como merge con la rama remota (por ejemplo, `o/main`).",
"",
"Así que si podés hacer cualquiera de las dos, ¿por qué las lecciones sólo se centraron en rebasear hasta ahora? ¿Por qué no dedicarle algo de amor al `merge` cuando trabajamos con remotos?",
""
@ -181,7 +181,7 @@ exports.level = {
"markdowns": [
"## ¿Por qué no hacer merge?",
"",
"Para hacer push con tus novedades al remoto, todo lo que tienes que hacer es *integrar* los últimos cambios del remoto con los tuyos. Eso significa que puedes hacer tanto rebase como merge con la rama remota (por ejemplo, `o/master`).",
"Para hacer push con tus novedades al remoto, todo lo que tienes que hacer es *integrar* los últimos cambios del remoto con los tuyos. Eso significa que puedes hacer tanto rebase como merge con la rama remota (por ejemplo, `o/main`).",
"",
"Así que si puedes hacer cualquiera de las dos, ¿por qué las lecciones sólo se han centrado en rebasear hasta ahora? ¿Por qué no dedicarle algo de amor al `merge` cuando trabajamos con remotos?",
""
@ -226,7 +226,7 @@ exports.level = {
"markdowns": [
"## Por que não um merge?",
"",
"Para enviar novas atualizações ao repositório remoto, tudo que você precisa é *incorporar* as últimas mudanças ali presentes. Isso significa que você pode tanto fazer um rebase *quanto* um merge no ramo remoto (ex. `o/master`).",
"Para enviar novas atualizações ao repositório remoto, tudo que você precisa é *incorporar* as últimas mudanças ali presentes. Isso significa que você pode tanto fazer um rebase *quanto* um merge no ramo remoto (ex. `o/main`).",
"",
"Então, se você pode escolher qualquer um desses métodos, por que as lições focaram no rebase até o momento? Por que não demos nenhum amor ao `merge` quando trabalhamos com repositórios remotos?",
""
@ -271,7 +271,7 @@ exports.level = {
"markdowns": [
"## ¿Por qué non mesturar?",
"",
"Para empurrar as túas novidades ó remoto, todo o que tes que facer é *integrar* os últimos cambios do remoto cos teus. Eso significa que podes facer tanto rebase como merge ca rama remota (por exemplo, `o/master`).",
"Para empurrar as túas novidades ó remoto, todo o que tes que facer é *integrar* os últimos cambios do remoto cos teus. Eso significa que podes facer tanto rebase como merge ca rama remota (por exemplo, `o/main`).",
"",
"Así que podes facer calquera das dúas, ¿por qué as leccións só se centraron en rebasar ata agora? ¿Por qué non adicarlle algo de amor ó `merge` cando traballamos con remotos?",
""
@ -316,7 +316,7 @@ exports.level = {
"markdowns": [
"## 為何不要 merge？",
"",
"為了要 push 新的 commit 給 remote，你只需要做的是先同步 remote 的更新，那就表示你可以使用 rebase *或者*是 merge remote branch （例如，`o/master`）。",
"為了要 push 新的 commit 給 remote，你只需要做的是先同步 remote 的更新，那就表示你可以使用 rebase *或者*是 merge remote branch （例如，`o/main`）。",
"",
"所以假如你已經學會使用其中一個方式了，那為什麼我們到目前為止還在強調 `rebase`？為什麼當提到 remote 的時候，反而 `merge` 比較沒有受到關注？",
""
@ -361,7 +361,7 @@ exports.level = {
"markdowns": [
"## Warum nicht Merge?",
"",
"Um neue Dinge auf das Remote zu schieben musst du erst alle Änderungen vom Remote holen und bei dir integrieren. Das bedeutet du kannst den entfernten Branch (z.B. `o/master`) entweder Rebasen *oder* Mergen.",
"Um neue Dinge auf das Remote zu schieben musst du erst alle Änderungen vom Remote holen und bei dir integrieren. Das bedeutet du kannst den entfernten Branch (z.B. `o/main`) entweder Rebasen *oder* Mergen.",
"",
"Wenn du also beide Methoden benutzen kannst, warum haben sich die Level bisher auf Rebase konzentriert? Warum mag keiner `merge` wenn es um Remotes geht?",
""
@ -376,7 +376,7 @@ exports.level = {
"",
"Vorteile:",
"",
"* Rebasen macht den Commit-Baum sehr übersichtlich, weil alles linear aufeinander aufbaut",
"* Rebasen macht den Commit-Baum sehr übersichtlich, weil alles linear aufeinander aufbaut.",
"",
"Nachteile:",
"",
@ -384,7 +384,7 @@ exports.level = {
"",
"Zum Beispiel kann durch Rebasen Commit `C1` an Commit `C3` *vorbei* bewegt werden, bzw. eine Kopie von `C1`. Es sieht dann so aus als wären die Änderungen in `C1` nach denen in `C3` gemacht worden, obwohl das nicht stimmt.",
"",
"Manche Entwickler möchten lieber die History lassen wie sie ist und ziehen daher das Mergen vor. Andere (wie ich) haben lieber einen sauberen Commit-Baum und ziehen Rebase vor. Am Ende ist es eine Geschmacksfrage. :D"
"Manche Entwickler möchten lieber die History lassen, wie sie ist und ziehen daher das Mergen vor. Andere (wie ich) haben lieber einen sauberen Commit-Baum und ziehen Rebase vor. Am Ende ist es eine Geschmacksfrage. :D"
]
}
},
@ -406,7 +406,7 @@ exports.level = {
"markdowns": [
"## 为什么不用 merge 呢?",
"",
"为了 push 新变更到远程仓库，你要做的就是**包含**远程仓库中最新变更。意思就是只要你的本地分支包含了远程分支（如 `o/master`）中的最新变更就可以了，至于具体是用 rebase 还是 merge，并没有限制。",
"为了 push 新变更到远程仓库，你要做的就是**包含**远程仓库中最新变更。意思就是只要你的本地分支包含了远程分支（如 `o/main`）中的最新变更就可以了，至于具体是用 rebase 还是 merge，并没有限制。",
"",
"那么既然没有规定限制，为何前面几节都在着重于 rebase 呢？为什么在操作远程分支时不喜欢用 `merge` 呢？",
""
@ -451,7 +451,7 @@ exports.level = {
"markdowns": [
"## なぜマージではいけないのか？",
"",
"新しい更新をリモートにプッシュするため、あなたがする必要があるのはリモートからの最近の変更の*組み込み*です。それは、リモートブランチ(例えば、`o/master`)にリベース*か*マージのどちらかをあなたがする必要があるということを意味します。",
"新しい更新をリモートにプッシュするため、あなたがする必要があるのはリモートからの最近の変更の*組み込み*です。それは、リモートブランチ(例えば、`o/main`)にリベース*か*マージのどちらかをあなたがする必要があるということを意味します。",
"",
"もしどっちの方法でも行うことができるなら、なぜこれまでのレッスンでは、リベースに焦点を当ててきたのでしょう？リモートへの作業で、なぜ`merge`を推してこなかったのでしょうか？",
""
@ -496,7 +496,7 @@ exports.level = {
"markdowns": [
"## Merge? Нет, нет, спасибо.",
"",
"Чтобы закачать (push) новые изменения в удалённый репозиторий, всё, что вам нужно сделать - это *смешать* последние изменения из удалённого репозитория. Это значит, что вы можете выполнить rebase *или* merge на удалённом репозитории (например, `o/master`).",
"Чтобы закачать (push) новые изменения в удалённый репозиторий, всё, что вам нужно сделать - это *смешать* последние изменения из удалённого репозитория. Это значит, что вы можете выполнить rebase *или* merge на удалённом репозитории (например, `o/main`).",
"",
"Если мы можем воспользоваться одним из двух методов, то почему же эти упражнения сфокусированы в основном на rebase? К чему такая нелюбовь к `merge`, когда речь идёт о работе с удалёнными репозиториями?",
""
@ -541,7 +541,7 @@ exports.level = {
"markdowns": [
"## 왜 merge하지 않는거죠?",
"",
"새로운 작업들을 원격 저장소로 push하기위해서 여러분은 원격 저장소의 최근 변경들을 *합치기*만 하면 됩니다. 이 말은 즉 원격 브랜치로(예:`o/master`) rebase를 할 수도 merge를 할 수도 있다는 것입니다.",
"새로운 작업들을 원격 저장소로 push하기위해서 여러분은 원격 저장소의 최근 변경들을 *합치기*만 하면 됩니다. 이 말은 즉 원격 브랜치로(예:`o/main`) rebase를 할 수도 merge를 할 수도 있다는 것입니다.",
"",
"두가지를 다 할 수 있다면, 왜 지금까지 배운 레슨들은 rebase를 하는것에 집중한거죠? 원격 저장소와 작업을 할때는 왜 `merge`에게 관심을 가져주지 않는건가요?",
""
@ -586,7 +586,7 @@ exports.level = {
"markdowns": [
"## Чому б не змерджити?",
"",
"Для того, щоб віддалений сервер прийняв твої зміни, треба *об'єднати* їх з останніми змінами на сервері. Це означає ребейс *або* мердж з віддаленою гілкою (напр. `o/master`).",
"Для того, щоб віддалений сервер прийняв твої зміни, треба *об'єднати* їх з останніми змінами на сервері. Це означає ребейс *або* мердж з віддаленою гілкою (напр. `o/main`).",
"",
"Хмм, якщо можна використати один із цих методів, для чого нам додаткові уроки про ребейс? Чому ніхто не любить `merge`, працюючи з віддаленим сервером?",
""
@ -631,7 +631,7 @@ exports.level = {
"markdowns": [
"## Tại sao không hợp nhất?",
"",
"Để có thể đẩy cập nhật của bạn lên kho nhánh từ xa, tất cả những gì bạn cần làm là *kết nạp* thay đổi mới nhất từ nhánh từ xa. Nghĩa là bạn có thể dùng tái bố trí *hoặc* hợp nhất với nhánh từ xa (ví dụ `o/master`).",
"Để có thể đẩy cập nhật của bạn lên kho nhánh từ xa, tất cả những gì bạn cần làm là *kết nạp* thay đổi mới nhất từ nhánh từ xa. Nghĩa là bạn có thể dùng tái bố trí *hoặc* hợp nhất với nhánh từ xa (ví dụ `o/main`).",
"",
"Vậy ta có thể sử dụng một trong 2 cách, thì tại sao đến giờ ta chỉ tập trung vào tái bố trí trong các bài học? Tại sao khi làm việc với nhánh từ xa lại ta lại không thích `hợp nhất` (`merge`)?",
""
@ -676,7 +676,7 @@ exports.level = {
"markdowns": [
"## Zakaj ne merganje?",
"",
"Da bi poslal nove spremembe na oddaljen repo, je vse kar moraš narediti, da *vključiš* zadnje spremembe iz oddaljenega repota. To pomeni, da lahko rebaseaš *ali* mergeaš v oddaljeni branch (npr. `o/master`).",
"Da bi poslal nove spremembe na oddaljen repo, je vse kar moraš narediti, da *vključiš* zadnje spremembe iz oddaljenega repota. To pomeni, da lahko rebaseaš *ali* mergeaš v oddaljeni branch (npr. `o/main`).",
"",
"Torej če lahko narediš katero izmed metod, zakaj imeti lekcijo, ki se zaenkrat osredotoča na rebaseanje? Zakaj ni nobene ljubezni do `mergea` pri delanju z oddaljenimi repoti?",
""

156
src/levels/remote/pull.js
View file

@ -49,9 +49,9 @@ exports.level = {
"",
"There are actually many ways to do this -- once you have new commits available locally, you can incorporate them as if they were just normal commits on other branches. This means you could execute commands like:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* etc., etc.",
"",
"In fact, the workflow of *fetching* remote changes and then *merging* them is so common that git actually provides a command that does both at once! That command is `git pull`."
@ -65,9 +65,9 @@ exports.level = {
"Let's first see a `fetch` and a `merge` executed sequentially."
],
"afterMarkdowns": [
"Boom -- we downloaded `C3` with a `fetch` and then merged in that work with `git merge o/master`. Now our `master` branch reflects the new work from the remote (in this case, named `origin`)"
"Boom -- we downloaded `C3` with a `fetch` and then merged in that work with `git merge o/main`. Now our `main` branch reflects the new work from the remote (in this case, named `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -108,9 +108,9 @@ exports.level = {
"",
"Il existe en fait beaucoup de façons de faire cela -- une fois que vous avez de nouveaux commits disponibles localement, vous pouvez les incorporer dans votre branche de travail comme s'ils étaient des commits normaux d'autres branches. Cela signifie que pourriez simplement exécuter des commandes comme :",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* etc., etc.",
"",
"En fait, le principe de *rapatrier* (fetch) les branches distantes puis les *fusionner* (merge) est si commun que git a en réalité une commande pour faire les deux à la fois ! Cette commande est `git pull`."
@ -124,9 +124,9 @@ exports.level = {
"Voyons d'abord un `fetch` puis un `merge` exécutés séquentiellement."
],
"afterMarkdowns": [
"Boum -- nous avons téléchargé `C3` avec un `fetch` et ensuite nous avons fusionné ce travail dans notre copie avec `git merge o/master`. Maintenant notre branche `master` reflète le nouveau travail du dépôt distant (dans ce cas, nommé `origin`)"
"Boum -- nous avons téléchargé `C3` avec un `fetch` et ensuite nous avons fusionné ce travail dans notre copie avec `git merge o/main`. Maintenant notre branche `main` reflète le nouveau travail du dépôt distant (dans ce cas, nommé `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -167,9 +167,9 @@ exports.level = {
"",
"Realmente hay varias formas de hacer esto: una vez que tenés los commits disponibles localmente, podés integrarlos como si fueran commits comunes de otras ramas. Esto significa que podrías ejecutar comandos como:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* etc., etc.",
"",
"De hecho, el flujo de trabajo de *fetchear* cambios remotos y después *mergearlos* es tan común que git incluye un comando que hace ambas cosas de una: ¡`git pull`!"
@ -183,9 +183,9 @@ exports.level = {
"Veamos primero un `fetch` y un `merge` ejecutados secuencialmente."
],
"afterMarkdowns": [
"Boom: descargamos `C3` con un `fetch` y luego lo mergeamos con `git merge o/master`. Ahora nuestra rama `master` refleja el nuevo trabajo del remoto (en este caso, llamado `origin`)"
"Boom: descargamos `C3` con un `fetch` y luego lo mergeamos con `git merge o/main`. Ahora nuestra rama `main` refleja el nuevo trabajo del remoto (en este caso, llamado `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -226,9 +226,9 @@ exports.level = {
"",
"Realmente hay varias formas de hacer esto: una vez que tienes los commits disponibles localmente, puedes integrarlos como si fueran commits comunes de otras ramas. Esto significa que podrías ejecutar comandos como:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* etc., etc.",
"",
"De hecho, el flujo de trabajo de *fetchear* cambios remotos y después *mergearlos* es tan común que git incluye un comando que hace ambas cosas de una: ¡`git pull`!"
@ -242,9 +242,9 @@ exports.level = {
"Veamos primero un `fetch` y un `merge` ejecutados secuencialmente."
],
"afterMarkdowns": [
"Zas: descargamos `C3` con un `fetch` y luego lo mergeamos con `git merge o/master`. Ahora nuestra rama `master` refleja el nuevo trabajo del remoto (en este caso, llamado `origin`)"
"Zas: descargamos `C3` con un `fetch` y luego lo mergeamos con `git merge o/main`. Ahora nuestra rama `main` refleja el nuevo trabajo del remoto (en este caso, llamado `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -285,9 +285,9 @@ exports.level = {
"",
"Há, na verdade, muitas formas de fazê-lo -- uma vez que você tenha os novos commits disponíveis localmente, você pode incorporá-los como se eles fossem commits normais em outros ramos. Isso significa que você pode executar comandos como estes a seguir:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* etc., etc.",
"",
"O fluxo de trabalho de executar *fetch* para baixar as mudanças remotas e depois fazer um *merge* delas é tão comum que o Git na verdade fornece um comando que faz ambas as coisas de uma vez só! Esse comando é o `git pull`."
@ -301,9 +301,9 @@ exports.level = {
"Vamos primeiro ver um `fetch` e um `merge` executados sequencialmente."
],
"afterMarkdowns": [
"Boom -- nós baixamos o `C3` com um `fetch` e então fizemos um merge desse trabalho usando `git merge o/master`. Agora o nosso ramo `master` reflete o trabalho realizado no repositório remoto (neste caso, chamado de `origin`)"
"Boom -- nós baixamos o `C3` com um `fetch` e então fizemos um merge desse trabalho usando `git merge o/main`. Agora o nosso ramo `main` reflete o trabalho realizado no repositório remoto (neste caso, chamado de `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -344,9 +344,9 @@ exports.level = {
"",
"Realmente hai varias formas de facer esto: unha vez que teñas os commits dispoñibles localmente, podes integralos coma se foran commits comúns de outras ramas. Esto significa que poderías executar comandos como:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* etc., etc.",
"",
"De feito, o fluxo de traballo de *fetchear* os cambios remotos e depois *mesturalos* é tan común que git inclúe un comando que fai as dúas operacións nunha sola: ¡`giti pull`!"
@ -360,9 +360,9 @@ exports.level = {
"Vexamos primeiro un `fetch` e un `merge` executados secuencialmente."
],
"afterMarkdowns": [
"Boom: descargamos `C3` cun `fetch` e logo mesturámolos con `git merge o/master`. Agora a nosa rama `master` reflexa o novo traballo do remoto (neste caso, chamado `origin`)"
"Boom: descargamos `C3` cun `fetch` e logo mesturámolos con `git merge o/main`. Agora a nosa rama `main` reflexa o novo traballo do remoto (neste caso, chamado `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -403,9 +403,9 @@ exports.level = {
"",
"只要在你的 local 有 fetch 到新的 commit，便有很多方法可以做到這件事情，你可以把它們視為在其它 branch 上面的一般的 commit，這表示你可以執行像這樣子的指令:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* 等等‧‧‧",
"",
"事實上，一次*下載 (fetch)* remote 的更新並且*合併（merge）* 這些更新在 git 裡面是很常見的事情！這個命令叫作 `git pull`。"
@ -419,9 +419,9 @@ exports.level = {
"讓我們來看循序執行一個 `fetch` 和一個 `merge` 的樣子"
],
"afterMarkdowns": [
"看吧! 我們利用 `fetch` 下載了 `C3` 並且利用 `git merge o/master` 來更新資料，現在我們的 `master` branch 跟 remote 同步了（在這個例子中，remote repository 叫作 `origin`）。"
"看吧! 我們利用 `fetch` 下載了 `C3` 並且利用 `git merge o/main` 來更新資料，現在我們的 `main` branch 跟 remote 同步了（在這個例子中，remote repository 叫作 `origin`）。"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -462,9 +462,9 @@ exports.level = {
"",
"其实有很多方法的 —— 当远程分支中有新的提交时，你可以像合并本地分支那样来合并远程分支。也就是说就是你可以执行以下命令: ",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* 等等",
"",
"实际上，由于先抓取更新再合并到本地分支这个流程很常用，因此 Git 提供了一个专门的命令来完成这两个操作。它就是我们要讲的 `git pull`。"
@ -478,9 +478,9 @@ exports.level = {
"我们先来看看 `fetch`、`merge` 依次执行的效果"
],
"afterMarkdowns": [
"我们用 `fetch` 下载了 `C3`, 然后通过 `git merge o/master` 合并了这一提交记录。现在我们的 `master` 分支包含了远程仓库中的更新（在本例中远程仓库名为 `origin`）"
"我们用 `fetch` 下载了 `C3`, 然后通过 `git merge o/main` 合并了这一提交记录。现在我们的 `main` 分支包含了远程仓库中的更新（在本例中远程仓库名为 `origin`）"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -517,16 +517,16 @@ exports.level = {
"markdowns": [
"## Git Pull",
"",
"Jetzt, wo wir wissen wie wir mit `git fetch` Daten von einem entfernten Repository holen können, wollen wir unsere lokalen Daten aktualisieren, damit sie die Änderungen vom Server beinhalten.",
"Jetzt, wo wir wissen, wie wir mit `git fetch` Daten von einem entfernten Repository holen können, wollen wir unsere lokalen Daten aktualisieren, damit sie die Änderungen vom Server beinhalten.",
"",
"Tatsächlich gibt es eine Menge Wege dies zu erreichen -- sobald du die neuen Commits lokal verfügbar hast, kannst du sie integrieren so als wären es Commits von ganz normalen anderen Branches. Du kannst also:",
"Tatsächlich gibt es eine Menge Wege dies zu erreichen -- sobald du die neuen Commits lokal verfügbar hast, kannst du sie integrieren wie Commits von ganz normalen anderen Branches. Du kannst also:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* usw. usf. ausführen.",
"",
"Der Ablauf, die Änderungen vom Server zu holen und dann in die eigene Arbeit zu mergen wird so häufig benötigt, dass Git einen Befehl kennt der beides auf einmal erledigt! Das ist `git pull`."
"Änderungen vom Server zu holen und dann in die eigene Arbeit zu mergen wird so häufig benötigt, dass Git einen Befehl kennt, der beides auf einmal erledigt! Das ist `git pull`."
]
}
},
@ -537,9 +537,9 @@ exports.level = {
"Schauen wir uns erst mal ein `fetch` gefolgt von `merge` an:"
],
"afterMarkdowns": [
"Bämm -- wir haben `C3` mit `fetch` heruntergeladen und dann in unseren Branch mit `git merge o/master` integriert. Nun bildet unser `master` dieselben Inhalte ab, wie sie auf dem entfernten Server (`origin`) liegen."
"Bämm -- wir haben `C3` mit `fetch` heruntergeladen und dann in unseren Branch mit `git merge o/main` integriert. Nun bildet unser `main` dieselben Inhalte ab, wie sie auf dem entfernten Server (`origin`) liegen."
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -580,9 +580,9 @@ exports.level = {
"",
"Существует множество вариантов решений - как только у вас имеется локальный коммит, вы можете соединить его с другой веткой. Это значит, вы можете выполнить одну из команд:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* и т.д.",
"",
"Процедура *скачивания (fetching)* изменений с удалённой ветки и *объединения (merging)* настолько частая и распространённая, что git предоставляет вместо двух команд - одну! Эта команда - `git pull`."
@ -596,9 +596,9 @@ exports.level = {
"Давайте рассмотрим, как `fetch` и `merge` выполняются последовательно"
],
"afterMarkdowns": [
"Опа - мы скачали `C3` с помощью команды `fetch` и затем объединяем эти наработки с помощью `git merge o/master`. Теперь наша ветка `master` отображает изменения с удалённого репозитория (в данном случае — с репозитория `origin`)"
"Опа - мы скачали `C3` с помощью команды `fetch` и затем объединяем эти наработки с помощью `git merge o/main`. Теперь наша ветка `main` отображает изменения с удалённого репозитория (в данном случае — с репозитория `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -639,9 +639,9 @@ exports.level = {
"",
"実際には多くの方法があり、ローカルに利用可能なリモートの新しいコミットがある場合、あなたはそのコミットを他のブランチの通常のコミットと同じように、自分の作業に組み込むことができます。これは、あなたが次のようなコマンドを実行することで行えます:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* その他",
"",
"実は、リモートの変更を取ってきてマージするという作業の流れはとてもよく行われるので、gitは実際にはその二つを同時に行うコマンドを提供しているのです！それは、`git pull`というコマンドです。"
@ -655,9 +655,9 @@ exports.level = {
"まずは、連続して`fetch`して`merge`する流れの方を見てみましょう。"
],
"afterMarkdowns": [
"わーお。私たちは`C3`を`fetch`でダウンロードして、`git merge o/master`でこれをマージしました。今や私たちの`master`ブランチに(この場合、`origin`という名前の)リモートの新しい作業内容が反映されています。"
"わーお。私たちは`C3`を`fetch`でダウンロードして、`git merge o/main`でこれをマージしました。今や私たちの`main`ブランチに(この場合、`origin`という名前の)リモートの新しい作業内容が反映されています。"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -698,9 +698,9 @@ exports.level = {
"",
"Насправді, є кілька шляхів як цого досягнути -- щойно нові коміти з’явилися локально, ти можеш додавати їх в бранчі так само, як звичайні коміти. Це означає що ти можеш виконувати команди:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* тощо.",
"",
"Насправді, процес *витягування* віддалених змін й подальший *мерджинг* їх є настільки популярним, що гіт пропонує спеціальну команду, що виконує ці дві дії за один раз! Ця команда називається `git pull`."
@ -714,9 +714,9 @@ exports.level = {
"Спершу виконаймо по черзі `fetch`, а потім `merge`."
],
"afterMarkdowns": [
"Ка-бум -- ми звантажили `C3` за допомогою `fetch` і потім змерджили їх, використавши `git merge o/master`. Тепер наша гілка `master` відповідає гілці з віддаленого сховища (в цьому випадку, з назвою `origin`)"
"Ка-бум -- ми звантажили `C3` за допомогою `fetch` і потім змерджили їх, використавши `git merge o/main`. Тепер наша гілка `main` відповідає гілці з віддаленого сховища (в цьому випадку, з назвою `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -757,9 +757,9 @@ exports.level = {
"",
"사실 이걸 하는 방법은 여러가지 있습니다 -- 새 커밋들을 로컬에 내려받은 이후에는 그냥 다른 브랜치에있는 일반 커밋처럼 활용할 수 있습니다. 이런 명령들을 실행할 수 있다는 뜻 입니다 :",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* 기타 등등",
"",
"사실 원격 저장소의 변경을 *fetch*하고 그이후에 *merge*하는 작업의 과정이 워낙 자주있는 일이라서 git은 이 두가지를 한번에 하는 명령을 제공합니다! 이 명령어는 `git pull` 입니다."
@ -773,9 +773,9 @@ exports.level = {
"먼저 `fetch` 와 `merge`가 차례로 실행되는것을 확인해 봅시다"
],
"afterMarkdowns": [
"Boom -- 우리는 `C3`를 `fetch`로 내려 받고 `git merge o/master`로 우리의 작업으로 병합했습니다. 이제 우리의 `master` 브랜치는 원격 저장소의 새 작업들을 반영하게 됩니다(지금 사례에서 `origin`입니다)."
"Boom -- 우리는 `C3`를 `fetch`로 내려 받고 `git merge o/main`로 우리의 작업으로 병합했습니다. 이제 우리의 `main` 브랜치는 원격 저장소의 새 작업들을 반영하게 됩니다(지금 사례에서 `origin`입니다)."
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -816,9 +816,9 @@ exports.level = {
"",
"Thực ra thì có nhiều cách đề làm điều này -- một khi bạn đã có các commit này ở ko chứa địa phương, bạn có thể hợp nhất chúng như với các commit ở các nhánh khác. Nghĩa là bạn có thể sử dụng các câu lệnh sau:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* etc., etc.",
"",
"Thực tế thì, quá trình *nạp* commit từ kho chứa từ xa và *hợp nhất* chúng phổ biết đến nỗi git cung cấp một câu lệnh để làm cả 2 điều này một lúc! Đó là `git pull`."
@ -832,9 +832,9 @@ exports.level = {
"Trước tiên hãy xem quá trình `nạp` và `hợp nhất` được thực hiện một cách tuần tự."
],
"afterMarkdowns": [
"Bùùm -- ta tải xuống commit `C3` với lệnh `git fetch` rồi sau đó hợp nhất nó với lệnh `git merge o/master`. Giờ thì nhánh `master` đã phản ánh trạng thái mới từ kho chứa từ xa (trong trường hợp này là `origin`)"
"Bùùm -- ta tải xuống commit `C3` với lệnh `git fetch` rồi sau đó hợp nhất nó với lệnh `git merge o/main`. Giờ thì nhánh `main` đã phản ánh trạng thái mới từ kho chứa từ xa (trong trường hợp này là `origin`)"
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},
@ -875,9 +875,9 @@ exports.level = {
"",
"V bistvu je več načinov za izvedbo tega -- ko imaš enkrat lokalno na voljo nove commite, jih lahko vključiš, kot da so normalni commiti na drugem branchu. To pomeni, da lahko izvedeš ukaze, kot so:",
"",
"* `git cherry-pick o/master`",
"* `git rebase o/master`",
"* `git merge o/master`",
"* `git cherry-pick o/main`",
"* `git rebase o/main`",
"* `git merge o/main`",
"* itd., itd.",
"",
"Pravzaprav je *fetchanje* oddaljenih sprememb in kasneje *merganje* le-teh tako pogosto, da ima git dejansko ukaz, ki naredi oboje! Ukaz je `git pull`."
@ -891,9 +891,9 @@ exports.level = {
"Poglejmo najprej `fetch` in `merge` izvedena zaporedno:"
],
"afterMarkdowns": [
"Boom -- prenesli smo `C3` s `fetch` in nato mergali delo z `git merge o/master`. Sedaj naš `master` branch odseva spremembe novega dela iz oddaljenega repoztorija (v tem primeru poimenovan `origin`)."
"Boom -- prenesli smo `C3` s `fetch` in nato mergali delo z `git merge o/main`. Sedaj naš `main` branch odseva spremembe novega dela iz oddaljenega repoztorija (v tem primeru poimenovan `origin`)."
],
"command": "git fetch; git merge o/master",
"command": "git fetch; git merge o/main",
"beforeCommand": "git clone; git commit; git fakeTeamwork"
}
},

118
src/levels/remote/pullArgs.js
View file

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C6\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"o/bar\":{\"target\":\"C1\",\"id\":\"o/bar\",\"remoteTrackingBranchID\":null},\"foo\":{\"target\":\"C3\",\"id\":\"foo\",\"remoteTrackingBranchID\":null},\"side\":{\"target\":\"C2\",\"id\":\"side\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C4\":{\"parents\":[\"C1\"],\"id\":\"C4\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C5\":{\"parents\":[\"C3\",\"C4\"],\"id\":\"C5\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C6\":{\"parents\":[\"C2\",\"C5\"],\"id\":\"C6\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"bar\":{\"target\":\"C3\",\"id\":\"bar\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"}},\"HEAD\":{\"target\":\"bar\",\"id\":\"HEAD\"}}}",
"solutionCommand": "git pull origin bar:foo;git pull origin master:side",
"solutionCommand": "git pull origin bar:foo;git pull origin main:side",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C4\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"o/bar\":{\"target\":\"C1\",\"id\":\"o/bar\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C4\":{\"parents\":[\"C1\"],\"id\":\"C4\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"bar\":{\"target\":\"C3\",\"id\":\"bar\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"}},\"HEAD\":{\"target\":\"bar\",\"id\":\"HEAD\"}}}",
"name": {
"en_US": "Pull arguments",
@ -82,9 +82,9 @@ exports.level = {
"If we specify the place to fetch, everything happens as before with fetch but we merge in whatever was just fetched."
],
"afterMarkdowns": [
"See! by specifying `master` we downloaded commits onto `o/master` just as normal. Then we merged `o/master` to our currently checked out location which is *not* the local branch `master`. For this reason it can actually make sense to run git pull multiple times (with the same args) from different locations in order to update multiple branches."
"See! by specifying `main` we downloaded commits onto `o/main` just as normal. Then we merged `o/main` to our currently checked out location which is *not* the local branch `main`. For this reason it can actually make sense to run git pull multiple times (with the same args) from different locations in order to update multiple branches."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -95,9 +95,9 @@ exports.level = {
"Does it work with source and destination too? You bet! Let's see that:"
],
"afterMarkdowns": [
"Wow, that's a TON in one command. We created a new branch locally named `foo`, downloaded commits from remote's master onto that branch `foo`, and then merged that branch into our currently checked out branch `bar`. It's over 9000!!!"
"Wow, that's a TON in one command. We created a new branch locally named `foo`, downloaded commits from remote's main onto that branch `foo`, and then merged that branch into our currently checked out branch `bar`. It's over 9000!!!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -156,9 +156,9 @@ exports.level = {
"Si nous précisons l'emplacement à rapatrier tout se passe comme précédemment, avec fetch, mais en sus nous fusionnons tout ce qui a été rapatrié."
],
"afterMarkdowns": [
"Vu ? En précisant `master` nous avons téléchargé les commits dans `o/master` comme d'habitude. Puis nous avons fusionné `o/master` avec là où nous sommes, *sans nous soucier* de la branche courante."
"Vu ? En précisant `main` nous avons téléchargé les commits dans `o/main` comme d'habitude. Puis nous avons fusionné `o/main` avec là où nous sommes, *sans nous soucier* de la branche courante."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -169,9 +169,9 @@ exports.level = {
"Cela fonctionne-t-il aussi bien avec une source et une destination ? Et oui ! Voyons cela :"
],
"afterMarkdowns": [
"Wow, INCROYABLE tout ce que nous avons fait en une commande. Nous avons créé une branche locale nommée `foo`, téléchargé les commits depuis la branche master distante dans `foo`, et ensuite fusionné cette branche dans notre branche actuelle de travail (checkoutée) `bar` !!!"
"Wow, INCROYABLE tout ce que nous avons fait en une commande. Nous avons créé une branche locale nommée `foo`, téléchargé les commits depuis la branche main distante dans `foo`, et ensuite fusionné cette branche dans notre branche actuelle de travail (checkoutée) `bar` !!!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -230,9 +230,9 @@ exports.level = {
"Si especificamos el lugar del que hacer fetch, todo ocurre como antes, pero sólo mergeamos lo que se fetcheó."
],
"afterMarkdowns": [
"¡Ves! Especificando `master` bajamos los commits a `o/master` como siempre. Después mergeamos `o/master` a nuestra rama actual, *sin importar* qué había en nuestra copia de trabajo."
"¡Ves! Especificando `main` bajamos los commits a `o/main` como siempre. Después mergeamos `o/main` a nuestra rama actual, *sin importar* qué había en nuestra copia de trabajo."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -243,9 +243,9 @@ exports.level = {
"¿Esto funciona con origen y destino, también? ¡Más vale! Veámoslo:"
],
"afterMarkdowns": [
"Wow, eso es un MONTÓN en un único comando. Creamos una nueva rama local llamada `foo`, descargamos los commits del master del remoto a esta rama `foo`, y después mezclamos esa rama a nuestra rama actual `bar`. ¡¡¡Supera los 9000!!!"
"Wow, eso es un MONTÓN en un único comando. Creamos una nueva rama local llamada `foo`, descargamos los commits del main del remoto a esta rama `foo`, y después mezclamos esa rama a nuestra rama actual `bar`. ¡¡¡Supera los 9000!!!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -304,9 +304,9 @@ exports.level = {
"Si especificamos el lugar desde donde hacer fetch, todo ocurre como antes, pero sólo mergeamos lo que se fetcheó."
],
"afterMarkdowns": [
"¡Ves! Especificando `master` descargamos los commits a `o/master` como siempre. Después mergeamos `o/master` a nuestra rama actual, *sin importar* qué había en nuestra copia de trabajo."
"¡Ves! Especificando `main` descargamos los commits a `o/main` como siempre. Después mergeamos `o/main` a nuestra rama actual, *sin importar* qué había en nuestra copia de trabajo."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -317,9 +317,9 @@ exports.level = {
"¿Esto funciona con origen y destino, también? ¡Más vale! Veámoslo:"
],
"afterMarkdowns": [
"Caramba, eso es una BARBARIDAD en un único comando. Creamos una nueva rama local llamada `foo`, descargamos los commits del master del remoto a esta rama `foo`, y después mezclamos esa rama a nuestra rama actual `bar`. ¡¡¡Supera los 9000!!!"
"Caramba, eso es una BARBARIDAD en un único comando. Creamos una nueva rama local llamada `foo`, descargamos los commits del main del remoto a esta rama `foo`, y después mezclamos esa rama a nuestra rama actual `bar`. ¡¡¡Supera los 9000!!!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -378,9 +378,9 @@ exports.level = {
"Se especificarmos o lugar onde fazer o fetch, tudo acontece como antes com o fetch, mas fazemos o merge naquilo que acabou de ser baixado."
],
"afterMarkdowns": [
"Veja! Especificando `master` nós baixamos commits em `o/master` como sempre. Então fizemos um merge de `o/master` com o lugar onde estamos, *independente* daquilo que está atualmente em checkout."
"Veja! Especificando `main` nós baixamos commits em `o/main` como sempre. Então fizemos um merge de `o/main` com o lugar onde estamos, *independente* daquilo que está atualmente em checkout."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -391,9 +391,9 @@ exports.level = {
"Isso também funciona com origem e destino especificados? Sim, você acertou! Vejamos:"
],
"afterMarkdowns": [
"Wow, isso é MUITA coisa em um comando só. Nós criamos um novo ramo local chamado `foo`, baixamos commits do master remoto nesse ramo `foo`, e então fizemos um merge dele com o ramo atualmente em checkout, `bar`."
"Wow, isso é MUITA coisa em um comando só. Nós criamos um novo ramo local chamado `foo`, baixamos commits do main remoto nesse ramo `foo`, e então fizemos um merge dele com o ramo atualmente em checkout, `bar`."
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -452,9 +452,9 @@ exports.level = {
"Se especificamos o lugar do que facer o fetch, todo ocorre coma antes, pero só mesturamos o que se descargou."
],
"afterMarkdowns": [
"¡Ves! Indicando `master` baixamos os commits á `o/master` coma sempre. Despois mesturamos `o/master` á nosa rama actual, *sen importar* qué tiñamos na nos copia de traballo."
"¡Ves! Indicando `main` baixamos os commits á `o/main` coma sempre. Despois mesturamos `o/main` á nosa rama actual, *sen importar* qué tiñamos na nos copia de traballo."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -465,9 +465,9 @@ exports.level = {
"¿Esto funciona co orixe e o destino, tamén? ¡Máis lle vale! Vexámolo:"
],
"afterMarkdowns": [
"Wow, eso es unha CHEA nun único comando. Creamos unha nova rama local chamada `foo`, descargamos os commits do master do remoto a esta rama `foo`, e logo mesturamos esa rama á nosa rama actual `bar`. ¡¡¡Supera os 9000!!!"
"Wow, eso es unha CHEA nun único comando. Creamos unha nova rama local chamada `foo`, descargamos os commits do main do remoto a esta rama `foo`, e logo mesturamos esa rama á nosa rama actual `bar`. ¡¡¡Supera os 9000!!!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -526,9 +526,9 @@ exports.level = {
"如果我們在 fetch 的時候有指定`位置`的話，跟之前一樣，fetch 所做的事情沒有變，但是我們會 merge 我們剛剛所 fetch 的該`位置`的commit。"
],
"afterMarkdowns": [
"看吧！指定位置為 `master`，跟平常一樣，我們下載了 commit 並且放到 `o/master` 上，接著，我們會 merge `o/master` 到我們現在的位置，*不管*我們現在所 checkout 的位置在哪裡。"
"看吧！指定位置為 `main`，跟平常一樣，我們下載了 commit 並且放到 `o/main` 上，接著，我們會 merge `o/main` 到我們現在的位置，*不管*我們現在所 checkout 的位置在哪裡。"
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -539,9 +539,9 @@ exports.level = {
"他是不是也可以同時指定 source 以及 destination？你說對了啦！讓我們來看一下："
],
"afterMarkdowns": [
"哇！這個指令強而有力，我們在 local 建立了一個新的 `foo` branch，下載了 remote 的 `master` 的 commit，並且放到 local 的 `foo` branch，之後 merge `foo` branch 到我們目前所 checkout 的 `bar` branch。這實在是太超過了！！！"
"哇！這個指令強而有力，我們在 local 建立了一個新的 `foo` branch，下載了 remote 的 `main` 的 commit，並且放到 local 的 `foo` branch，之後 merge `foo` branch 到我們目前所 checkout 的 `bar` branch。這實在是太超過了！！！"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -600,9 +600,9 @@ exports.level = {
"如果我们指定要抓取的 place，所有的事情都会跟之前一样发生，只是增加了 merge 操作"
],
"afterMarkdowns": [
"看到了吧! 通过指定 `master` 我们更新了 `o/master`。然后将 `o/master` merge 到我们的检出位置，**无论**我们当前检出的位置是哪。"
"看到了吧! 通过指定 `main` 我们更新了 `o/main`。然后将 `o/main` merge 到我们的检出位置，**无论**我们当前检出的位置是哪。"
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -613,9 +613,9 @@ exports.level = {
"pull 也可以用 source:destination 吗? 当然喽, 看看吧:"
],
"afterMarkdowns": [
" 哇, 这个命令做的事情真多。它先在本地创建了一个叫 `foo` 的分支，从远程仓库中的 master 分支中下载提交记录，并合并到 `foo`，然后再 merge 到我们的当前检出的分支 `bar` 上。操作够多的吧？！"
" 哇, 这个命令做的事情真多。它先在本地创建了一个叫 `foo` 的分支，从远程仓库中的 main 分支中下载提交记录，并合并到 `foo`，然后再 merge 到我们的当前检出的分支 `bar` 上。操作够多的吧？！"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -639,7 +639,7 @@ exports.level = {
"",
"Da du jetzt so ziemlich *alles* kennst, was es an Optionen für `git fetch` und `git push` gibt, ist kaum noch etwas zu Optionen für `git pull` zu sagen. :)",
"",
"Das liegt daran, dass `git pull` letztendlich *wirklich* nur eine Abkürzuung für `fetch` gefolgt von einem `merge` von was auch immer gerade heruntergeladen wurde, ist. Denk es dir als ein `git fetch` mit denselben Optionen und einem anschließenden Merge.",
"Das liegt daran, dass `git pull` letztendlich *wirklich* nur eine Abkürzuung für `fetch` gefolgt von einem `merge` von dem, was auch immer gerade heruntergeladen wurde, ist. Denk es dir als ein `git fetch` mit denselben Optionen und einem anschließenden Merge.",
"",
"Das trifft sogar zu, wenn du völlig abgedrehte Optionen verwendest. Ein paar Beispiele:"
]
@ -661,7 +661,7 @@ exports.level = {
"",
"`git fetch origin bar~1:bugFix; git merge bugFix`",
"",
"Siehst du? `git pull` ist wirklich nur eine Abkürzung von `fetch` + `merge` und es interessiert sich nur dafür wo die Commits hin sollen (die \"Ziel\"-Option, die es beim `fetch` auswertet).",
"Siehst du? `git pull` ist wirklich nur eine Abkürzung von `fetch` + `merge` und es interessiert sich nur dafür, wo die Commits hin sollen (die \"Ziel\"-Option, die es beim `fetch` auswertet).",
"",
"Schauen wir uns eine Demonstration an:"
]
@ -671,12 +671,12 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Wenn wir den Ort, auf den das `fetch` ausgeführt werden soll, angeben, passiert alles so wie beim `git fetch` aber es wird direkt danach auch ein Merge ausgeführt."
"Wenn wir den Ort, auf den das `fetch` ausgeführt werden soll, angeben, passiert alles so wie beim `git fetch`, aber es wird direkt danach auch ein Merge ausgeführt."
],
"afterMarkdowns": [
"Siehst du? Da wir `master` angegeben haben sind die Commits in `o/master` heruntergeladen worden. Danach wurde `o/master` gemerged, egal was gerade ausgecheckt war."
"Siehst du? Da wir `main` angegeben haben, sind die Commits in `o/main` heruntergeladen worden. Danach wurde `o/main` gemerged, egal was gerade ausgecheckt war."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -687,9 +687,9 @@ exports.level = {
"Funktioniert das auch wenn man Quelle und Ziel angibt? Aber sicher! Das sehen wir hier:"
],
"afterMarkdowns": [
"Wow, das ist eine Menge in einem einzelnen Befehl. Wir haben lokal einen neuen Branch namens `foo` erstellt, die Commits vom `master` des Servers dorthin heruntergeladen und ihn danach in unseren aktuell ausgecheckten Commit `bar` gemerged."
"Wow, das ist eine Menge in einem einzelnen Befehl. Wir haben lokal einen neuen Branch namens `foo` erstellt, die Commits vom `main` des Servers dorthin heruntergeladen und ihn danach in unseren aktuell ausgecheckten Branch `bar` gemerged."
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -697,7 +697,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok, um's zu Ende zu bringen versuch das Ziel aus der Zielgrafik zu erreichen. Du wirst einige Commits herunterladen, einige neue Branches anlegen und diese in andere mergen müssen, aber das sollte nicht allzuviele Befehle benötigen. :P"
"Ok, um's zu Ende zu bringen versuch das Ziel aus der Zielgrafik zu erreichen. Du wirst einige Commits herunterladen, einige neue Branches anlegen und diese in andere mergen müssen, aber das sollte nicht allzu viele Befehle benötigen. :P"
]
}
}
@ -748,9 +748,9 @@ exports.level = {
"Здесь сначала выполнится fetch с аргументом указанным к pull, а merge выполняется с теми изменениями, которые будут скачаны командой fetch."
],
"afterMarkdowns": [
"Как видно, мы указали `master`, поэтому как обычно все обновления притянулись на ветку `o/master`. Затем мы слили (merge) обновленную ветку `o/master` с веткой, на которой мы находимся."
"Как видно, мы указали `main`, поэтому как обычно все обновления притянулись на ветку `o/main`. Затем мы слили (merge) обновленную ветку `o/main` с веткой, на которой мы находимся."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -761,9 +761,9 @@ exports.level = {
"Будет ли это работать, если указать `<источник>` и `<приемник>`? Проверим:"
],
"afterMarkdowns": [
"Ого, сколько всего выполнено всего одной командой!. Мы создали новую ветку `foo` в локальном репозитории, скачали на неё изменения с ветки `master` удаленного репозитория, а затем слили эту ветку с веткой `bar`, на которой мы находились!"
"Ого, сколько всего выполнено всего одной командой!. Мы создали новую ветку `foo` в локальном репозитории, скачали на неё изменения с ветки `main` удаленного репозитория, а затем слили эту ветку с веткой `bar`, на которой мы находились!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -822,9 +822,9 @@ exports.level = {
"place를 지정하면, 이전에 fecth를 하던때와 완전히 똑같이 진행되고 fetch한것을 병합합니다."
],
"afterMarkdowns": [
"보이죠! `master`를 지정해서 우리는 `o/master`에 평소처럼 커밋들을 내려받았습니다. 그다음 우리가 있는 곳으로 `o/master`를 병합했습니다 현재 체크아웃된 브랜치와 *상관없이* 말이죠"
"보이죠! `main`를 지정해서 우리는 `o/main`에 평소처럼 커밋들을 내려받았습니다. 그다음 우리가 있는 곳으로 `o/main`를 병합했습니다 현재 체크아웃된 브랜치와 *상관없이* 말이죠"
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -837,7 +837,7 @@ exports.level = {
"afterMarkdowns": [
"이야, 명령어 하나에 많은게 일어나고있습니다. 로컬에 이름이 `foo`인 새 브랜치를 만들고, 원격 저장소의 master에서 이 브랜치 `foo`에 커밋들을 내려받습니다, 그후 그 브랜치를 우리가 현재 체크아웃한 브랜치 `bar`로 병합했습니다. 오오오!!!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -896,9 +896,9 @@ exports.level = {
"Якщо ми вказуємо місце призначення для fetch, fetch виконується як звичайно, але мердж відбудеться з тим, що ми щойно стягнули"
],
"afterMarkdowns": [
"От бачиш, вказавши `master`, ми звантажили коміти в `o/master`, як завжди. Потім змерджили `o/master` в поточну гілку."
"От бачиш, вказавши `main`, ми звантажили коміти в `o/main`, як завжди. Потім змерджили `o/main` в поточну гілку."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -909,9 +909,9 @@ exports.level = {
"Чи це працює також при вказанні `source` і `destination`? І не сумнівайся! Ось приклад:"
],
"afterMarkdowns": [
"Ого, стільки роботи однією командою. Ми створили локальну гілку з назвою `foo`, звантажили в неї коміти з віддаленого master, а потім змерджили `foo` в поточну гілку `bar`!"
"Ого, стільки роботи однією командою. Ми створили локальну гілку з назвою `foo`, звантажили в неї коміти з віддаленого main, а потім змерджили `foo` в поточну гілку `bar`!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -970,9 +970,9 @@ exports.level = {
"Nếu ta chỉ định vị trí để nạp, mọi thứ diễn ra như với git fetch nhưng giờ đây có thêm một bước đó là ta hợp nhất những gì mà ta đã nạp"
],
"afterMarkdowns": [
"Thấy chứ! Bằng cách chỉ định nhánh `master` ta tải các commit xuống nhánh `o/master` như thường lệ. Sau đó hợp nhất nhánh `o/master` vào nhánh cục bộ mà ta đang đứng, nhánh mà *không phải* nhánh cục bộ `master`. Nhờ vậy mà ta có thể chạy cùng một lệnh git pull(với cùng tham số) nhiều lần ở những vị trí khác nhau để áp dụng cùng cập nhật lên các nhánh khác nhau."
"Thấy chứ! Bằng cách chỉ định nhánh `main` ta tải các commit xuống nhánh `o/main` như thường lệ. Sau đó hợp nhất nhánh `o/main` vào nhánh cục bộ mà ta đang đứng, nhánh mà *không phải* nhánh cục bộ `main`. Nhờ vậy mà ta có thể chạy cùng một lệnh git pull(với cùng tham số) nhiều lần ở những vị trí khác nhau để áp dụng cùng cập nhật lên các nhánh khác nhau."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -983,9 +983,9 @@ exports.level = {
"Điều này có hoạt động với đích và nguồn không? Đoán đúng rồi đấy! Cùng xem thử nào:"
],
"afterMarkdowns": [
"Wao, quá NHIỀU trong một câu lệnh. Ta tạo ra một nhánh cục bộ là `foo`, tải commit xuống từ nhánh từ xa master xuống nhánh `foo` đó, và sau đó hợp nhất commit vào nhánh `bar` mà ta đang đứng. Đủ thứ luôn!!!"
"Wao, quá NHIỀU trong một câu lệnh. Ta tạo ra một nhánh cục bộ là `foo`, tải commit xuống từ nhánh từ xa main xuống nhánh `foo` đó, và sau đó hợp nhất commit vào nhánh `bar` mà ta đang đứng. Đủ thứ luôn!!!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},
@ -1044,9 +1044,9 @@ exports.level = {
"Če določimo mesto za fetchanje, se zgodi vse kot prej s fetchem, ampak tudi zmergamo, kar smo pravkar fetchali."
],
"afterMarkdowns": [
"Vidiš! Z določitvijo `master` smo prenesli commite na `o/master` kot ponavadi. Potem smo zmergali `o/master` v našo trenutno checkoutano lokacijo, ki *ni* lokalni branch `master`. Zaradi tega razloga je morda celo logično, da izvedemo git pull večkrat (z istimi argumenti) iz drugi lokacij, da posodobimo več branchev."
"Vidiš! Z določitvijo `main` smo prenesli commite na `o/main` kot ponavadi. Potem smo zmergali `o/main` v našo trenutno checkoutano lokacijo, ki *ni* lokalni branch `main`. Zaradi tega razloga je morda celo logično, da izvedemo git pull večkrat (z istimi argumenti) iz drugi lokacij, da posodobimo več branchev."
],
"command": "git pull origin master",
"command": "git pull origin main",
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
}
},
@ -1059,7 +1059,7 @@ exports.level = {
"afterMarkdowns": [
"Wow, to je pa RES veliko v enem ukazu. Naredili smo nov lokalen branch imenovan `foo`, prenesli commite iz oddaljenega masterja na ta branch `foo` in potem zmergali ta branch v naš trenutno checkoutan branch `bar`. Je več kot 9000!!!"
],
"command": "git pull origin master:foo",
"command": "git pull origin main:foo",
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
}
},

30
src/levels/remote/push.js
View file

@ -66,7 +66,7 @@ exports.level = {
"Here we have some changes that the remote does not have. Let's upload them!"
],
"afterMarkdowns": [
"There we go -- the remote received commit `C2`, the branch `master` on the remote was updated to point at `C2`, and our *own* reflection of the remote (`o/master`) was updated as well. Everything is in sync!"
"There we go -- the remote received commit `C2`, the branch `main` on the remote was updated to point at `C2`, and our *own* reflection of the remote (`o/main`) was updated as well. Everything is in sync!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -109,7 +109,7 @@ exports.level = {
"Nous avons fait ici quelques changements que le dépôt distant n'a pas. Envoyons-les !"
],
"afterMarkdowns": [
"Et voilà : le dépôt distant a reçu le commit `C2`, la branche `master` a été mise à jour sur `C2`, et votre *propre* représentation de la branche distante (`o/master`) a aussi été mise à jour. Tout est synchronisé !"
"Et voilà : le dépôt distant a reçu le commit `C2`, la branche `main` a été mise à jour sur `C2`, et votre *propre* représentation de la branche distante (`o/main`) a aussi été mise à jour. Tout est synchronisé !"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -150,7 +150,7 @@ exports.level = {
"Acá tenemos algunos cambios que nuestro remoto no tiene. ¡Subámoslos!"
],
"afterMarkdowns": [
"Ahí está: el remoto recibió el commit `C2`, la rama `master` de ese remoto se actualizó para apuntar a `C2`, y nuestro *propio* reflejo del remoto (`o/master`) también fue actualizado. ¡Todo está en sincronía!"
"Ahí está: el remoto recibió el commit `C2`, la rama `main` de ese remoto se actualizó para apuntar a `C2`, y nuestro *propio* reflejo del remoto (`o/main`) también fue actualizado. ¡Todo está en sincronía!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -191,7 +191,7 @@ exports.level = {
"Aquí tenemos algunos cambios que nuestro remoto no tiene. ¡Subámoslos!"
],
"afterMarkdowns": [
"Ahí está: el remoto recibió el commit `C2`, la rama `master` de ese remoto se actualizó para apuntar a `C2`, y nuestro *propio* reflejo del remoto (`o/master`) también fue actualizado. ¡Todo está en sincronía!"
"Ahí está: el remoto recibió el commit `C2`, la rama `main` de ese remoto se actualizó para apuntar a `C2`, y nuestro *propio* reflejo del remoto (`o/main`) también fue actualizado. ¡Todo está en sincronía!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -234,7 +234,7 @@ exports.level = {
"Aqui temos algumas mudanças que o repositório remoto não contém. Vamos subi-las!"
],
"afterMarkdowns": [
"Aqui vamos nós -- o repositório remoto recebeu o commit `C2`, o ramo `master` no repositório remoto foi atualizado para apontar para `C2`, e a *nossa* reflexão do remoto (`o/master`) foi atualizada também. Está tudo sincronizado!"
"Aqui vamos nós -- o repositório remoto recebeu o commit `C2`, o ramo `main` no repositório remoto foi atualizado para apontar para `C2`, e a *nossa* reflexão do remoto (`o/main`) foi atualizada também. Está tudo sincronizado!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -277,7 +277,7 @@ exports.level = {
"Aquí temos algúns cambios que o repositorio remoto non contén. ¡Imos subilas!"
],
"afterMarkdowns": [
"Ahí imos -- o repositorio remoto recibiu o commit `C2`, a rama `master` do repositorio remoto foi actualizado para apuntar para `C2`, e o *noso* reflexo do remoto (`o/master`) foi atualizado tamén. ¡Está todo sincronizado!"
"Ahí imos -- o repositorio remoto recibiu o commit `C2`, a rama `main` do repositorio remoto foi actualizado para apuntar para `C2`, e o *noso* reflexo do remoto (`o/main`) foi atualizado tamén. ¡Está todo sincronizado!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -318,7 +318,7 @@ exports.level = {
"這裡我們有了一些 remote 所沒有的 commit。讓我們來上傳它們吧！"
],
"afterMarkdowns": [
"我說的沒錯吧！remote 收到了 commit `C2`，同時在 remote 上的 `master` branch 也一起更新並且指向 `C2`，同時我們*自己的* `o/master` 也一併更新了！"
"我說的沒錯吧！remote 收到了 commit `C2`，同時在 remote 上的 `main` branch 也一起更新並且指向 `C2`，同時我們*自己的* `o/main` 也一併更新了！"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -362,7 +362,7 @@ exports.level = {
"这里我们准备了一些远程仓库中没有的提交记录, 咱们开始先上传吧!"
],
"afterMarkdowns": [
"过去了, 远程仓库接收了 `C2`，远程仓库中的 `master` 分支也被更新到指向 `C2` 了，我们的远程分支 (o/master) 也同样被更新了。所有的分支都同步了！"
"过去了, 远程仓库接收了 `C2`，远程仓库中的 `main` 分支也被更新到指向 `C2` 了，我们的远程分支 (o/main) 也同样被更新了。所有的分支都同步了！"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -403,7 +403,7 @@ exports.level = {
"Hier haben wir ein paar Änderungen, die auf dem Remote noch fehlen. Und hoch damit!"
],
"afterMarkdowns": [
"Na bitte -- das Remote hat den Commit `C2` bekommen, der `master` auf dem Remote ist entsprechend aktualisiert worden und unsere *eigene* Abbildung des `master` auf dem Remote namens `o/master` wurde auch aktualisiert. Alles im Lot!"
"Na bitte -- das Remote hat den Commit `C2` bekommen, der `main` auf dem Remote ist entsprechend aktualisiert worden und unsere *eigene* Abbildung des `main` auf dem Remote namens `o/main` wurde auch aktualisiert. Alles im Lot!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -446,7 +446,7 @@ exports.level = {
"Здесь у нас имеются изменения, которых нет в удалённом репозитории. Давайте же закачаем их туда!"
],
"afterMarkdowns": [
"Вот так - удалённый репозиторий получил новый коммит `C2`, ветка `master` на удалённом репозитории теперь указывает на `C2`, и наше *собственное* локальное отображение удалённого репозитория (`o/master`) изменилось соответственно. Всё синхронизировалось!"
"Вот так - удалённый репозиторий получил новый коммит `C2`, ветка `main` на удалённом репозитории теперь указывает на `C2`, и наше *собственное* локальное отображение удалённого репозитория (`o/main`) изменилось соответственно. Всё синхронизировалось!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -489,7 +489,7 @@ exports.level = {
"ここにリモートにはないいくつかの変更点があります。これをアップロードしてみましょう！"
],
"afterMarkdowns": [
"さて、いってみましょう -- リモートはコミット`C2`を受け取り、リモート上の`master`ブランチは`C2`の位置に更新され、私たち*自身*のリモートブランチ(`o/master`)も良い具合に更新されました。全てが同期されました！"
"さて、いってみましょう -- リモートはコミット`C2`を受け取り、リモート上の`main`ブランチは`C2`の位置に更新され、私たち*自身*のリモートブランチ(`o/main`)も良い具合に更新されました。全てが同期されました！"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -532,7 +532,7 @@ exports.level = {
"Ось ми маємо деякі зміни яких нема в віддаленому сховищі. Надішлімо їх!"
],
"afterMarkdowns": [
"Ось, маєш -- віддалене сховище отримало `C2`, гілку `master` на ньому було оновлено й тепер вона посилається на `C2`, а наше *власне* відображення віддаленого репо (`o/master`) було також оновлено. Все синхронізовано!"
"Ось, маєш -- віддалене сховище отримало `C2`, гілку `main` на ньому було оновлено й тепер вона посилається на `C2`, а наше *власне* відображення віддаленого репо (`o/main`) було також оновлено. Все синхронізовано!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -575,7 +575,7 @@ exports.level = {
"여기 원격저장소에는 없는 변경이 있습니다. 이것들을 업로드 해 봅시다!"
],
"afterMarkdowns": [
"자 됬습니다 -- 원격 저장소가 커밋 `C2`를 받았고, 원격 저장소의 브랜치 `master`가 `C2`라는 지점까지 갱신 되었습니다. 그리고 원격 저장소의 반영인 *우리의* 원격 브랜치 (`o/master`)또한 잘 갱신 되었습니다. 모든게 동기화되어 있습니다!"
"자 됬습니다 -- 원격 저장소가 커밋 `C2`를 받았고, 원격 저장소의 브랜치 `main`가 `C2`라는 지점까지 갱신 되었습니다. 그리고 원격 저장소의 반영인 *우리의* 원격 브랜치 (`o/main`)또한 잘 갱신 되었습니다. 모든게 동기화되어 있습니다!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -618,7 +618,7 @@ exports.level = {
"Ở đây ta có một vài thay đổi mà kho chứa từ xa không có. Hãy tải chúng lên!"
],
"afterMarkdowns": [
"Đó -- kho chứa từ xa đã nhận được commit `C2`, nhánh `master` ở kho chứa từ xa đã được cập nhật lên `C2`, và phản chiếu nhánh từ xa *của ta* (`o/master`) cũng được cập nhật luôn. Mọi thứ đã đồng bộ!"
"Đó -- kho chứa từ xa đã nhận được commit `C2`, nhánh `main` ở kho chứa từ xa đã được cập nhật lên `C2`, và phản chiếu nhánh từ xa *của ta* (`o/main`) cũng được cập nhật luôn. Mọi thứ đã đồng bộ!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"
@ -661,7 +661,7 @@ exports.level = {
"Tu imamo nekaj sprememb, ki jih oddaljen repo nima. Dajmo jih naložiti!"
],
"afterMarkdowns": [
"Tako je -- oddaljen repo je prejel commit `C2`, branch `master` na oddaljenem repotu je bil posodobljen, da kaže na `C2` in naš *lasten* prikaz oddaljenega repota (`o/master`) je bil prav tako posodobljen. Vse je usklajeno!"
"Tako je -- oddaljen repo je prejel commit `C2`, branch `main` na oddaljenem repotu je bil posodobljen, da kaže na `C2` in naš *lasten* prikaz oddaljenega repota (`o/main`) je bil prav tako posodobljen. Vse je usklajeno!"
],
"command": "git push",
"beforeCommand": "git clone; git commit"

176
src/levels/remote/pushArgs.js
View file

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"foo\":{\"target\":\"C3\",\"id\":\"foo\",\"remoteTrackingBranchID\":\"o/foo\"},\"o/master\":{\"target\":\"C2\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"o/foo\":{\"target\":\"C3\",\"id\":\"o/foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"}},\"HEAD\":{\"target\":\"C0\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"foo\":{\"target\":\"C3\",\"id\":\"foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"solutionCommand": "git push origin master;git push origin foo",
"solutionCommand": "git push origin main;git push origin foo",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"foo\":{\"target\":\"C3\",\"id\":\"foo\",\"remoteTrackingBranchID\":\"o/foo\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"o/foo\":{\"target\":\"C1\",\"id\":\"o/foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"}},\"HEAD\":{\"target\":\"C0\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"foo\":{\"target\":\"C1\",\"id\":\"foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"disabledMap": {
"git checkout": true
@ -64,13 +64,13 @@ exports.level = {
"markdowns": [
"What is a `<place>` parameter you say? We'll dive into the specifics soon, but first an example. Issuing the command:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"translates to this in English:",
"",
"*Go to the branch named \"master\" in my repository, grab all the commits, and then go to the branch \"master\" on the remote named \"origin\". Place whatever commits are missing on that branch and then tell me when you're done.*",
"*Go to the branch named \"main\" in my repository, grab all the commits, and then go to the branch \"main\" on the remote named \"origin\". Place whatever commits are missing on that branch and then tell me when you're done.*",
"",
"By specifying `master` as the \"place\" argument, we told git where the commits will *come from* and where the commits *will go*. It's essentially the \"place\" or \"location\" to synchronize between the two repositories.",
"By specifying `main` as the \"place\" argument, we told git where the commits will *come from* and where the commits *will go*. It's essentially the \"place\" or \"location\" to synchronize between the two repositories.",
"",
"Keep in mind that since we told git everything it needs to know (by specifying both arguments), it totally ignores where we are checked out!"
]
@ -83,9 +83,9 @@ exports.level = {
"Let's see an example of specifying the arguments. Note the location where we are checked out in this example."
],
"afterMarkdowns": [
"There we go! `master` got updated on the remote since we specified those arguments."
"There we go! `main` got updated on the remote since we specified those arguments."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -106,7 +106,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok, for this level let's update both `foo` and `master` on the remote. The twist is that `git checkout` is disabled for this level!",
"Ok, for this level let's update both `foo` and `main` on the remote. The twist is that `git checkout` is disabled for this level!",
"",
"*Note: The remote branches are labeled with `o/` prefixes because the full `origin/` label does not fit in our UI. Don't worry ",
"about this... simply use `origin` as the name of the remote like normal.*"
@ -139,13 +139,13 @@ exports.level = {
"markdowns": [
"Qu'est ce que ce paramètre `<place>` ? Avant de passer à l'explication, voyons d'abord un exemple. La commande suivante :",
"",
"`git push origin master`",
"`git push origin main`",
"",
"peut se traduire en français par :",
"",
"*Va dans la branche \"master\" de mon dépôt, récupère tous les commits, et ensuite va dans la branche distante \"master\" sur le dépôt nommé \"origin\". Envoie tous les commits qui lui manquent sur cette branche distante puis préviens-moi quand c'est terminé.*",
"*Va dans la branche \"main\" de mon dépôt, récupère tous les commits, et ensuite va dans la branche distante \"main\" sur le dépôt nommé \"origin\". Envoie tous les commits qui lui manquent sur cette branche distante puis préviens-moi quand c'est terminé.*",
"",
"En spécifiant `master` comme argument `<place>`, nous avons dit à git *d'où* les commits venaient et où ils *allaient*. C'est en fait \"l'emplacement\" à synchroniser entre les deux dépôts.",
"En spécifiant `main` comme argument `<place>`, nous avons dit à git *d'où* les commits venaient et où ils *allaient*. C'est en fait \"l'emplacement\" à synchroniser entre les deux dépôts.",
"",
"Gardez à l'esprit que nous avons dit à git tout ce dont il a besoin pour opérer (en précisant les deux arguments), il n'a donc absolument pas besoin de savoir quelle est la branche courante !"
]
@ -158,9 +158,9 @@ exports.level = {
"Voyons un exemple d'arguments. Notez bien où se trouve `HEAD` dans cet exemple."
],
"afterMarkdowns": [
"Voilà ! `master` a été mise à jour puisque nous avons spécifié ces arguments."
"Voilà ! `main` a été mise à jour puisque nous avons spécifié ces arguments."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -181,7 +181,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok, pour ce niveau mettez à jour `foo` et `master` sur le dépôt distant. La difficulté est que `git checkout` est désactivée pour ce niveau !"
"Ok, pour ce niveau mettez à jour `foo` et `main` sur le dépôt distant. La difficulté est que `git checkout` est désactivée pour ce niveau !"
]
}
}
@ -211,13 +211,13 @@ exports.level = {
"markdowns": [
"¿Qué será este parámetro `<lugar>`, te preguntarás? Ya vamos a entrar en detalle, pero primero un ejemplo. Correr el comando:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"se traduce así al español:",
"",
"*Andá a la rama llamada \"master\" en mi repositorio, agarrá todos los commits, y después andá a la rama \"master\" del remoto llamado \"origin\". Aplicá ahí todos los commits que falten, y avisame cuando termines.*",
"*Andá a la rama llamada \"main\" en mi repositorio, agarrá todos los commits, y después andá a la rama \"main\" del remoto llamado \"origin\". Aplicá ahí todos los commits que falten, y avisame cuando termines.*",
"",
"Especificando `master` como el parámetro \"lugar\", le dijimos a git de dónde traer los commits, y a dónde mandarlos. Es, básicamente, el \"lugar\" o \"ubicación\" que sincronizar entre ambos repositorios.",
"Especificando `main` como el parámetro \"lugar\", le dijimos a git de dónde traer los commits, y a dónde mandarlos. Es, básicamente, el \"lugar\" o \"ubicación\" que sincronizar entre ambos repositorios.",
"",
"Tené en cuenta que, como le dijimos a git todo lo que necesitaba saber (especificando ambos parámetros), ¡ignora totalmente dónde estamos parados en este momento¡"
]
@ -230,9 +230,9 @@ exports.level = {
"Veamos un ejemplo especificando los parámetros. Notá en dónde estamos parados en este ejemplo."
],
"afterMarkdowns": [
"¡Ahí está! Se actualizó `master` en el remoto, porque especificamos esos parámetros."
"¡Ahí está! Se actualizó `main` en el remoto, porque especificamos esos parámetros."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -253,7 +253,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok. Para este nivel, actualicemos tanto `foo` como `master` en el remoto. El tema está en que ¡tenemos deshabilitado `git checkout` en este nivel!"
"Ok. Para este nivel, actualicemos tanto `foo` como `main` en el remoto. El tema está en que ¡tenemos deshabilitado `git checkout` en este nivel!"
]
}
}
@ -283,13 +283,13 @@ exports.level = {
"markdowns": [
"¿Qué será este parámetro `<lugar>`, te preguntarás? Vamos a entrar en detalle, pero primero un ejemplo. Ejecutar el comando:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"se traduce así al español:",
"",
"*Vete a la rama llamada \"master\" en mi repositorio, coge todos los commits, y después vete a la rama \"master\" del remoto llamado \"origin\". Copia ahí todos los commits que falten, y avísame cuando termines.*",
"*Vete a la rama llamada \"main\" en mi repositorio, coge todos los commits, y después vete a la rama \"main\" del remoto llamado \"origin\". Copia ahí todos los commits que falten, y avísame cuando termines.*",
"",
"Especificando `master` como el parámetro \"lugar\", le dijimos a git de dónde traer los commits, y a dónde mandarlos. Es, básicamente, el \"lugar\" o \"ubicación\" que sincronizar entre ambos repositorios.",
"Especificando `main` como el parámetro \"lugar\", le dijimos a git de dónde traer los commits, y a dónde mandarlos. Es, básicamente, el \"lugar\" o \"ubicación\" que sincronizar entre ambos repositorios.",
"",
"Ten en cuenta que, como le dijimos a git todo lo que necesitaba saber (especificando ambos parámetros), ¡ignora totalmente dónde estamos parados en este momento¡"
]
@ -302,9 +302,9 @@ exports.level = {
"Veamos un ejemplo especificando los parámetros. Date cuenta dónde estamos parados en este ejemplo."
],
"afterMarkdowns": [
"¡Ahí está! Se actualizó `master` en el remoto, porque especificamos esos parámetros."
"¡Ahí está! Se actualizó `main` en el remoto, porque especificamos esos parámetros."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -325,7 +325,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Perfecto. Para este nivel, actualicemos tanto `foo` como `master` en el remoto. El tema está en que ¡tenemos deshabilitado `git checkout` en este nivel!"
"Perfecto. Para este nivel, actualicemos tanto `foo` como `main` en el remoto. El tema está en que ¡tenemos deshabilitado `git checkout` en este nivel!"
]
}
}
@ -355,13 +355,13 @@ exports.level = {
"markdowns": [
"Você deve estar se perguntando: o que é esse parâmetro `<lugar>`? Vamos discutir as especifidades em breve, mas vejamos primeiro um exemplo. Executar o comando:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"pode ser traduzido para o seguinte em Português:",
"",
"*Vá ao ramo chamado \"master\" no meu repositório local, pegue todos os commits, então vá ao ramo \"master\" no repositório remoto chamado \"origin\". Coloque quaisquer commits que estiverem faltando nesse ramo, e então me diga quando estiver pronto.*",
"*Vá ao ramo chamado \"main\" no meu repositório local, pegue todos os commits, então vá ao ramo \"main\" no repositório remoto chamado \"origin\". Coloque quaisquer commits que estiverem faltando nesse ramo, e então me diga quando estiver pronto.*",
"",
"Especificando `master` como parâmetro \"lugar\", dizemos ao Git de onde os commits *vão vir* e para onde os commits *irão*. É essencialmente o \"lugar\" onde sincronizar entre os dois repositórios.",
"Especificando `main` como parâmetro \"lugar\", dizemos ao Git de onde os commits *vão vir* e para onde os commits *irão*. É essencialmente o \"lugar\" onde sincronizar entre os dois repositórios.",
"",
"Tenha em mente que já que contamos ao Git tudo que ele precisa saber (especificando ambos os parâmetros), ele ignora totalmente o checkout atual!"
]
@ -374,9 +374,9 @@ exports.level = {
"Vejamos um exemplo especificando os argumentos. Preste atenção no commit que sofreu checkout neste exemplo."
],
"afterMarkdowns": [
"Aqui vamos nós! O `master` foi atualizado no repositório remoto, já que especificamos os parâmetros."
"Aqui vamos nós! O `main` foi atualizado no repositório remoto, já que especificamos os parâmetros."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -397,7 +397,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok, neste nível vamos atualizar tanto o `foo` como o `master` no repositório remoto. Porém desabilitamos o comando `git checkout` para dificultar um pouco a tarefa!"
"Ok, neste nível vamos atualizar tanto o `foo` como o `main` no repositório remoto. Porém desabilitamos o comando `git checkout` para dificultar um pouco a tarefa!"
]
}
}
@ -427,13 +427,13 @@ exports.level = {
"markdowns": [
"¿Qué será este parámetro `<lugar>`, fixécheste esa pregunta? Xa imos entrar en detalle, pero primeiro un exemplo. Executa o comando:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"tradúcese así ó galego:",
"",
"*Vai á rama chamada \"master\" no meu repositorio, colle tódolos commits, e despois vai á rama \"master\" do remoto chamado \"origin\". Aplica ahí tódolos commits que falten, e avísame cando remates.*",
"*Vai á rama chamada \"main\" no meu repositorio, colle tódolos commits, e despois vai á rama \"main\" do remoto chamado \"origin\". Aplica ahí tódolos commits que falten, e avísame cando remates.*",
"",
"Indicando `master` como o parámetro \"lugar\", dixémoslle a git ónde traer os commits, e ónde mandalos. É básicamente, o \"lugar\" ou \"ubicación\" que sincroniza entre ámbolos dous repositorios.",
"Indicando `main` como o parámetro \"lugar\", dixémoslle a git ónde traer os commits, e ónde mandalos. É básicamente, o \"lugar\" ou \"ubicación\" que sincroniza entre ámbolos dous repositorios.",
"",
"Ten en conta que, como lle dixemos a git todo o que precisaba saber (indicando ambos parámetros), ¡ignora totalmente ónde andabamos neste momento!"
]
@ -446,9 +446,9 @@ exports.level = {
"Vexamos un exemplo especificando os parámetros. Nota ónde ficamos parados neste exemplo."
],
"afterMarkdowns": [
"¡Ahí o tes! Actualizouse `master` no remoto, porque especificamos eses parámetros."
"¡Ahí o tes! Actualizouse `main` no remoto, porque especificamos eses parámetros."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -469,7 +469,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok. Para este nivel, actualiza tanto `foo` como `master` no remoto. O tema está en que ¡temos deshabilitado `git checkout` neste nivel!"
"Ok. Para este nivel, actualiza tanto `foo` como `main` no remoto. O tema está en que ¡temos deshabilitado `git checkout` neste nivel!"
]
}
}
@ -499,13 +499,13 @@ exports.level = {
"markdowns": [
"`<place>` 這個參數表示什麼? 我們等一下會提到細節，但是先來看一個例子，執行以下的指令：",
"",
"`git push origin master`",
"`git push origin main`",
"",
"將這段解釋成中文：",
"",
"*先到我的 repo 中的 \"master\" branch，抓下所有的 commit，然後到叫作 \"origin\" 的 remote 的 \"master\" branch，檢查 remote 的 commit 有沒有跟我的 repo 一致，如果沒有，就更新。*",
"*先到我的 repo 中的 \"main\" branch，抓下所有的 commit，然後到叫作 \"origin\" 的 remote 的 \"main\" branch，檢查 remote 的 commit 有沒有跟我的 repo 一致，如果沒有，就更新。*",
"",
"將 `master` 當作 \"place\" 這個參數，我們告訴 git 這些 commit 是*從哪裡來的*，而且它們要*往哪裡去*。對於要同步兩個 repo， \"place\" 或者是 \"location\" 是非常重要的。",
"將 `main` 當作 \"place\" 這個參數，我們告訴 git 這些 commit 是*從哪裡來的*，而且它們要*往哪裡去*。對於要同步兩個 repo， \"place\" 或者是 \"location\" 是非常重要的。",
"",
"要記住喔，因為我們告訴 git 它所要知道的（有兩個參數），因此它才不會管你現在所 checkout 的 branch！"
]
@ -518,9 +518,9 @@ exports.level = {
"讓我們來看一個有加上參數的例子，在這個例子中，要特別注意到我們所 checkout 的位置。"
],
"afterMarkdowns": [
"我說的沒錯吧！因為我們加上了參數，所以在 remote 上的 `master` branch 更新了。"
"我說的沒錯吧！因為我們加上了參數，所以在 remote 上的 `main` branch 更新了。"
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -541,7 +541,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"好的，在這個關卡中，我們要更新在 remote 上的 `foo` 以及 `master` branch，比較遺憾的是 `git checkout` 在這個關卡中是不被允許的喔！"
"好的，在這個關卡中，我們要更新在 remote 上的 `foo` 以及 `main` branch，比較遺憾的是 `git checkout` 在這個關卡中是不被允許的喔！"
]
}
}
@ -571,13 +571,13 @@ exports.level = {
"markdowns": [
"`<place>` 参数是什么意思呢？我们稍后会深入其中的细节, 先看看例子, 这个命令是:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"把这个命令翻译过来就是：",
"",
"*切到本地仓库中的“master”分支，获取所有的提交，再到远程仓库“origin”中找到“master”分支，将远程仓库中没有的提交记录都添加上去，搞定之后告诉我。*",
"*切到本地仓库中的“main”分支，获取所有的提交，再到远程仓库“origin”中找到“main”分支，将远程仓库中没有的提交记录都添加上去，搞定之后告诉我。*",
"",
"我们通过“place”参数来告诉 Git 提交记录来自于 master, 要推送到远程仓库中的 master。它实际就是要同步的两个仓库的位置。",
"我们通过“place”参数来告诉 Git 提交记录来自于 main, 要推送到远程仓库中的 main。它实际就是要同步的两个仓库的位置。",
"",
"需要注意的是，因为我们通过指定参数告诉了 Git 所有它需要的信息, 所以它就忽略了我们所检出的分支的属性！"
]
@ -590,9 +590,9 @@ exports.level = {
"我们看看指定参数的例子。注意下我们当前检出的位置。"
],
"afterMarkdowns": [
"好了! 通过指定参数, 远程仓库中的 `master` 分支得到了更新。"
"好了! 通过指定参数, 远程仓库中的 `main` 分支得到了更新。"
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -613,7 +613,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"本关我们要更新远程仓库中的 `foo` 和 `master`, 但是 `git checkout` 被禁用了！",
"本关我们要更新远程仓库中的 `foo` 和 `main`, 但是 `git checkout` 被禁用了！",
"",
"*注意：远程分支使用 `o/` 开头是因为 `origin/` 对于 UI 来说太长了。不用太在意这个，直接用 `origin` 作为远程仓库的名称就可以了。*",
""
@ -630,7 +630,7 @@ exports.level = {
"markdowns": [
"## Push-Optionen",
"",
"Großartig! Da du dich jetzt mit Remote Tracking Branches auskennst können wir anfangen, die Geheimnisse hinter `git push`, `fetch` und `pull` zu ergründen. Wir werden uns einen Befehl nach dem anderen vornehmen, aber die Funktionsweisen sind sich sehr ähnlich.",
"Großartig! Da du dich jetzt mit Remote Tracking Branches auskennst, können wir anfangen, die Geheimnisse hinter `git push`, `fetch` und `pull` zu ergründen. Wir werden uns einen Befehl nach dem anderen vornehmen, aber die Funktionsweisen sind sich sehr ähnlich.",
"",
"Zunächst schauen wir uns `git push` an. Du hast im Level über Remote Tracking schon mitbekommen, dass Git den Remote Server *und* den Branch herausbekommt, indem es sich die Eigenschaften des aktuell ausgecheckten Branches ansieht (in denen das Remote steht, das der Branch \"trackt\"). Das ist das Verhalten bei keiner Angabe weiterer Optionen -- du kannst bei `git push` aber auch folgende setzen:",
"",
@ -644,17 +644,17 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Was \"Ort\" sein soll fragst du? Das klären wir später genau, schauen wir uns zunächst ein Beispiel an:",
"Was \"Ort\" sein soll, fragst du? Das klären wir später genau, schauen wir uns zunächst ein Beispiel an:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"Das bedeutet im Klartext:",
"",
"\"Geh zum Branch namens `master` in meinem Repository, nimm all seine Commits, dann geh zum Branch `master` auf dem Remote namens `origin`. Leg da alles Commits ab die fehlen und sag mir wenn du fertig bist.\"",
"\"Geh zum Branch namens `main` in meinem Repository, nimm all seine Commits, dann geh zum Branch `main` auf dem Remote namens `origin`. Lege da alle Commits ab, die fehlen und sage mir, wenn du fertig bist.\"",
"",
"Dadurch, dass wir `master` als \"Ort\" angegeben haben, weiß Git *woher* die Commits kommen und *wohin* sie sollen. Es ist im Grunde der Name der Orte, die zwischen zwei Repositorys synchronisiert werden soll.",
"Da wir `main` als \"Ort\" angegeben haben, weiß Git, *woher* die Commits kommen und *wohin* sie sollen. Es ist im Grunde der Name der Orte, die zwischen zwei Repositorys synchronisiert werden sollen.",
"",
"Dadurch, dass wir Git alles explizit gesagt haben, was es für die Operation wissen muss (durch Angabe von Remote und Ort) ist es vollkommen egal, was gerade ausgecheckt ist."
"Da wir Git alles explizit gesagt haben, was es für die Operation wissen muss (durch Angabe von Remote und Ort), ist es vollkommen egal, was gerade ausgecheckt ist."
]
}
},
@ -662,12 +662,12 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Schauen wir uns noch ein Beispiel an. Beachte was in diesem Fall gerade ausgecheckt ist."
"Schauen wir uns noch ein Beispiel an. Beachte, was in diesem Fall gerade ausgecheckt ist."
],
"afterMarkdowns": [
"Da haben wir's! `master` wurde auf dem Remote aktualisiert, weil wir beide Optionen angegeben haben."
"Da haben wir's! `main` wurde auf dem Remote aktualisiert, weil wir beide Optionen angegeben haben."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -688,7 +688,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok, in diesem Level lass uns sowohl `foo` als auch `master` auf dem Remote aktualisieren. Um's spannender zu machen, ist `git checkout` in diesem Level deaktiviert."
"Ok, in diesem Level lass uns sowohl `foo` als auch `main` auf dem Remote aktualisieren. Um's spannender zu machen ist `git checkout` in diesem Level deaktiviert."
]
}
}
@ -718,13 +718,13 @@ exports.level = {
"markdowns": [
"Что за такой параметр `<целевая_ветка>`? Мы узнаем об этом через секунду, а пока что рассмотрим пример. Допустим, что мы выполняем такую команду:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"дословный перевод с английского будет таким:",
"",
"*Перейди в ветку с именем \"master\" в моём локальном репозитории, возьми все коммиты и затем перейди на ветку \"master\" на удалённом репозитории \"origin.\". На эту удалённую ветку скопируй все отсутствующие коммиты, которые есть у меня, и скажи, когда ты закончишь.*",
"*Перейди в ветку с именем \"main\" в моём локальном репозитории, возьми все коммиты и затем перейди на ветку \"main\" на удалённом репозитории \"origin.\". На эту удалённую ветку скопируй все отсутствующие коммиты, которые есть у меня, и скажи, когда ты закончишь.*",
"",
"Указывая `master` в качестве аргумента \"целевая_ветка\", мы тем самым говорим git-у откуда будут *приходить* и *уходить* наши коммиты. Аргумент \"целевая_ветка\" или \"местонахождение\" - это синхронизация между двумя репозиториями.",
"Указывая `main` в качестве аргумента \"целевая_ветка\", мы тем самым говорим git-у откуда будут *приходить* и *уходить* наши коммиты. Аргумент \"целевая_ветка\" или \"местонахождение\" - это синхронизация между двумя репозиториями.",
"",
"Имейте в виду, что с тех пор, как мы сказали git-у всё, что ему необходимо (указав оба аргумента), ему - git-у - абсолютно всё равно, что вы зачекаутили до этого!"
]
@ -737,9 +737,9 @@ exports.level = {
"Давайте взглянем на пример, в котором указаны оба этих аргумента. Обратите внимание на местоположение, в котором мы находимся после чекаута."
],
"afterMarkdowns": [
"Вот так! Мы обновили `master` на удалённом репозитории, принудительно указав аргументы в push."
"Вот так! Мы обновили `main` на удалённом репозитории, принудительно указав аргументы в push."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -760,7 +760,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Хорошо, для выполнения этого уровня давайте обновим обе ветки `foo` и `master` на удалённом репозитории. Фишка в том, что команда `git checkout` не доступна на этом уровне!",
"Хорошо, для выполнения этого уровня давайте обновим обе ветки `foo` и `main` на удалённом репозитории. Фишка в том, что команда `git checkout` не доступна на этом уровне!",
"",
"*Замечание: Удалённые ветки помечены как `o/`, а не `origin/`. Дело в том, что полная метка не помещается на экране. Не волнуйтесь ",
"по этому поводу... просто используйте знакомый нам `origin` для обращения к удалённому репозиторию.*"
@ -793,13 +793,13 @@ exports.level = {
"markdowns": [
"`<place>`인자가 무엇을 의미할것 같나요? 세부사항은 알아보기 전에 예시부터 봅시다. 다음 명령어를 보세요:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"해석해 보면:",
"",
"*내 저장소에 있는 \"master\"라는 이름의 브랜치로 가서 모든 커밋들을 수집합니다, 그다음 \"origin\"의 \"master\"브랜치로 가서 이 브랜치에 부족한 커밋들을 채워 넣고 완료 되면 알려줍니다.*",
"*내 저장소에 있는 \"main\"라는 이름의 브랜치로 가서 모든 커밋들을 수집합니다, 그다음 \"origin\"의 \"main\"브랜치로 가서 이 브랜치에 부족한 커밋들을 채워 넣고 완료 되면 알려줍니다.*",
"",
"`master`를 \"place\"인자로 지정해서 우리가 git에게 *어디서부터* 커밋이 오는지, 그리고 *어디로* 커밋이 가야하는지 알려줍니다. 두 저장소간에 동기화 작업을 할 \"장소\"를 지정해 주는것이라고 볼 수 있습니다.",
"`main`를 \"place\"인자로 지정해서 우리가 git에게 *어디서부터* 커밋이 오는지, 그리고 *어디로* 커밋이 가야하는지 알려줍니다. 두 저장소간에 동기화 작업을 할 \"장소\"를 지정해 주는것이라고 볼 수 있습니다.",
"",
"git이 알아야 할 것은 다 알려줬기 때문에(두 인자를 모두 지정했죠), git은 현재 우리가 체크아웃한 브랜치는 무시하고 명령을 수행합니다."
]
@ -812,9 +812,9 @@ exports.level = {
"인자를 지정해주는 예제를 눈으로 직접 확인해 봅시다. 이 예제에서 우리가 체크아웃한 곳이 어디인지를 주의하며 봅시다."
],
"afterMarkdowns": [
"됬네요! 지정해준 인자들에 의해 원격 저장소의 `master`가 갱신 되었습니다."
"됬네요! 지정해준 인자들에 의해 원격 저장소의 `main`가 갱신 되었습니다."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -835,7 +835,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"좋습니다, 이번 레벨에서는 원격저장소의 `foo`, `master`브랜치 모두 갱신해봅시다. 이번 문제는 `git checkout`이 비활성화 되있다는 점이 특징이죠!",
"좋습니다, 이번 레벨에서는 원격저장소의 `foo`, `main`브랜치 모두 갱신해봅시다. 이번 문제는 `git checkout`이 비활성화 되있다는 점이 특징이죠!",
"",
"*노트: 원격 브랜치들은 `o/`접두어로 분류되어 있습니다. `origin/`으로 생략없이 표현하면 UI에 안맞아서 이렇게 표현했어요. ",
"그래서... 원격저장소 이름은 원래처럼 `origin`으로 써주세요.*"
@ -868,13 +868,13 @@ exports.level = {
"markdowns": [
"Ви спитаєте, що таке аргумент `<place>`? Ми скоро вдамося в детальні пояснення, але спочатку -- приклад. Виконання команди:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"буквально перекладається як:",
"",
"*Піди в гілку, що називається \"master\" в моєму репозиторії, візьми всі коміти, піди у віддалений \"master\", що називається \"origin\". Додай ті коміти, яких немає в цій гілці і надрукуй, що саме ти зробив.*",
"*Піди в гілку, що називається \"main\" в моєму репозиторії, візьми всі коміти, піди у віддалений \"main\", що називається \"origin\". Додай ті коміти, яких немає в цій гілці і надрукуй, що саме ти зробив.*",
"",
"Вказуючи `master` в якості аргумента \"place\", ми сказали git-у, *звідки* взяти коміти і *куди* їх додати. (\"Place\") - фактично точка синхронізації двох репозиторіїв.",
"Вказуючи `main` в якості аргумента \"place\", ми сказали git-у, *звідки* взяти коміти і *куди* їх додати. (\"Place\") - фактично точка синхронізації двох репозиторіїв.",
"",
"Пам'ятайте, що оскільки ми надали git-у всю необхідну інформацію (вказавши обидва аргументи), не має значення яка гілка є зараз поточною!"
]
@ -887,9 +887,9 @@ exports.level = {
"Розгляньмо приклад використання аргументів. Зверніть увагу на поточну гілку в цьому прикладі."
],
"afterMarkdowns": [
"Ось так! `master` у віддаленому репозиторії оновився, оскільки ми вказали його в аргументах."
"Ось так! `main` у віддаленому репозиторії оновився, оскільки ми вказали його в аргументах."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -910,7 +910,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Гаразд, на цьому рівні оновімо віддалені гілки `foo` і `master`. Для ускладнення ми заборонимо використовувати `git checkout`!",
"Гаразд, на цьому рівні оновімо віддалені гілки `foo` і `main`. Для ускладнення ми заборонимо використовувати `git checkout`!",
"",
"*Пам'ятай, віддалені гілки позначені префіксом `o/`, оскільки повний префікс `origin/` не влазить в наш UI. Але не хвилюйся ",
"про це... ти можеш використовувати `origin` посилаючись на віддалений репозиторій.*"
@ -943,13 +943,13 @@ exports.level = {
"markdowns": [
"Tham số `<vị trí>` là gì vậy? Chúng ta sẽ đi sâu vào chi tiết sau sau, hãy xem ví dụ trước. Đưa ra câu lệnh:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"được dịch lại là:",
"",
"*Chuyển sang nhánh \"master\" trong kho lưu trữ cục bộ, nhận tất cả các commit và tìm nhánh \"master\" trong kho chứa từ xa tên là \"origin\". Thêm tất cả các commit không có trong nhánh đó và báo cho tôi biết khi nào hoàn tất.*",
"*Chuyển sang nhánh \"main\" trong kho lưu trữ cục bộ, nhận tất cả các commit và tìm nhánh \"main\" trong kho chứa từ xa tên là \"origin\". Thêm tất cả các commit không có trong nhánh đó và báo cho tôi biết khi nào hoàn tất.*",
"",
"Bằng cách chỉ định `master` trong tham số \"vị trí\",ta báo với git nơi mà commit *xuất phát* và nơi chúng *sẽ đến*. Về căn bản nó là \"địa điểm\" để đồng bộ hóa 2 kho chứa.",
"Bằng cách chỉ định `main` trong tham số \"vị trí\",ta báo với git nơi mà commit *xuất phát* và nơi chúng *sẽ đến*. Về căn bản nó là \"địa điểm\" để đồng bộ hóa 2 kho chứa.",
"",
"Lưu ý rằng ta ta đã thông báo cho gi tất cả thông tin cần thiết( thông qua chỉ định 2 tham số), nó sẽ không quan tâm nhánh mà ta đang đứng!"
]
@ -962,9 +962,9 @@ exports.level = {
"Hãy xem xét một ví dụ về việc xác định tham số. Lưu ý vị trí nhánh mà ta đang đứng."
],
"afterMarkdowns": [
"Được rồi! Bằng cách chỉ định các tham số, nhánh `master` trong kho lưu trữ từ xa đã được cập nhật."
"Được rồi! Bằng cách chỉ định các tham số, nhánh `main` trong kho lưu trữ từ xa đã được cập nhật."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -985,7 +985,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Được rồi, trong cấp độ này hãy cập nhánh `foo` và `master` trên kho lưu trữ từ xa. Cái khó là ở cấp độ này lệnh `git checkout` đã bị vô hiệu hóa!",
"Được rồi, trong cấp độ này hãy cập nhánh `foo` và `main` trên kho lưu trữ từ xa. Cái khó là ở cấp độ này lệnh `git checkout` đã bị vô hiệu hóa!",
"",
"*Chú ý: Các nhánh từ xa được đánh dấu bằng tiền tố `o/` bời vì UI của chúng tôi không chứa được hết `origin/`. Đừng lo ",
"về vấn đề này... đơn giản cứ dùng `origin` như bình thường thôi.*"
@ -1018,11 +1018,11 @@ exports.level = {
"markdowns": [
"Kaj je `<place>` parameter praviš? Kmalu bomo zaplavali v podrobnosti, ampak najprej primer. Izvedba ukaza:",
"",
"`git push origin master`",
"`git push origin main`",
"",
"se v slovenščini prevede v:",
"",
"*Pojdi na branch poimenovan \"master\" na mojem repozitoriju, zgrabi vse commite in nato pojdi na branch \"master\" na oddaljenem repotu poimenovanem \"origin\". Postavi vse commite, ki manjkajo na branch in me obvesti, ko končaš.*",
"*Pojdi na branch poimenovan \"main\" na mojem repozitoriju, zgrabi vse commite in nato pojdi na branch \"main\" na oddaljenem repotu poimenovanem \"origin\". Postavi vse commite, ki manjkajo na branch in me obvesti, ko končaš.*",
"",
"Z določanjem `masterja` kot \"place\" argument, smo povedali gitu iz kje bodo commiti *prišli* in kam bodo commiti *šli*. V bistvu je to \"mesto\" oziroma \"lokacija\" za uskladitev med dvema repozitorijema.",
"",
@ -1037,9 +1037,9 @@ exports.level = {
"Poglejmo si primer podajanja argumentov. Bodi pozoren na mesto, kjer smo checkoutani v tem primeru."
],
"afterMarkdowns": [
"Evo ga! `master` je bil posodobljen na oddaljenem repotu, ker smo podali te argumente."
"Evo ga! `main` je bil posodobljen na oddaljenem repotu, ker smo podali te argumente."
],
"command": "git checkout C0; git push origin master",
"command": "git checkout C0; git push origin main",
"beforeCommand": "git clone; git commit"
}
},
@ -1060,7 +1060,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Ok, za to stopnjo posodobimo oba `foo` in `master` na oddaljenem repotu. Trik je, da je `git checkout` onemogočen za to stopnjo!",
"Ok, za to stopnjo posodobimo oba `foo` in `main` na oddaljenem repotu. Trik je, da je `git checkout` onemogočen za to stopnjo!",
"",
"*Opomba: Oddaljeni branchi so označeni z `o/` predpono, ker celotna `origin/` oznaka ne paše v naš prikaz. Ne skrbi ",
"glede tega ... preprosto uporabi `origin` kot ime oddaljenega repota kot ponavadi.*"

102
src/levels/remote/pushArgs2.js
View file

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C6\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"foo\":{\"target\":\"C4\",\"id\":\"foo\",\"remoteTrackingBranchID\":\"o/foo\"},\"o/master\":{\"target\":\"C4\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"o/foo\":{\"target\":\"C5\",\"id\":\"o/foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C2\",\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C2\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C4\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"foo\":{\"target\":\"C5\",\"id\":\"foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C5\":{\"parents\":[\"C2\"],\"id\":\"C5\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C2\",\"C3\"],\"id\":\"C4\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"solutionCommand": "git push origin master^:foo;git push origin foo:master",
"solutionCommand": "git push origin main^:foo;git push origin foo:main",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C6\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\"},\"foo\":{\"target\":\"C4\",\"id\":\"foo\",\"remoteTrackingBranchID\":\"o/foo\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null},\"o/foo\":{\"target\":\"C1\",\"id\":\"o/foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C2\",\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C2\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\",\"remoteTrackingBranchID\":null},\"foo\":{\"target\":\"C1\",\"id\":\"foo\",\"remoteTrackingBranchID\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"name": {
"en_US": "Git push arguments -- Expanded!",
@ -45,7 +45,7 @@ exports.level = {
"markdowns": [
"## `<place>` argument details",
"",
"Remember from the previous lesson that when we specified `master` as the place argument for git push, we specified both the *source* of where the commits would come from and the *destination* of where the commits would go.",
"Remember from the previous lesson that when we specified `main` as the place argument for git push, we specified both the *source* of where the commits would come from and the *destination* of where the commits would go.",
"",
"You might then be wondering -- what if we wanted the source and destination to be different? What if you wanted to push commits from the `foo` branch locally onto the `bar` branch on remote?",
"",
@ -78,7 +78,7 @@ exports.level = {
"afterMarkdowns": [
"Woah! That's a pretty trippy command but it makes sense -- git resolved `foo^` into a location, uploaded whatever commits that weren't present yet on the remote, and then updated destination."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -91,7 +91,7 @@ exports.level = {
"afterMarkdowns": [
"Sweet, that's pretty slick :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -115,7 +115,7 @@ exports.level = {
"markdowns": [
"## L'argument `<place>` dans le détail",
"",
"Rappelez-vous de notre dernière leçon : quand vous passiez `master` comme argument `<place>` à git push, cela spécifiait à la fois la *source* de provenance des commits et leur *destination*.",
"Rappelez-vous de notre dernière leçon : quand vous passiez `main` comme argument `<place>` à git push, cela spécifiait à la fois la *source* de provenance des commits et leur *destination*.",
"",
"Vous vous demandez peut-être donc : et si nous voulions avoir une source et une destination différentes ? Et si vous voulez envoyez des commits de la branche locale `foo` dans la branche distante `bar` ?",
"",
@ -148,7 +148,7 @@ exports.level = {
"afterMarkdowns": [
"Woahou ! C'est une commande très alambiquée mais qui a du sens : git résoud `foo^` en un emplacement, envoie tous les commits qui n'étaient pas encore présents sur le dépôt distant, et met ensuite à jour la branche de destination."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -161,7 +161,7 @@ exports.level = {
"afterMarkdowns": [
"Cool, c'est habile :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -185,7 +185,7 @@ exports.level = {
"markdowns": [
"## Detalles sobre el parámetro `<lugar>`",
"",
"Acordate de la lección anterior que cuando especificamos `master` como el parámetro lugar de git push, especificamos tanto el *origen* del que sacar los commits como el *destino* al que enviarlos.",
"Acordate de la lección anterior que cuando especificamos `main` como el parámetro lugar de git push, especificamos tanto el *origen* del que sacar los commits como el *destino* al que enviarlos.",
"",
"Podrías estar preguntándote ¿Y si quisiéramos que el origen y el destino sean distintos? ¿Si quisieras pushear los commits de la rama local `foo` a la rama `bar` del remote?",
"",
@ -218,7 +218,7 @@ exports.level = {
"afterMarkdowns": [
"¡Woow! Ese commando es bastante loco, pero tiene sentido: git resolvió `foo^` a una ubicación, subió cualquier commit de ahí que aún no estuviera en el remoto, y luego actualizó el destino."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -231,7 +231,7 @@ exports.level = {
"afterMarkdowns": [
"Genial, simplemente fluye :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -255,7 +255,7 @@ exports.level = {
"markdowns": [
"## Detalles sobre el parámetro `<lugar>`",
"",
"Recuerda de la lección anterior que cuando especificamos `master` como el parámetro lugar de git push, especificamos tanto el *origen* del que sacar los commits como el *destino* al que enviarlos.",
"Recuerda de la lección anterior que cuando especificamos `main` como el parámetro lugar de git push, especificamos tanto el *origen* del que sacar los commits como el *destino* al que enviarlos.",
"",
"Podrías estar preguntándote ¿Y si quisiéramos que el origen y el destino fuesen distintos? ¿Si quisieras hacer push de los commits de la rama local `foo` a la rama `bar` del remote?",
"",
@ -288,7 +288,7 @@ exports.level = {
"afterMarkdowns": [
"¡Vaya! Ese commando es bastante rompedor, pero tiene sentido: git resolvió `foo^` a una ubicación, subió cualquier commit de ahí que aún no estuviera en el remoto, y luego actualizó el destino."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -301,7 +301,7 @@ exports.level = {
"afterMarkdowns": [
"Genial, simplemente fluye :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -325,7 +325,7 @@ exports.level = {
"markdowns": [
"## Detalhes sobre `<lugar>`",
"",
"Lembra que na lição anterior especificamos `master` como o parâmetro lugar para o git push? Lá definimos tanto a *origem* de onde os commits viriam quanto o *destino* para onde os commits foram.",
"Lembra que na lição anterior especificamos `main` como o parâmetro lugar para o git push? Lá definimos tanto a *origem* de onde os commits viriam quanto o *destino* para onde os commits foram.",
"",
"Você pode estar se perguntando -- e se eu quisesse que a origem e o destino fossem diferentes? E se eu quisesse enviar commits do ramo local `foo` para o ramo remoto `bar`?",
"",
@ -358,7 +358,7 @@ exports.level = {
"afterMarkdowns": [
"Uau! Esse comando é bastante viajado, mas ele faz sentido -- o Git entendeu a referência `foo^`, enviou quaisquer commits que não estavam presentes no repositório remoto, e então atualizou o destino."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -371,7 +371,7 @@ exports.level = {
"afterMarkdowns": [
"Doce, isso é muito bom :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -395,7 +395,7 @@ exports.level = {
"markdowns": [
"## Detalles sobre o parámetro `<lugar>`",
"",
"Lémbrate da lección anterior cando especificamos `master` como o parámetro lugar de git push, especificamos tanto a *orixe* do que sacar os commits como o *destino* ó que envialos.",
"Lémbrate da lección anterior cando especificamos `main` como o parámetro lugar de git push, especificamos tanto a *orixe* do que sacar os commits como o *destino* ó que envialos.",
"",
"Poderías estar a preguntarte ¿E se quixéramos que a orixe e o destino sexan distintos? ¿Se quixéramos empurrar os commits da rama local `foo` á rama `bar` do remoto?",
"",
@ -428,7 +428,7 @@ exports.level = {
"afterMarkdowns": [
"¡Woow! Ese commando é unha tolemia, pero ten sentido: git resolveu `foo^` a unha ubicación, subiu calquera commit de ahí que aún non estivera no remoto, e logo actualizou o destino."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -441,7 +441,7 @@ exports.level = {
"afterMarkdowns": [
"Xenial, sinxelamente tira para adiante."
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -465,7 +465,7 @@ exports.level = {
"markdowns": [
"## `<place>` 這個參數的細節",
"",
"回想一下，我們在之前的課程中提到，當我們用 `git push` 並且把 `master` 當作 `<place>` 這個參數的時候，我們就相當於告訴 git 我們的所要更新的 commit 要*從哪裡來*（source） 並且要 *往哪裡去*（destination）。",
"回想一下，我們在之前的課程中提到，當我們用 `git push` 並且把 `main` 當作 `<place>` 這個參數的時候，我們就相當於告訴 git 我們的所要更新的 commit 要*從哪裡來*（source） 並且要 *往哪裡去*（destination）。",
"",
"你可能會很好奇，當我們的 source 以及 destination 是不同的時候，應該怎麼做？當你想要 push `foo` branch 上面的 commit 到 remote 的 `bar` branch 的時候，應該怎麼做？",
"",
@ -496,9 +496,9 @@ exports.level = {
"記住， `source` 表示任意可以被 git 辨識的位置："
],
"afterMarkdowns": [
"哇!這實在是一個很花俏的指令但是確很合理，git 把 `foo^` 解讀成一個位置，並且 push 該位置的 commit 到目前 remote 的 master branch。"
"哇!這實在是一個很花俏的指令但是確很合理，git 把 `foo^` 解讀成一個位置，並且 push 該位置的 commit 到目前 remote 的 main branch。"
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -511,7 +511,7 @@ exports.level = {
"afterMarkdowns": [
"太讚了，實在非常地簡單:D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -535,7 +535,7 @@ exports.level = {
"markdowns": [
"## `<place>`参数详解",
"",
"还记得之前课程说的吧，当为 git push 指定 place 参数为 `master` 时，我们同时指定了提交记录的来源和去向。",
"还记得之前课程说的吧，当为 git push 指定 place 参数为 `main` 时，我们同时指定了提交记录的来源和去向。",
"",
"你可能想问 —— 如果来源和去向分支的名称不同呢？比如你想把本地的 `foo` 分支推送到远程仓库中的 `bar` 分支。",
"",
@ -566,9 +566,9 @@ exports.level = {
"记住，`source` 可以是任何 Git 能识别的位置："
],
"afterMarkdowns": [
"这是个另人困惑的命令，但是它确实是可以运行的 —— Git 将 `foo^` 解析为一个位置，上传所有未被包含到远程仓库里 `master` 分支中的提交记录。"
"这是个另人困惑的命令，但是它确实是可以运行的 —— Git 将 `foo^` 解析为一个位置，上传所有未被包含到远程仓库里 `main` 分支中的提交记录。"
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -581,7 +581,7 @@ exports.level = {
"afterMarkdowns": [
"很赞吧！它是不是很聪明？！ :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -605,11 +605,11 @@ exports.level = {
"markdowns": [
"## Details zum `<Ort>`-Parameter",
"",
"Du erinnerst dich von dem vorherigen Level, dass, als wir `master` als \"Ort\" beim `git push` angegeben haben, daraus sowohl die *Quelle* als auch das *Ziel* für die Operation abgeleitet wurden.",
"Du erinnerst dich von dem vorherigen Level, dass, als wir `main` als \"Ort\" beim `git push` angegeben haben, daraus sowohl die *Quelle* als auch das *Ziel* für die Operation abgeleitet wurden.",
"",
"Daher fragst du dich vielleicht -- was wenn wir möchten, dass Quelle und Ziel anders sind? Was wenn du Commits von einem lokalen Branch `foo` in den Branch `bar` auf einem Server schieben möchtest?",
"Daher fragst du dich vielleicht -- was wenn wir möchten, dass Quelle und Ziel verschieden voneinander sind? Was wenn du Commits von einem lokalen Branch `foo` in den Branch `bar` auf einem Server schieben möchtest?",
"",
"Tja, leider ist das in Git unmöglich .... ein Scherz! Natürlich ist das möglich. Git besitzt tonnenweise Flexibilität (eher zuviel, als zuwenig).",
"Tja, leider ist das in Git unmöglich .... ein Scherz! Natürlich ist das möglich. Git besitzt tonnenweise Flexibilität (eher zu viel, als zu wenig).",
"",
"Und gleich sehen wir, wie das geht ..."
]
@ -623,9 +623,9 @@ exports.level = {
"",
"`git push origin <Quelle>:<Ziel>`",
"",
"Das wird üblicherweise Refspec (Referenz-Spezifikation) genannt. Refspec ist nur ein anderer Name für einen Ort, mit dem Git etwas anfangen kann (wie mit Branch `foo` oder mit `HEAD~2`)",
"Das wird üblicherweise Refspec (Referenz-Spezifikation) genannt. Refspec ist nur ein anderer Name für einen Ort, mit dem Git etwas anfangen kann (wie mit Branch `foo` oder mit `HEAD~2`).",
"",
"Sobald du Quelle und Ziel separat angibt, kannst du flexibel und präzise entfernte Branches ansteuern. Hier eine Demo:"
"Sobald du Quelle und Ziel separat angibst, kannst du flexibel und präzise entfernte Branches ansteuern. Hier eine Demo:"
]
}
},
@ -636,9 +636,9 @@ exports.level = {
"Vergiss nicht, `Quelle` ist jeder mögliche Ort, mit dem Git etwas anfangen kann:"
],
"afterMarkdowns": [
"Boah! Das ist ein ziemlich abgefahrener Befehl gewesen, aber er ist sinnvoll -- Git hat `foo^` zu einem Commit aufgelöst, alle Commits die bis zu diesem einschließich noch nicht auf dem Server waren hochgeladen und dann dort das Ziel aktualisiert."
"Boah! Das ist ein ziemlich abgefahrener Befehl gewesen, aber er ist sinnvoll -- Git hat `foo^` zu einem Commit aufgelöst, alle Commits, die bis zu einschließlich diesem noch nicht auf dem Server waren, hochgeladen und dann dort das Ziel aktualisiert."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -651,7 +651,7 @@ exports.level = {
"afterMarkdowns": [
"Schick, das ist ziemlich praktisch. :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -659,7 +659,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Um dieses Level zu schaffen versuch den dargestellten Zielzustand zu erreichen und vergiss nicht das Format:",
"Um dieses Level zu schaffen versuche den dargestellten Zielzustand zu erreichen und vergiss nicht das Format:",
"",
"`<Quelle>:<Ziel>`"
]
@ -675,7 +675,7 @@ exports.level = {
"markdowns": [
"## Подробности аргумента `<пункт назначения>`",
"",
"Помните, когда в прошлом занятии мы указали в качестве аргумента ветку `master` для команды git push, мы указали совместно *источник*, откуда будут приходить коммиты, и *пункт назначения (получатель)*, куда коммиты будут уходить.",
"Помните, когда в прошлом занятии мы указали в качестве аргумента ветку `main` для команды git push, мы указали совместно *источник*, откуда будут приходить коммиты, и *пункт назначения (получатель)*, куда коммиты будут уходить.",
"",
"Однако, вы, наверное, задаётесь вопросом - а что, если я хочу, чтобы мои источник и получатель коммитов были различными? Что, если мы хотим запушить коммиты из локальной ветки `foo` в ветку `bar` на удалённом репозитории?",
"",
@ -708,7 +708,7 @@ exports.level = {
"afterMarkdowns": [
"Вау! Это довольно нетривиальная команда, однако она имеет смысл - git видит в `foo^` не что иное, как местоположение, закачивает все коммиты, которые не присутствуют на удалённом репозитории, и затем обновляет получателя."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -721,7 +721,7 @@ exports.level = {
"afterMarkdowns": [
"Класс! Довольно легко! :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -746,7 +746,7 @@ exports.level = {
"## `<place>` 인자에 대한 세부사항들",
"",
"",
"기억하세요? 이전 강의에서 우리는 `master`를 커밋의 근원이되는 *source*와 목적지가 되는 *destination*으로 명령어의 인자로 넣어줌으로써 지정해줬습니다.",
"기억하세요? 이전 강의에서 우리는 `main`를 커밋의 근원이되는 *source*와 목적지가 되는 *destination*으로 명령어의 인자로 넣어줌으로써 지정해줬습니다.",
"여러분은 이런 생각이 들 수 있어요 -- 내가 source와 destination이 다르길 원하면 어떻게 해야되지? 로컬의 `foo` 브랜치에서 원격의 `bar` 브랜치로 커밋을 push하고 싶으면 어떻게 해야 되지?",
"",
"사실 git에서는 그게 불가능합니다... 네 농담이고! 당연 가능합니다 :)... git의 어마무시하게 유연합니다(지나칠정도로요).",
@ -778,7 +778,7 @@ exports.level = {
"afterMarkdowns": [
"워 뭔가 잘 안쓸것 같은 명령이지만 잘 됩니다 -- git은 `foo^`의 위치를 알아내서 원격 저장소에 아직 반영되지 않은 커밋들을 업로드하고 destination 브랜치를 갱신했습니다."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -791,7 +791,7 @@ exports.level = {
"afterMarkdowns": [
"좋네요, 번지르르 삐까뻔쩍 :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -815,7 +815,7 @@ exports.level = {
"markdowns": [
"## Детальніше про аргумент `<place>`",
"",
"З попереднього уроку нам відомо, що коли ми вказуємо `master` в якості аргумента place для git push, ми задаємо і гілку, *з якої* брати нові коміти, і гілку *до якої* їх буде перенесено.",
"З попереднього уроку нам відомо, що коли ми вказуємо `main` в якості аргумента place для git push, ми задаємо і гілку, *з якої* брати нові коміти, і гілку *до якої* їх буде перенесено.",
"",
"Тут ти можеш задуматись, а чи можуть гілки, звідки беремо, і куди переносимо, бути різними? Що, коли потрібно коміти з локальної гілки `foo` перенести у віддалену гілку `bar`?",
"",
@ -848,7 +848,7 @@ exports.level = {
"afterMarkdowns": [
"Овва! Це доволі незвична команда, але тут все має сенс -- git, знаючи куди вказує `foo^`, завантажив на віддалену сторону ще відсутні там коміти і оновив місце призначення."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -861,7 +861,7 @@ exports.level = {
"afterMarkdowns": [
"Спритно, еге-ж? :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -885,7 +885,7 @@ exports.level = {
"markdowns": [
"## Chi tiết về tham số `<vị trí>`",
"",
"Nhớ lại học trước, khi chỉ định tham số `<vị trí>` là `master` cho lệnh `git push`, ta cũng đã chỉ định nguồn và đích cho các commit.",
"Nhớ lại học trước, khi chỉ định tham số `<vị trí>` là `main` cho lệnh `git push`, ta cũng đã chỉ định nguồn và đích cho các commit.",
"",
"Có thể bạn sẽ thắng mắc -- Nếu như ta muốn nguồn và đích khác đi thì sao? Nếu như ta muốn đẩy commit từ nhánh cục bộ `foo` lên nhánh từ xa `bar` thì sao?",
"",
@ -918,7 +918,7 @@ exports.level = {
"afterMarkdowns": [
"Wao! Lệnh này khá phức tạp, nhưng mà hợp lý -- git diễn giải `foo^` thành một vị trí, tải lên tất cả các commit từ đó trở về trước mà chưa có trên nhánh đích rồi cập nhật nó."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -931,7 +931,7 @@ exports.level = {
"afterMarkdowns": [
"Tuyệt vời, thấy git thú vị không :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},
@ -955,7 +955,7 @@ exports.level = {
"markdowns": [
"## Podrobnosti `<place>` argumenta",
"",
"Spomni se prejšnje lekcije, kjer smo določili `master` kot place argument za git push, določili smo *izvor* iz kje bodo commiti prišli in *destinacijo*, kamor bodo commiti odšli.",
"Spomni se prejšnje lekcije, kjer smo določili `main` kot place argument za git push, določili smo *izvor* iz kje bodo commiti prišli in *destinacijo*, kamor bodo commiti odšli.",
"",
"Morda se sprašuješ -- kaj če želimo, da sta izvor in destinacija različna? Kaj če želiš pushati commite iz lokalnega `foo` brancha na oddaljen `bar` branch?",
"",
@ -988,7 +988,7 @@ exports.level = {
"afterMarkdowns": [
"Woah! To je kar zanimiv ukaz, ampak ima smisel -- git je razrešil `foo^` v lokacijo, naložil commite, ki še niso bili prisotni v oddaljenem repotu in nato posodobil destinacijo."
],
"command": "git push origin foo^:master",
"command": "git push origin foo^:main",
"beforeCommand": "git clone; go -b foo; git commit; git commit"
}
},
@ -1001,7 +1001,7 @@ exports.level = {
"afterMarkdowns": [
"Lepa, to je kar kul :D"
],
"command": "git push origin master:newBranch",
"command": "git push origin main:newBranch",
"beforeCommand": "git clone; git commit"
}
},

124
src/levels/remote/pushManyFeatures.js
View file

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C7%27%22%2C%22id%22%3A%22master%22%2C%22remoteTrackingBranchID%22%3A%22o/master%22%2C%22localBranchesThatTrackThis%22%3Anull%7D%2C%22o/master%22%3A%7B%22target%22%3A%22C7%27%22%2C%22id%22%3A%22o/master%22%2C%22remoteTrackingBranchID%22%3Anull%2C%22localBranchesThatTrackThis%22%3A%5B%22master%22%5D%7D%2C%22side1%22%3A%7B%22target%22%3A%22C2%27%22%2C%22id%22%3A%22side1%22%2C%22remoteTrackingBranchID%22%3Anull%2C%22localBranchesThatTrackThis%22%3Anull%7D%2C%22side2%22%3A%7B%22target%22%3A%22C4%27%22%2C%22id%22%3A%22side2%22%2C%22remoteTrackingBranchID%22%3Anull%2C%22localBranchesThatTrackThis%22%3Anull%7D%2C%22side3%22%3A%7B%22target%22%3A%22C7%27%22%2C%22id%22%3A%22side3%22%2C%22remoteTrackingBranchID%22%3Anull%2C%22localBranchesThatTrackThis%22%3Anull%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C2%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C2%22%7D%2C%22C3%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C3%22%7D%2C%22C4%22%3A%7B%22parents%22%3A%5B%22C3%22%5D%2C%22id%22%3A%22C4%22%7D%2C%22C5%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C5%22%7D%2C%22C6%22%3A%7B%22parents%22%3A%5B%22C5%22%5D%2C%22id%22%3A%22C6%22%7D%2C%22C7%22%3A%7B%22parents%22%3A%5B%22C6%22%5D%2C%22id%22%3A%22C7%22%7D%2C%22C8%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C8%22%7D%2C%22C2%27%22%3A%7B%22parents%22%3A%5B%22C8%22%5D%2C%22id%22%3A%22C2%27%22%7D%2C%22C3%27%22%3A%7B%22parents%22%3A%5B%22C2%27%22%5D%2C%22id%22%3A%22C3%27%22%7D%2C%22C4%27%22%3A%7B%22parents%22%3A%5B%22C3%27%22%5D%2C%22id%22%3A%22C4%27%22%7D%2C%22C5%27%22%3A%7B%22parents%22%3A%5B%22C4%27%22%5D%2C%22id%22%3A%22C5%27%22%7D%2C%22C6%27%22%3A%7B%22parents%22%3A%5B%22C5%27%22%5D%2C%22id%22%3A%22C6%27%22%7D%2C%22C7%27%22%3A%7B%22parents%22%3A%5B%22C6%27%22%5D%2C%22id%22%3A%22C7%27%22%7D%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%2C%22originTree%22%3A%7B%22branches%22%3A%7B%22master%22%3A%7B%22target%22%3A%22C7%27%22%2C%22id%22%3A%22master%22%2C%22remoteTrackingBranchID%22%3Anull%2C%22localBranchesThatTrackThis%22%3Anull%7D%7D%2C%22commits%22%3A%7B%22C0%22%3A%7B%22parents%22%3A%5B%5D%2C%22id%22%3A%22C0%22%2C%22rootCommit%22%3Atrue%7D%2C%22C1%22%3A%7B%22parents%22%3A%5B%22C0%22%5D%2C%22id%22%3A%22C1%22%7D%2C%22C8%22%3A%7B%22parents%22%3A%5B%22C1%22%5D%2C%22id%22%3A%22C8%22%7D%2C%22C2%27%22%3A%7B%22parents%22%3A%5B%22C8%22%5D%2C%22id%22%3A%22C2%27%22%7D%2C%22C3%27%22%3A%7B%22parents%22%3A%5B%22C2%27%22%5D%2C%22id%22%3A%22C3%27%22%7D%2C%22C4%27%22%3A%7B%22parents%22%3A%5B%22C3%27%22%5D%2C%22id%22%3A%22C4%27%22%7D%2C%22C5%27%22%3A%7B%22parents%22%3A%5B%22C4%27%22%5D%2C%22id%22%3A%22C5%27%22%7D%2C%22C6%27%22%3A%7B%22parents%22%3A%5B%22C5%27%22%5D%2C%22id%22%3A%22C6%27%22%7D%2C%22C7%27%22%3A%7B%22parents%22%3A%5B%22C6%27%22%5D%2C%22id%22%3A%22C7%27%22%7D%7D%2C%22HEAD%22%3A%7B%22target%22%3A%22master%22%2C%22id%22%3A%22HEAD%22%7D%7D%7D",
"solutionCommand": "git fetch;git rebase o/master side1;git rebase side1 side2;git rebase side2 side3;git rebase side3 master;git push",
"solutionCommand": "git fetch;git rebase o/main side1;git rebase side1 side2;git rebase side2 side3;git rebase side3 main;git push",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\",\"remoteTrackingBranchID\":\"o/master\",\"localBranchesThatTrackThis\":null},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":[\"master\"]},\"side1\":{\"target\":\"C2\",\"id\":\"side1\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null},\"side2\":{\"target\":\"C4\",\"id\":\"side2\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null},\"side3\":{\"target\":\"C7\",\"id\":\"side3\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"},\"C5\":{\"parents\":[\"C1\"],\"id\":\"C5\"},\"C6\":{\"parents\":[\"C5\"],\"id\":\"C6\"},\"C7\":{\"parents\":[\"C6\"],\"id\":\"C7\"}},\"HEAD\":{\"target\":\"side3\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C8\",\"id\":\"master\",\"remoteTrackingBranchID\":null,\"localBranchesThatTrackThis\":null}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C8\":{\"parents\":[\"C1\"],\"id\":\"C8\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"hint": {
"en_US": "Remember you can always use the undo or reset commands",
@ -22,7 +22,7 @@ exports.level = {
"name": {
"en_US": "Push Master!",
"zh_CN": "推送主分支",
"zh_TW": "push master！",
"zh_TW": "push main！",
"es_AR": "¡Push Master!",
"es_ES": "¡Push Master!",
"pt_BR": "Push Master!",
@ -48,13 +48,13 @@ exports.level = {
"",
"Now that you're comfortable with fetching, pulling, and pushing, let's put these skills to the test with a new workflow.",
"",
"It's common for developers on big projects to do all their work on feature branches (off of `master`) and then integrate that work only once it's ready. This is similar to the previous lesson (where side branches get pushed to the remote), but here we introduce one more step.",
"It's common for developers on big projects to do all their work on feature branches (off of `main`) and then integrate that work only once it's ready. This is similar to the previous lesson (where side branches get pushed to the remote), but here we introduce one more step.",
"",
"Some developers only push and pull when on the `master` branch -- that way `master` always stays updated to what is on the remote (`o/master`).",
"Some developers only push and pull when on the `main` branch -- that way `main` always stays updated to what is on the remote (`o/main`).",
"",
"So for this workflow we combine two things:",
"",
"* integrating feature branch work onto `master`, and",
"* integrating feature branch work onto `main`, and",
"* pushing and pulling from the remote"
]
}
@ -63,7 +63,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Let's see a refresher real quick of how to update `master` and push work."
"Let's see a refresher real quick of how to update `main` and push work."
],
"afterMarkdowns": [
"We executed two commands here that:",
@ -101,13 +101,13 @@ exports.level = {
"",
"Maintenant que vous êtes habitué à fetch, pull et push, mettons ces compétences à profit avec une autre approche de travail.",
"",
"Il est commun pour les développeurs de gros projets de faire tout leur travail dans des \"feature branches\" dédiées à une fonctionnalité (en dehors de `master`) et d'intégrer ce travail au reste seulement une fois qu'il est prêt. C'est similaire à la leçon précédente (où les branches secondaires étaient pushées sur le dépôt distant), mais ici nous introduisons une étape supplémentaire.",
"Il est commun pour les développeurs de gros projets de faire tout leur travail dans des \"feature branches\" dédiées à une fonctionnalité (en dehors de `main`) et d'intégrer ce travail au reste seulement une fois qu'il est prêt. C'est similaire à la leçon précédente (où les branches secondaires étaient pushées sur le dépôt distant), mais ici nous introduisons une étape supplémentaire.",
"",
"Certains développeurs utilisent la méthode \"push puis pull\" uniquement sur la branche `master` : de cette manière `master` reste toujours à jour avec ce qu'il y a sur le dépôt distant (`o/master`).",
"Certains développeurs utilisent la méthode \"push puis pull\" uniquement sur la branche `main` : de cette manière `main` reste toujours à jour avec ce qu'il y a sur le dépôt distant (`o/main`).",
"",
"Cette approche combine donc deux choses :",
"",
"* intégrer le travail présent depuis la feature branch (la fonctionnalité développée) vers `master`, puis",
"* intégrer le travail présent depuis la feature branch (la fonctionnalité développée) vers `main`, puis",
"* pusher et puller sur le dépôt distant."
]
}
@ -116,7 +116,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Rappelons-nous rapidement comment mettre à jour `master` et envoyer (push) le travail."
"Rappelons-nous rapidement comment mettre à jour `main` et envoyer (push) le travail."
],
"afterMarkdowns": [
"Nous exécutons ici deux commandes :",
@ -154,13 +154,13 @@ exports.level = {
"",
"Ahora que estás cómodo fetcheando, pulleando y pusheando, pongamos a prueba estas habilidades con un nuevo flujo de trabajo.",
"",
"Es bastante común que los desarrolladores en los grandes proyectos trabajen sobre ramas específicas para cada tarea (feature branches) basadas en `master`, y que las integren sólo cuando están listas. Esto es similar a la lección anterior, en que pusheabamos las ramas periféricas al remoto, pero acá tenemos un paso más.",
"Es bastante común que los desarrolladores en los grandes proyectos trabajen sobre ramas específicas para cada tarea (feature branches) basadas en `main`, y que las integren sólo cuando están listas. Esto es similar a la lección anterior, en que pusheabamos las ramas periféricas al remoto, pero acá tenemos un paso más.",
"",
"Algunos desarrolladores sólo pushean y pullean cuando están en `master`: de ese modo, `master` siempre se mantiene actualizado con el remoto (`o/master`).",
"Algunos desarrolladores sólo pushean y pullean cuando están en `main`: de ese modo, `main` siempre se mantiene actualizado con el remoto (`o/main`).",
"",
"Entonces, en este flujo de trabajo combinamos dos cosas:",
"",
"* integramos el trabajo de las ramas específicas a `master`, y",
"* integramos el trabajo de las ramas específicas a `main`, y",
"* pusheamos y pulleamos del remoto"
]
}
@ -169,7 +169,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Refresquemos un poco cómo actualizar `master` y pushear nuestro trabajo."
"Refresquemos un poco cómo actualizar `main` y pushear nuestro trabajo."
],
"afterMarkdowns": [
"Acá ejecutamos dos comandos que:",
@ -207,13 +207,13 @@ exports.level = {
"",
"Ahora que estás cómodo fetcheando, pulleando y pusheando, pongamos a prueba estas habilidades con un nuevo flujo de trabajo.",
"",
"Es bastante común que los desarrolladores en los grandes proyectos trabajen sobre ramas específicas para cada tarea (feature branches o ramas de trabajo) basadas en `master`, y que las integren sólo cuando estén listas. Esto es similar a la lección anterior, en la que hicimos push de las ramas periféricas al remoto, pero aquí tenemos un paso más.",
"Es bastante común que los desarrolladores en los grandes proyectos trabajen sobre ramas específicas para cada tarea (feature branches o ramas de trabajo) basadas en `main`, y que las integren sólo cuando estén listas. Esto es similar a la lección anterior, en la que hicimos push de las ramas periféricas al remoto, pero aquí tenemos un paso más.",
"",
"Algunos desarrolladores sólo pushean y pullean cuando están en `master`: de ese modo, `master` siempre se mantiene actualizado con el remoto (`o/master`).",
"Algunos desarrolladores sólo pushean y pullean cuando están en `main`: de ese modo, `main` siempre se mantiene actualizado con el remoto (`o/main`).",
"",
"Entonces, en este flujo de trabajo combinamos dos cosas:",
"",
"* integramos el trabajo de las ramas específicas a `master`, y",
"* integramos el trabajo de las ramas específicas a `main`, y",
"* pusheamos y pulleamos del remoto"
]
}
@ -222,7 +222,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Refresquemos un poco cómo actualizar `master` y pushear nuestro trabajo."
"Refresquemos un poco cómo actualizar `main` y pushear nuestro trabajo."
],
"afterMarkdowns": [
"Ahora ejecutamos dos comandos que:",
@ -260,13 +260,13 @@ exports.level = {
"",
"Agora que você está confortável com fetch, pull e push, vamos colocar essas habilidades em teste com um novo fluxo de trabalho.",
"",
"É comum para desenvolvedores de grande projetos fazer todo o trabalho em ramos de funcionalidades (fora do `master`) e então integrar esse trabalho uma única vez quando ele estiver pronto. Isso é similar à lição anterior (onde ramos laterais eram enviados ao repositório remoto), mas introduzimos mais um passo.",
"É comum para desenvolvedores de grande projetos fazer todo o trabalho em ramos de funcionalidades (fora do `main`) e então integrar esse trabalho uma única vez quando ele estiver pronto. Isso é similar à lição anterior (onde ramos laterais eram enviados ao repositório remoto), mas introduzimos mais um passo.",
"",
"Alguns desenvolvedores só fazem push e pull quando no ramo `master` -- desta forma o `master` sempre se mantém atualizado com aquilo que está no ramo remoto (`o/master`).",
"Alguns desenvolvedores só fazem push e pull quando no ramo `main` -- desta forma o `main` sempre se mantém atualizado com aquilo que está no ramo remoto (`o/main`).",
"",
"Então, para este fluxo de trabalho, combinaremos duas coisas:",
"",
"* Integrar ramos de funcionalidade no `master`, e",
"* Integrar ramos de funcionalidade no `main`, e",
"* Realizar push e pull do repositório remoto"
]
}
@ -275,7 +275,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Vamos refrescar a memória sobre como atualizar o `master` e enviar trabalho."
"Vamos refrescar a memória sobre como atualizar o `main` e enviar trabalho."
],
"afterMarkdowns": [
"Nós executamos dois comandos aqui que:",
@ -315,11 +315,11 @@ exports.level = {
"",
"É bastante común que os desenvolvedores nos grandes proxectos traballen sobre ramas específicas para cada tarefa (feature branches) baseadas en `mater`, e que as integren só cando están preparadas. Esto é similar á lección anterior, na que empurrábamos as ramas periféricas ó remoto, pero acá temos un paso máis.",
"",
"Algúns desenvovledores só empurran e descargan cando están en `master`: de ese xeito, `master` sempre mantén actualizado o seu estado co remoto (`o/master`).",
"Algúns desenvovledores só empurran e descargan cando están en `main`: de ese xeito, `main` sempre mantén actualizado o seu estado co remoto (`o/main`).",
"",
"Entón, neste fluxo de traballo combinamos dúas cousas:",
"",
"* integramos o traballo das ramas específicas a `master`, e",
"* integramos o traballo das ramas específicas a `main`, e",
"* empurramos e turramos do remoto"
]
}
@ -328,7 +328,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Refresquemos un pouco cómo actualizar `master` e empurrar o noso traballo."
"Refresquemos un pouco cómo actualizar `main` e empurrar o noso traballo."
],
"afterMarkdowns": [
"Agora executamos dous comandos que:",
@ -366,13 +366,13 @@ exports.level = {
"",
"現在你已經很熟悉 fetch、pull 以及 push，讓我們來針對一個新的問題來應用這些技巧。",
"",
"在一個大型的專案裡面，程式設計師經常會在 feature branch（有別於 master branch）上面做開發，之後等開發完之後，在一次 merge 回去。這跟之前的課程是很類似的（其它的 branch 被 push 到 remote），但是現在我們還要再多介紹一個步驟。",
"在一個大型的專案裡面，程式設計師經常會在 feature branch（有別於 main branch）上面做開發，之後等開發完之後，在一次 merge 回去。這跟之前的課程是很類似的（其它的 branch 被 push 到 remote），但是現在我們還要再多介紹一個步驟。",
"",
"某些程式設計師只針對 `master` branch 進行 push 或者是 pull。這樣子的話 `master` 一直都保持跟 remote （`o/master`） 同步。",
"某些程式設計師只針對 `main` branch 進行 push 或者是 pull。這樣子的話 `main` 一直都保持跟 remote （`o/main`） 同步。",
"",
"所以針對這個問題我們結合了兩件事情：",
"",
"* merge feature branch 到`master` branch，並且",
"* merge feature branch 到`main` branch，並且",
"* push remote 以及 pull remote"
]
}
@ -381,7 +381,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"讓我們馬上來實際看一下如何更新 `master` 並且 push 到 remote。"
"讓我們馬上來實際看一下如何更新 `main` 並且 push 到 remote。"
],
"afterMarkdowns": [
"我們在這裡執行兩個指令:",
@ -417,15 +417,15 @@ exports.level = {
"markdowns": [
"## Einen Feature Branch reintegrieren",
"",
"Nun da du mit `fetch`, `pull`, und `push` vertraut bist sollten wir diese Fähigkeiten mit einem neuen Arbeitsablauf auf die Probe stellen.",
"Nun da du mit `fetch`, `pull`, und `push` vertraut bist, sollten wir diese Fähigkeiten mit einem neuen Arbeitsablauf auf die Probe stellen.",
"",
"Für Entwickler in großen Projekten ist es nicht ungewöhnlich ihre Arbeit in Feature Branches (von `master` abgeleitet) zu erledigen und dann diese Inhalte zu reintegrieren, wenn sie fertig sind. Das ist ähnlich dem vorherigen Level (in dem ein Feature Branch auf den Server geschoben wird), nur mit einem zusätzlichen Schritt.",
"Für Entwickler in großen Projekten ist es nicht ungewöhnlich ihre Arbeit in Feature Branches (von `main` abgeleitet) zu erledigen und dann diese Inhalte zu reintegrieren, wenn sie fertig sind. Das ist ähnlich dem vorherigen Level (in dem ein Feature Branch auf den Server geschoben wird), nur mit einem zusätzlichen Schritt.",
"",
"Einige Entwickler pushen und pullen nur auf dem `master` -- dadurch ist `master` immer aktuell zu seinem Gegenstück auf dem Server (`o/master`).",
"Einige Entwickler pushen und pullen nur auf dem `main` -- dadurch ist `main` immer aktuell zu seinem Gegenstück auf dem Server (`o/main`).",
"",
"Für diesen Ablauf werden wir also zwei Dinge kombinieren:",
"",
"* einen Feature Branch in `master` reintegrieren und",
"* einen Feature Branch in `main` reintegrieren und",
"* vom entfernten Server pushen und pullen."
]
}
@ -434,7 +434,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Schauen wir uns zur Erinnerung schnell noch mal an wie man den `master` aktualisiert und seine Commits pusht."
"Schauen wir uns zur Erinnerung schnell noch mal an, wie man den `main` aktualisiert und seine Commits pusht."
],
"afterMarkdowns": [
"Wir haben hier zwei Befehle ausgeführt, die:",
@ -472,13 +472,13 @@ exports.level = {
"",
"既然你应该很熟悉 fetch、pull、push 了，现在我们要通过一个新的工作流来测试你的这些技能。",
"",
"在大型项目中开发人员通常会在（从 `master` 上分出来的）特性分支上工作，工作完成后只做一次集成。这跟前面课程的描述很相像（把 side 分支推送到远程仓库），不过本节我们会深入一些.",
"在大型项目中开发人员通常会在（从 `main` 上分出来的）特性分支上工作，工作完成后只做一次集成。这跟前面课程的描述很相像（把 side 分支推送到远程仓库），不过本节我们会深入一些.",
"",
"但是有些开发人员只在 master 上做 push、pull —— 这样的话 master 总是最新的，始终与远程分支 (o/master) 保持一致。",
"但是有些开发人员只在 main 上做 push、pull —— 这样的话 main 总是最新的，始终与远程分支 (o/main) 保持一致。",
"",
"对于接下来这个工作流，我们集成了两个步骤：",
"",
"* 将特性分支集成到 `master` 上",
"* 将特性分支集成到 `main` 上",
"* 推送并更新远程分支"
]
}
@ -487,7 +487,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"让我们看看如何快速的更新 `master` 分支并推送到远程。"
"让我们看看如何快速的更新 `main` 分支并推送到远程。"
],
"afterMarkdowns": [
"我们执行了两个命令: ",
@ -525,13 +525,13 @@ exports.level = {
"",
"Теперь, когда вы умело владеете командами fetch, pull и push, давайте применим эти навыки в сочетании с новым рабочим процессом (он же workflow).",
"",
"Среди разработчиков, вовлечённых в большой проект, довольно распространённ приём — выполнять всю свою работу в так называемых фича-бранчах (вне `master`). А затем, как только работа выполнена, разработчик интегрирует всё, что было им сделано. Всё это, за исключением одного шага, похоже на предыдущий урок (там, где мы закачивали ветки на удалённый репозиторий)",
"Среди разработчиков, вовлечённых в большой проект, довольно распространённ приём — выполнять всю свою работу в так называемых фича-бранчах (вне `main`). А затем, как только работа выполнена, разработчик интегрирует всё, что было им сделано. Всё это, за исключением одного шага, похоже на предыдущий урок (там, где мы закачивали ветки на удалённый репозиторий)",
"",
"Ряд разработчиков делают push и pull лишь на локальную ветку `master` - таким образом ветка `master` всегда синхронизирована с тем, что находится на удалённом репозитории (`o/master`).",
"Ряд разработчиков делают push и pull лишь на локальную ветку `main` - таким образом ветка `main` всегда синхронизирована с тем, что находится на удалённом репозитории (`o/main`).",
"",
"Для этого рабочего процесса мы совместили две вещи:",
"",
"* интеграцию фича-бранчей в `master`",
"* интеграцию фича-бранчей в `main`",
"* закачку (push) и скачку (pull) с удалённого репозитория"
]
}
@ -540,7 +540,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Давайте быстренько вспомним, как нам обновить `master` и закачать выполненную работу."
"Давайте быстренько вспомним, как нам обновить `main` и закачать выполненную работу."
],
"afterMarkdowns": [
"Здесь мы выполнили две команды, которые:",
@ -578,13 +578,13 @@ exports.level = {
"",
"今や、あなたは`fetch`、`pull`、`push`を十分に使えるようになったでしょうから、そのスキルを新しい作業の流れで試してみましょう。",
"",
"大きなプロジェクトの開発者にとって、フィーチャーブランチ（`master`を除く）上で全ての作業を行い、完成したら一度でその作業を統合するというような流れが一般的です。これは前のレッスンの内容（他のブランチからリモートにプッシュされるような状況のところが）に似ていますが、ここではもう一歩踏み込んで解説しましょう。",
"大きなプロジェクトの開発者にとって、フィーチャーブランチ（`main`を除く）上で全ての作業を行い、完成したら一度でその作業を統合するというような流れが一般的です。これは前のレッスンの内容（他のブランチからリモートにプッシュされるような状況のところが）に似ていますが、ここではもう一歩踏み込んで解説しましょう。",
"",
"開発者は、`master`ブランチにいるときプッシュとプルしかしません -- `master`は常にリモート(`o/master`）に追従した状態のままにします。",
"開発者は、`main`ブランチにいるときプッシュとプルしかしません -- `main`は常にリモート(`o/main`）に追従した状態のままにします。",
"",
"この作業の流れでは、私たちは二つのことを組み合わせています:",
"",
"* `master`にフィーチャーブランチの作業を統合し、",
"* `main`にフィーチャーブランチの作業を統合し、",
"* リモートへの`push`と`pull`を行う"
]
}
@ -593,7 +593,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"`master`の更新と作業の反映の方法を手早く復習しましょう。"
"`main`の更新と作業の反映の方法を手早く復習しましょう。"
],
"afterMarkdowns": [
"我々はここで二つのコマンドを動かしました:",
@ -631,13 +631,13 @@ exports.level = {
"",
"이제 여러분은 fetch, pull, push하는데에 익숙해졌을겁니다. 연마한 기술들을 새로운 상황에서 시험 해봅시다.",
"",
"개발자들은 주로 큰 프로젝트를 개발할때 작업을 feature 브랜치(=토픽브랜치 / `master`브랜치가 아닌 작업을위해 임시로 만든 브랜치를 말합니다)들에 하고 준비가 되면 그 작업을 통합합니다. 이전 강의와 비슷한 모습인데(사이드 브랜치들을 원격저장소로 push한것), 여기서 한 단계 더 나아가 봅시다. ",
"개발자들은 주로 큰 프로젝트를 개발할때 작업을 feature 브랜치(=토픽브랜치 / `main`브랜치가 아닌 작업을위해 임시로 만든 브랜치를 말합니다)들에 하고 준비가 되면 그 작업을 통합합니다. 이전 강의와 비슷한 모습인데(사이드 브랜치들을 원격저장소로 push한것), 여기서 한 단계 더 나아가 봅시다. ",
"",
"어떤 개발자들은 `master` 브랜치에 있을때만 push와 pull을 수행합니다 -- 이렇게하면 `master`는 항상 원격 브랜치 (`o/master`)의 상태와 항상 최신의 상태로 유지될 수 있습니다.",
"어떤 개발자들은 `main` 브랜치에 있을때만 push와 pull을 수행합니다 -- 이렇게하면 `main`는 항상 원격 브랜치 (`o/main`)의 상태와 항상 최신의 상태로 유지될 수 있습니다.",
"",
"이런 작업흐름은 두가지 작업을 같이하게됩니다 :",
"",
"* feature 브랜치의 작업을 master로 통합하는것과",
"* feature 브랜치의 작업을 main 브랜치로 통합하는것과",
"* 원격저장소에서 push하고 pull하는 작업입니다"
]
}
@ -646,7 +646,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"다음을 보고 `master`를 갱신하고 작업을 push하는 방법을 다시 떠올려봅시다."
"다음을 보고 `main`를 갱신하고 작업을 push하는 방법을 다시 떠올려봅시다."
],
"afterMarkdowns": [
"여기서 우리는 두개의 명령어를 실행 했습니다 :",
@ -684,13 +684,13 @@ exports.level = {
"",
"Тепер, коли ти вже впевнено володієш засобами `pull` та `push`, час перевірити ці знання в новому процесі.",
"",
"Зазвичай розробники працюють над якимось фічами в окремій гілці (не в `master`), а потім, коли роботу закінчено, інтегрують її. Це схоже на попередній урок (де окремі гілки пушили у віддалений репозиторій), але тут буде ще один додатковий крок.",
"Зазвичай розробники працюють над якимось фічами в окремій гілці (не в `main`), а потім, коли роботу закінчено, інтегрують її. Це схоже на попередній урок (де окремі гілки пушили у віддалений репозиторій), але тут буде ще один додатковий крок.",
"",
"Деякі розробники виконують push і pull лише в гілці `master` -- тож `master` завжди буде актуальним і синхронізованим з віддаленою гілкою (`o/master`).",
"Деякі розробники виконують push і pull лише в гілці `main` -- тож `main` завжди буде актуальним і синхронізованим з віддаленою гілкою (`o/main`).",
"",
"Отже для цього процесу ми об'єднуємо дві речі:",
"",
"* інтеграцію гілки з фічею в `master`, і",
"* інтеграцію гілки з фічею в `main`, і",
"* пул та пуш для синхронізації з віддаленим репозиторієм"
]
}
@ -699,7 +699,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Пригадаймо коротко як оновити `master` і запушити свої зміни."
"Пригадаймо коротко як оновити `main` і запушити свої зміни."
],
"afterMarkdowns": [
"Ми виконали дві команди, які:",
@ -737,13 +737,13 @@ exports.level = {
"",
"Giờ thì bạn đã quen thuộc với tìm nạp, kéo và đẩy, bây giờ chúng tôi sẽ kiểm tra kỹ năng của bạn với một quy trình làm việc mới.",
"",
"Trong các dự án lớn, các nhà phát triển thường làm việc trên các nhánh tính năng (được phân nhánh từ `master`) và chỉ thực hiện tích hợp sau khi công việc hoàn thành. Điều này tương tự như mô tả trong bài học trước (đẩy nhánh bên sang kho lưu trữ từ xa), nhưng chúng ta sẽ đi sâu hơn một chút trong phần này.",
"Trong các dự án lớn, các nhà phát triển thường làm việc trên các nhánh tính năng (được phân nhánh từ `main`) và chỉ thực hiện tích hợp sau khi công việc hoàn thành. Điều này tương tự như mô tả trong bài học trước (đẩy nhánh bên sang kho lưu trữ từ xa), nhưng chúng ta sẽ đi sâu hơn một chút trong phần này.",
"",
"Một vài nhà phát triển chỉ thực hiện đẩy và kéo khi ở trên nhánh `master` -- như vậy thì nhánh `master` luôn luôn được cập nhật với nhánh từ xa (`o/master`).",
"Một vài nhà phát triển chỉ thực hiện đẩy và kéo khi ở trên nhánh `main` -- như vậy thì nhánh `main` luôn luôn được cập nhật với nhánh từ xa (`o/main`).",
"",
"Vậy nên với quy trình làm việc này chúng tôi đã kết hợp 2 việc:",
"",
"* tích hợp nhánh chức năng lên nhánh `master`, và",
"* tích hợp nhánh chức năng lên nhánh `main`, và",
"* đẩy và kéo từ nhánh từ xa"
]
}
@ -752,7 +752,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Hãy xem qua cách cập nhật nhánh `master` và đẩy lên nhánh từ xa hoạt động như thế nào."
"Hãy xem qua cách cập nhật nhánh `main` và đẩy lên nhánh từ xa hoạt động như thế nào."
],
"afterMarkdowns": [
"Ta thực thi 2 câu lệnh làm việc sau:",
@ -790,13 +790,13 @@ exports.level = {
"",
"Sedaj, ko se počutiš udobno s fetchanjem, pullanjem in pushanjem, preizkusimo ta znanja z novimi primeri.",
"",
"Za razvijalce na velikih projektih je pogosto, da delajo vse svoje stvari na funkcionalnih brancih (ne na `master`) in potem vključijo to delo, ko je končano. To je podobno prejšnjim lekcijam (kjer so bili pushani stranski branchi na oddaljen repo), a tu predstavljamo še en korak.",
"Za razvijalce na velikih projektih je pogosto, da delajo vse svoje stvari na funkcionalnih brancih (ne na `main`) in potem vključijo to delo, ko je končano. To je podobno prejšnjim lekcijam (kjer so bili pushani stranski branchi na oddaljen repo), a tu predstavljamo še en korak.",
"",
"Nekateri razvijaci samo pushajo in pullajo na `master` branchu -- zato `master` vedno ostane posodobljen z oddaljenim masterjem (`o/master`).",
"Nekateri razvijaci samo pushajo in pullajo na `main` branchu -- zato `main` vedno ostane posodobljen z oddaljenim masterjem (`o/main`).",
"",
"Torej za tak primer uporabe, združimo dve stvari:",
"",
"* vključevanje dela funkcionalnih branchev na `master` in",
"* vključevanje dela funkcionalnih branchev na `main` in",
"* pushanje in pullanje iz oddaljenega repota"
]
}
@ -805,7 +805,7 @@ exports.level = {
"type": "GitDemonstrationView",
"options": {
"beforeMarkdowns": [
"Osvežimo si na hitro, kako posodobiti `master` in pushati delo."
"Osvežimo si na hitro, kako posodobiti `main` in pushati delo."
],
"afterMarkdowns": [
"Izvedli smo dva ukaza, ki:",

180
src/levels/remote/remoteBranches.js
View file

@ -1,6 +1,6 @@
exports.level = {
"goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C3\",\"id\":\"master\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C1\"],\"id\":\"C4\"}},\"HEAD\":{\"target\":\"C4\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"solutionCommand": "git commit;git checkout o/master;git commit",
"solutionCommand": "git commit;git checkout o/main;git commit",
"startTree": "{\"branches\":{\"master\":{\"target\":\"C1\",\"id\":\"master\"},\"o/master\":{\"target\":\"C1\",\"id\":\"o/master\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"},\"originTree\":{\"branches\":{\"master\":{\"target\":\"C2\",\"id\":\"master\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}}",
"name": {
"en_US": "Remote Branches",
@ -20,21 +20,21 @@ exports.level = {
"sl_SI": "Oddaljeni Branchi"
},
"hint": {
"en_US": "Pay attention to the ordering -- commit on master first!",
"zh_CN": "注意顺序 —— 先在 master 分支上提交!",
"zh_TW": "注意順序的問題喔！先在 master branch 上面送 commit",
"es_AR": "Prestá atención al orden: ¡commiteá sobre master primero!",
"es_ES": "Presta atención al orden: ¡haz commit sobre master primero!",
"pt_BR": "Preste atenção na ordem: commite no master primeiro!",
"gl" : "Preta atención á orde: fai commit no master primeiro",
"de_DE": "Beachte die Sortierung -- committe zuerst auf dem master!",
"en_US": "Pay attention to the ordering -- commit on main first!",
"zh_CN": "注意顺序 —— 先在 main 分支上提交!",
"zh_TW": "注意順序的問題喔！先在 main branch 上面送 commit",
"es_AR": "Prestá atención al orden: ¡commiteá sobre main primero!",
"es_ES": "Presta atención al orden: ¡haz commit sobre main primero!",
"pt_BR": "Preste atenção na ordem: commite no main primeiro!",
"gl" : "Preta atención á orde: fai commit no main primeiro",
"de_DE": "Beachte die Sortierung -- committe zuerst auf dem main!",
"ja" : "順番に注意 -- まずmasterに対してcommitしましょう",
"fr_FR": "Prêtez attention à l'ordre -- les commits sur master d'abord !",
"ru_RU": "Уделяйте внимание очерёдности -- сперва commit на master",
"ko" : "순서에 주의하세요 -- master에서 먼저 커밋하세요!",
"fr_FR": "Prêtez attention à l'ordre -- les commits sur main d'abord !",
"ru_RU": "Уделяйте внимание очерёдности -- сперва commit на main",
"ko" : "순서에 주의하세요: main 브랜치 에서 먼저 커밋하세요!",
"uk" : "Звертайте увагу на послідовність -- спочатку коміт в мастер!",
"vi" : "Chú ý đến thứ tự -- commit trên nhánh master trước!",
"sl_SI": "Bodi pozoren na vrsti red -- commitaj najprej na master!"
"vi" : "Chú ý đến thứ tự -- commit trên nhánh main trước!",
"sl_SI": "Bodi pozoren na vrsti red -- commitaj najprej na main!"
},
"startDialog": {
"en_US": {
@ -47,7 +47,7 @@ exports.level = {
"",
"Now that you've seen `git clone` in action, let's dive into what actually changed.",
"",
"The first thing you may have noticed is that a new branch appeared in our local repository called `o/master`. This type of branch is called a _remote_ branch; remote branches have special properties because they serve a unique purpose.",
"The first thing you may have noticed is that a new branch appeared in our local repository called `o/main`. This type of branch is called a _remote_ branch; remote branches have special properties because they serve a unique purpose.",
"",
"Remote branches reflect the _state_ of remote repositories (since you last talked to those remote repositories). They help you understand the difference between your local work and what work is public -- a critical step to take before sharing your work with others.",
"",
@ -65,7 +65,7 @@ exports.level = {
"",
"* `<remote name>/<branch name>`",
"",
"Hence, if you look at a branch named `o/master`, the branch name is `master` and the name of the remote is `o`.",
"Hence, if you look at a branch named `o/main`, the branch name is `main` and the name of the remote is `o`.",
"",
"Most developers actually name their main remote `origin`, not `o`. This is so common that git actually sets up your remote to be named `origin` when you `git clone` a repository.",
"",
@ -82,9 +82,9 @@ exports.level = {
"Lets check out a remote branch and see what happens."
],
"afterMarkdowns": [
"As you can see, git put us into detached `HEAD` mode and then did not update `o/master` when we added a new commit. This is because `o/master` will only update when the remote updates."
"As you can see, git put us into detached `HEAD` mode and then did not update `o/main` when we added a new commit. This is because `o/main` will only update when the remote updates."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -92,7 +92,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"To finish this level, commit once off of `master` and once after checking out `o/master`. This will help drive home how remote branches behave differently, and they only update to reflect the state of the remote."
"To finish this level, commit once off of `main` and once after checking out `o/main`. This will help drive home how remote branches behave differently, and they only update to reflect the state of the remote."
]
}
}
@ -108,7 +108,7 @@ exports.level = {
"",
"Maintenant que nous avons vu `git clone` en action, plongeons dans ce qui a changé.",
"",
"La première chose que vous avez peut-être remarqué est qu'une nouvelle branche est apparue dans votre dépôt local appelée `o/master`. Ce type de branche est appelée une branche _distante_ ; les branches distantes ont des propriétés spécifiques car elles servent à un but précis.",
"La première chose que vous avez peut-être remarqué est qu'une nouvelle branche est apparue dans votre dépôt local appelée `o/main`. Ce type de branche est appelée une branche _distante_ ; les branches distantes ont des propriétés spécifiques car elles servent à un but précis.",
"",
"Les branches distantes reflètent _l'état_ des dépôts distants (depuis la dernière fois où vous avez parlé avec ceux-ci). Elles vous aident à comprendre les différences entre votre travail et le travail public -- une étape critique à effectuer avant de partager son travail avec les autres.",
"",
@ -126,7 +126,7 @@ exports.level = {
"",
"* `<nom dépôt distant>/<nom de la branche>`",
"",
"Donc, si vous regardez une branche nommée `o/master`, le nom de la branche est `master` et le nom du dépôt distant est `o`.",
"Donc, si vous regardez une branche nommée `o/main`, le nom de la branche est `main` et le nom du dépôt distant est `o`.",
"",
"La plupart des développeurs nomment leur principal dépôt distant `origin`, pas `o`. C'est si commun que git configure en fait votre dépôt local pour être nommé `origin` quand vous faîtes un `git clone` du dépôt.",
"",
@ -143,9 +143,9 @@ exports.level = {
"Rendons-nous sur une branche et regardons ce qui se passe."
],
"afterMarkdowns": [
"Comme vous pouvez le voir, git nous a mis dans le mode \"detached\" (cf. `HEAD`) puis n'a pas mis à jour `o/master` quand nous avons ajouté un nouveau commit. C'est parce que `o/master` va se mettre à jour uniquement quand le dépôt distant sera mis à jour."
"Comme vous pouvez le voir, git nous a mis dans le mode \"detached\" (cf. `HEAD`) puis n'a pas mis à jour `o/main` quand nous avons ajouté un nouveau commit. C'est parce que `o/main` va se mettre à jour uniquement quand le dépôt distant sera mis à jour."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -153,7 +153,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Pour finir ce niveau, faîtes un commit en dehors de `master` puis un après vous être rendu dans `o/master`. Cela va nous aider à comprendre la différence de comportement des branches distantes, et le fait qu'elles se mettent à jour uniquement pour refléter l'état du dépôt distant."
"Pour finir ce niveau, faîtes un commit en dehors de `main` puis un après vous être rendu dans `o/main`. Cela va nous aider à comprendre la différence de comportement des branches distantes, et le fait qu'elles se mettent à jour uniquement pour refléter l'état du dépôt distant."
]
}
}
@ -169,7 +169,7 @@ exports.level = {
"",
"Ahora que viste `git clone` en acción, ahondemos en lo que realmente cambió.",
"",
"Lo primero que habrás notado es que apareció una nueva rama en tu repositorio local llamada `o/master`. A este tipo de ramas se las llama ramas _remotas_. Las ramas remotas tienen propiedades especiales porque sirven un propósito específico.",
"Lo primero que habrás notado es que apareció una nueva rama en tu repositorio local llamada `o/main`. A este tipo de ramas se las llama ramas _remotas_. Las ramas remotas tienen propiedades especiales porque sirven un propósito específico.",
"",
"Las ramas remotas reflejan el _estado_ de los repositorios remotos (cómo estaban la última vez que hablaste con ellos). Te ayudan a entender las diferencias entre tu trabajo local y el trabajo que ya está publicado - un paso crítico antes de compartir tu trabajo con los demás.",
"",
@ -187,7 +187,7 @@ exports.level = {
"",
"* `<nombre del remoto>/<nombre de la rama>`",
"",
"Entonces, si mirás una rama llamada `o/master`, el nombre de la rama es `master`, y el nombre del remoto es `o`.",
"Entonces, si mirás una rama llamada `o/main`, el nombre de la rama es `main`, y el nombre del remoto es `o`.",
"",
"La mayoría de los desarrolladores llaman `origin` a su remoto en lugar de `o`. Esto es tan común que git efectivamente crea tu remoto llamándolo `origin` cuando hacés `git clone` de un repositorio.",
"",
@ -204,9 +204,9 @@ exports.level = {
"Checkouteemos una rama remota a ver qué pasa."
],
"afterMarkdowns": [
"Como ves, git nos puso en el modo detached `HEAD` y no actualizó `o/master` cuando creamos un nuevo commit. Esto es porque `o/master` sólo va a actualizarse cuando el remoto se actualice."
"Como ves, git nos puso en el modo detached `HEAD` y no actualizó `o/main` cuando creamos un nuevo commit. Esto es porque `o/main` sólo va a actualizarse cuando el remoto se actualice."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -214,7 +214,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nivel, commiteá una vez sobre `master` y una después de checkoutear `o/master`. Esto te va a ayudar a caer en cómo las ramas remotas funcionan distinto, y que sólo se actualizan para reflejar el estado del remoto."
"Para completar este nivel, commiteá una vez sobre `main` y una después de checkoutear `o/main`. Esto te va a ayudar a caer en cómo las ramas remotas funcionan distinto, y que sólo se actualizan para reflejar el estado del remoto."
]
}
}
@ -230,7 +230,7 @@ exports.level = {
"",
"Ahora que viste `git clone` en acción, ahondemos en lo que realmente cambió.",
"",
"Lo primero que habrás notado es que apareció una nueva rama en tu repositorio local llamada `o/master`. A este tipo de ramas se las llama ramas _remotas_. Las ramas remotas tienen propiedades especiales porque sirven un propósito específico.",
"Lo primero que habrás notado es que apareció una nueva rama en tu repositorio local llamada `o/main`. A este tipo de ramas se las llama ramas _remotas_. Las ramas remotas tienen propiedades especiales porque sirven un propósito específico.",
"",
"Las ramas remotas reflejan el _estado_ de los repositorios remotos (cómo estaban la última vez que hablaste con ellos). Te ayudan a entender las diferencias entre tu trabajo local y el trabajo que ya está publicado - un paso crítico antes de compartir tu trabajo con los demás.",
"",
@ -248,7 +248,7 @@ exports.level = {
"",
"* `<nombre del remoto>/<nombre de la rama>`",
"",
"Entonces, si observas una rama llamada `o/master`, el nombre de la rama es `master`, y el nombre del remoto es `o`.",
"Entonces, si observas una rama llamada `o/main`, el nombre de la rama es `main`, y el nombre del remoto es `o`.",
"",
"La mayoría de los desarrolladores llaman `origin` a su remoto en lugar de `o`. Esto es tan común que git efectivamente crea tu remoto llamándolo `origin` cuando haces `git clone` de un repositorio.",
"",
@ -265,9 +265,9 @@ exports.level = {
"Hagamos checkout sobre una rama remota a ver qué pasa."
],
"afterMarkdowns": [
"Como ves, git nos puso en el modo detached `HEAD` y no actualizó `o/master` cuando creamos un nuevo commit. Esto ocurre porque `o/master` sólo va a actualizarse cuando el remoto se actualice."
"Como ves, git nos puso en el modo detached `HEAD` y no actualizó `o/main` cuando creamos un nuevo commit. Esto ocurre porque `o/main` sólo va a actualizarse cuando el remoto se actualice."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -275,7 +275,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nivel, haz commit una vez sobre `master` y otra vez después de checkoutear `o/master`. Esto te va a ayudar a aprender cómo las ramas remotas funcionan distinto, y que sólo se actualizan para reflejar el estado del remoto."
"Para completar este nivel, haz commit una vez sobre `main` y otra vez después de checkoutear `o/main`. Esto te va a ayudar a aprender cómo las ramas remotas funcionan distinto, y que sólo se actualizan para reflejar el estado del remoto."
]
}
}
@ -291,7 +291,7 @@ exports.level = {
"",
"Agora que vimos o `git clone` em ação, vamos estudar aquilo que realmente mudou.",
"",
"A primeira coisa que você pode ter percebido é que um novo ramo chamado `o/master` aparece no nosso repositório local. Esse tipo de ramo é chamado de ramo _remoto_; ramos remotos possuem propriedades especiais pois eles servem a um propósito único.",
"A primeira coisa que você pode ter percebido é que um novo ramo chamado `o/main` aparece no nosso repositório local. Esse tipo de ramo é chamado de ramo _remoto_; ramos remotos possuem propriedades especiais pois eles servem a um propósito único.",
"",
"Ramos remotos refletem o _estado_ de repositórios remotos (desde a última vez na qual você falou com eles). Eles ajudam a entender as diferenças entre o trabalho local e o trabalho atualmente público -- um passo crítico a ser dado antes de compartilhar seu trabalho com os outros.",
"",
@ -309,7 +309,7 @@ exports.level = {
"",
"* `<nome do repositório remoto>/<nome do ramo>`",
"",
"Então, se o ramo remoto é chamado `o/master`, o nome do ramo é `master` e o nome do repositório remoto é `o`.",
"Então, se o ramo remoto é chamado `o/main`, o nome do ramo é `main` e o nome do repositório remoto é `o`.",
"",
"A maioria dos desenvolvedores na verdade chama o repositório remoto principal de `origin`, e não de `o`. Isso é tão comum que o Git define por padrão o nome `origin` para o repositório remoto quando você usa o comando `git clone` para clonar um repositório.",
"",
@ -326,9 +326,9 @@ exports.level = {
"Vamos fazer checkout de um ramo remoto e ver o que acontece."
],
"afterMarkdowns": [
"Como você pode ver, o Git nos colocou no modo \"Detached HEAD\", e não atualizou o `o/master` quando adicionamos um novo commit. Isso é porque o `o/master` só será atualizado quando o repositório remoto for atualizado."
"Como você pode ver, o Git nos colocou no modo \"Detached HEAD\", e não atualizou o `o/main` quando adicionamos um novo commit. Isso é porque o `o/main` só será atualizado quando o repositório remoto for atualizado."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -336,7 +336,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nível, commite uma vez em `master`, e outra vez depois de fazer checkout em `o/master`. Isso vai ajudá-lo a sentir como os ramos remotos se comportam de forma diferente, e como eles apenas se atualizam para refletir o estado do repositório remoto."
"Para completar este nível, commite uma vez em `main`, e outra vez depois de fazer checkout em `o/main`. Isso vai ajudá-lo a sentir como os ramos remotos se comportam de forma diferente, e como eles apenas se atualizam para refletir o estado do repositório remoto."
]
}
}
@ -352,7 +352,7 @@ exports.level = {
"",
"Agora que viches `git clone` en acción, mergullémonos no que realmente mudou.",
"",
"O primeiro que notarías é que apareceu unha nova rama no teu repositorio local chamada `o/master`. A este tipo de ramas chámaselle ramas _remotas_. As ramas remotas teñén propiedades especiais porque serven para un propósito específico.",
"O primeiro que notarías é que apareceu unha nova rama no teu repositorio local chamada `o/main`. A este tipo de ramas chámaselle ramas _remotas_. As ramas remotas teñén propiedades especiais porque serven para un propósito específico.",
"",
"As ramas remotas reflexan o _estado_ dos repositorios remotos (como estaban á última vez que falaches con eles). Axúdante a entender as diferencias entre o teu traballo local e o teu traballo que xa está publicado - un paso crítico antes de compartir o teu traballo cos demáis.",
"",
@ -370,7 +370,7 @@ exports.level = {
"",
"* `<nome do remoto>/<nome da rama>`",
"",
"Entonces, se miras unha rama chamada `o/master`, o nome da rama é `master`, e o nome do remoto é `o`.",
"Entonces, se miras unha rama chamada `o/main`, o nome da rama é `main`, e o nome do remoto é `o`.",
"",
"A maioría dos desenvolvedores chaman `origin` ó seu remoto no lugar de `o`. Esto é tan común que git efectivamente crea o teu remoto chamandoo `origin` cando fas `git clone` dun repositorio.",
"",
@ -389,7 +389,7 @@ exports.level = {
"afterMarkdowns": [
"Como ves, git púxonos no modo detached `HEAD` e non actualizou `o/mater` cando creamos un novo commit. Esto é porque `o/mater` só vai actualizarse cando o remoto se actualice."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -397,7 +397,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Para completar este nivel, fai commit unha vez sobre `mater` e despois de facer o checkout a `o/master`. Esto vaite axudar a entender cómo funcionan as ramas remotas, e que só se actualizan para reflexar o estado do remoto."
"Para completar este nivel, fai commit unha vez sobre `mater` e despois de facer o checkout a `o/main`. Esto vaite axudar a entender cómo funcionan as ramas remotas, e que só se actualizan para reflexar o estado do remoto."
]
}
}
@ -413,7 +413,7 @@ exports.level = {
"",
"現在你已經知道 `git clone` 在幹嘛了，讓我們仔細看看到底發生了什麼事。",
"",
"你首先看到的是在你的本地端（local repository）出現了一個新的 branch 叫作 `o/master`，這種型態的 branch 叫作 remote branch （遠端分支），因為特殊的需求，因此 remote branch 有特殊的性質。",
"你首先看到的是在你的本地端（local repository）出現了一個新的 branch 叫作 `o/main`，這種型態的 branch 叫作 remote branch （遠端分支），因為特殊的需求，因此 remote branch 有特殊的性質。",
"",
"remote branch 反應了 remote repository 的狀態（因為你最後接觸的是這些 remote repository），最重要的是，在你想要分享你的 commit 給其他人時，你必須知道你現在的 commit 跟 remote repository 有哪些不同，而 remote branch 的狀態就是在告訴你這些資訊。",
"",
@ -431,7 +431,7 @@ exports.level = {
"",
"* `<remote 名稱>/<branch 名稱>`",
"",
"因此，當你看到一個 branch 叫做 `o/master`，就表示這個 branch 叫做 master，而且這個 remote 的名稱叫作 `o`。",
"因此，當你看到一個 branch 叫做 `o/main`，就表示這個 branch 叫做 main，而且這個 remote 的名稱叫作 `o`。",
"",
"很多程式設計師實際上會把他們的 remote 命名為 `origin`，而不是 `o`，這在 git 是很常見的事情，因為當你使用 `git clone` 時，git 會自動把你的 remote 命名為 `origin`。",
"",
@ -448,9 +448,9 @@ exports.level = {
"讓我們移動到（checkout）一個 remote branch 並且看一下會發生什麼事情"
],
"afterMarkdowns": [
"就像你看到的， git 讓我們進到 detached `HEAD` 狀態，同時，當我們加入一個新的 commit 時，`o/master` 都沒有更新，這是因為只有當 remote 更新的時候，`o/master` 才會更新。"
"就像你看到的， git 讓我們進到 detached `HEAD` 狀態，同時，當我們加入一個新的 commit 時，`o/main` 都沒有更新，這是因為只有當 remote 更新的時候，`o/main` 才會更新。"
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -458,7 +458,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"要完成這一關，先在 master branch 上面做一次 commit，再移動到 `o/master` 上做一次 commit，這有助於我們了解到 remote branch 的不同，它們只會反應 remote 的狀態。"
"要完成這一關，先在 main branch 上面做一次 commit，再移動到 `o/main` 上做一次 commit，這有助於我們了解到 remote branch 的不同，它們只會反應 remote 的狀態。"
]
}
}
@ -474,9 +474,9 @@ exports.level = {
"",
"Nun da du `git clone` in Aktion gesehen hast, lass uns tiefer in die Materie eintauchen.",
"",
"Das erste, was dir wahrscheinlich aufgefallen ist, ist dass ein neuer Branch in unserem lokalen Repository aufgetaucht ist, namens `o/master`. Diese Art von Branch nennt sich _Remote_ Branch; er hat besondere Eigenschaften, weil er einem bestimmten Zweck dient.",
"Dir ist wahrscheinlich als Erstes aufgefallen, dass ein neuer Branch namens `o/main` in unserem lokalen Repository aufgetaucht ist. Diese Art von Branch nennt sich _Remote_ Branch; er hat besondere Eigenschaften, weil er einem bestimmten Zweck dient.",
"",
"Ein Remote Branch bildet den Zustand des entsprechenden Branch in einem entfernten Repository ab (dem Zustand in dem der Branch war, als du das letzte mal das entfernte Repository angesprochen hast). Er hilft dir, den Unterschied zwischen deinem lokalen Branch und dem Gegenstück auf dem Server zu sehen -- eine nötige Information, bevor du deine Arbeit mit anderen teilen kannst.",
"Ein Remote Branch bildet den Zustand des entsprechenden Branch in einem entfernten Repository ab (dem Zustand in dem der Branch war, als du das letzte Mal das entfernte Repository angesprochen hast). Er hilft dir, den Unterschied zwischen deinem lokalen Branch und dem Gegenstück auf dem Server zu sehen -- eine nötige Information, bevor du deine Arbeit mit anderen teilen kannst.",
"",
"Remote Branches besitzen die besondere Eigenschaft dein Repository in den \"Detached `HEAD`\" Zustand zu versetzen, wenn du sie auscheckst. Git macht das absichtlich so, denn du kannst nicht direkt auf Remote Branches arbeiten; du musst auf Kopien von ihnen arbeiten und deine Änderungen von dort auf den entfernten Server schieben (wonach der Remote Branch dann auch bei dir aktualisiert wird)."
]
@ -492,11 +492,11 @@ exports.level = {
"",
"* `<Name des Remote>/<Name des Branches>`",
"",
"Wenn du also einen Remote Branch namens `o/master` hast, ist es eine Abbildung des Branches `master` auf dem Server, der in deinem Repository als `o` bekannt ist.",
"Wenn du also einen Remote Branch namens `o/main` hast, ist es eine Abbildung des Branches `main` auf dem Server, der in deinem Repository als `o` bekannt ist.",
"",
"Die meisten Entwickler nennen das Haupt-Remote tatsächlich `origin` und nicht `o`. Das ist so verbreitet, dass Git den entfernten Server von dem man ein `git clone` macht tatsächlich als `origin` im Clone speichert.",
"Die meisten Entwickler nennen das Haupt-Remote eigentlich `origin` und nicht `o`. Das ist so verbreitet, dass Git den entfernten Server, von dem man ein `git clone` macht, standardmäßig als `origin` im Clone speichert.",
"",
"Leider passt der ganze Name, `origin`, nicht in unsere Darstellung, deshalb benutzen wir hier kurz `o`. :( Merk dir einfach: wenn du echtes Git benutzt werden die Remotes meistens `origin` heißen!",
"Leider passt der ganze Name, `origin`, nicht in unsere Darstellung, deshalb benutzen wir hier kurz `o`. :( Merk dir einfach: wenn du echtes Git benutzt, werden die Remotes meistens `origin` heißen!",
"",
"So, das war eine Menge zu verdauen, schauen wir uns das in Aktion an."
]
@ -509,9 +509,9 @@ exports.level = {
"Checken wir mal einen Remote Branch aus und schauen was passiert."
],
"afterMarkdowns": [
"Wie du siehst setzt uns Git in den \"Detached `HEAD`\" Modus und aktualisiert dann nach dem Commit nicht den Branch `o/master`. Das liegt daran, dass der Remote Branch nur aktualisiert wird, wenn sich der entsprechende Branch auf dem Remote verändert."
"Wie du siehst setzt uns Git in den \"Detached `HEAD`\" Modus und aktualisiert dann nach dem Commit nicht den Branch `o/main`. Das liegt daran, dass der Remote Branch nur aktualisiert wird, wenn sich der entsprechende Branch auf dem Remote verändert."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -519,7 +519,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Um diesen Level zu bewältigen musst du einen Commit in `master` machen und einen nachdem du `o/master` ausgecheckt hast. Das illustriert noch einmal wie sich Branches und Remote Branches unterschiedlich verhalten und dass letztere sich nur verändern, wenn sich ihr Zustand auf dem entfernten Server ändert."
"Um diesen Level zu bewältigen musst du einen Commit in `main` machen und einen nachdem du `o/main` ausgecheckt hast. Das illustriert noch einmal wie sich Branches und Remote Branches unterschiedlich verhalten und dass letztere sich nur verändern, wenn sich ihr Zustand auf dem entfernten Server ändert."
]
}
}
@ -535,7 +535,7 @@ exports.level = {
"",
"既然你已经看过 `git clone` 命令了，咱们深入地看一下发生了什么。",
"",
"你可能注意到的第一个事就是在我们的本地仓库多了一个名为 `o/master` 的分支, 这种类型的分支就叫**远程**分支。由于远程分支的特性导致其拥有一些特殊属性。",
"你可能注意到的第一个事就是在我们的本地仓库多了一个名为 `o/main` 的分支, 这种类型的分支就叫**远程**分支。由于远程分支的特性导致其拥有一些特殊属性。",
"",
"远程分支反映了远程仓库(在你上次和它通信时)的**状态**。这会有助于你理解本地的工作与公共工作的差别 —— 这是你与别人分享工作成果前至关重要的一步.",
"",
@ -553,7 +553,7 @@ exports.level = {
"",
"* `<remote name>/<branch name>`",
"",
"因此，如果你看到一个名为 `o/master` 的分支，那么这个分支就叫 `master`，远程仓库的名称就是 `o`。",
"因此，如果你看到一个名为 `o/main` 的分支，那么这个分支就叫 `main`，远程仓库的名称就是 `o`。",
"",
"大多数的开发人员会将它们主要的远程仓库命名为 `origin`，并不是 `o`。这是因为当你用 `git clone` 某个仓库时，Git 已经帮你把远程仓库的名称设置为 `origin` 了",
"",
@ -570,9 +570,9 @@ exports.level = {
"如果检出远程分支会怎么样呢？"
],
"afterMarkdowns": [
"正如你所见，Git 变成了分离 HEAD 状态，当添加新的提交时 `o/master` 也不会更新。这是因为 `o/master` 只有在远程仓库中相应的分支更新了以后才会更新。"
"正如你所见，Git 变成了分离 HEAD 状态，当添加新的提交时 `o/main` 也不会更新。这是因为 `o/main` 只有在远程仓库中相应的分支更新了以后才会更新。"
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -580,7 +580,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"要通过本关，在 `master` 分支上做一次提交；然后检出 `o/master`，再做一提交。这有助于你理解远程分支的不同，他们的更新只是反映了远程的状态。"
"要通过本关，在 `main` 分支上做一次提交；然后检出 `o/main`，再做一提交。这有助于你理解远程分支的不同，他们的更新只是反映了远程的状态。"
]
}
}
@ -614,7 +614,7 @@ exports.level = {
"",
"* `<リモート名>/<ブランチ名>`",
"",
"これに基づいて、`o/master`と名付けられたブランチを見てみると、`master`はブランチの名前、`o`はリモートの名前であることが分かります。",
"これに基づいて、`o/main`と名付けられたブランチを見てみると、`main`はブランチの名前、`o`はリモートの名前であることが分かります。",
"",
"多くの開発者は、実際にはメインのリモート名として`o`ではなく`origin`を使います。これは一般的には、Gitが`git clone`した時に`origin`という名前をリモートに付与するためです。",
"",
@ -631,9 +631,9 @@ exports.level = {
"リモートブランチをチェックアウトすると何が起こるかを見てみましょう"
],
"afterMarkdowns": [
"見ていた通り、`o/master`に移ってから新しいコミットをしても`HEAD`が分離状態になり`o/master`は更新されていません。これは、`o/master`がリモートの更新時のみ更新されるからです。"
"見ていた通り、`o/main`に移ってから新しいコミットをしても`HEAD`が分離状態になり`o/main`は更新されていません。これは、`o/main`がリモートの更新時のみ更新されるからです。"
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -641,7 +641,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"このレベルを終えるには、まずコミットを`master`に一回行い、その後`o/master`にチェックアウトしてからもう一度コミットをします。これは、リモートブランチがどれほど違った動きをするか、そしてリモートブランチがリモートの状態を反映する時しか更新されないことを理解するのに役立つでしょう。"
"このレベルを終えるには、まずコミットを`main`に一回行い、その後`o/main`にチェックアウトしてからもう一度コミットをします。これは、リモートブランチがどれほど違った動きをするか、そしてリモートブランチがリモートの状態を反映する時しか更新されないことを理解するのに役立つでしょう。"
]
}
}
@ -657,7 +657,7 @@ exports.level = {
"",
"Теперь, когда вы уже увидели `git clone` в действии, давайте углубимся в детали и посмотрим что же на самом деле изменилось.",
"",
"Во-первых, вы должны были заметить, что у нас в локальном репозитории появилась новая ветка с именем `o/master`. Такой тип ветки называется _удалённой_ веткой. Поскольку удалённые ветки играют важную и уникальную роль, они обладают рядом специальных свойств.",
"Во-первых, вы должны были заметить, что у нас в локальном репозитории появилась новая ветка с именем `o/main`. Такой тип ветки называется _удалённой_ веткой. Поскольку удалённые ветки играют важную и уникальную роль, они обладают рядом специальных свойств.",
"",
"Удалённые ветки отражают _состояние_ удалённых репозиториев (с того момента, как вы обращались к этим удалённым репозиториям в последний раз). Они позволяют вам отслеживать и видеть разницу между вашими локальными наработками и тем, что было сделано другими участниками - важный шаг, который необходимо делать, прежде чем делиться своими наработками с другими.",
"",
@ -675,7 +675,7 @@ exports.level = {
"",
"* `<удалённый репозиторий>/<имя ветки>`",
"",
"Следовательно, если вы взглянете на имя ветки `o/master`, то здесь `master` - это имя ветки, а `o` - это имя удалённого репозитория.",
"Следовательно, если вы взглянете на имя ветки `o/main`, то здесь `main` - это имя ветки, а `o` - это имя удалённого репозитория.",
"",
"Большинство разработчиков именуют свои главные удалённые репозитории не как `o`, а как `origin`. Также общепринятым является именование удалённого репозитория как `origin`, когда вы клонируете репозиторий командой `git clone`.",
"",
@ -692,9 +692,9 @@ exports.level = {
"Давайте извлечём (check out) удалённую ветку и посмотрим что произойдёт"
],
"afterMarkdowns": [
"Как вы можете видеть, git отделил (detached) `HEAD` и не обновил `o/master`, когда мы добавили новый коммит. Всё потому, что `o/master` обновится тогда и только тогда, когда обновится сам удалённый репозиторий."
"Как вы можете видеть, git отделил (detached) `HEAD` и не обновил `o/main`, когда мы добавили новый коммит. Всё потому, что `o/main` обновится тогда и только тогда, когда обновится сам удалённый репозиторий."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -702,7 +702,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Для завершения уровня выполните коммит единожды на `master`, а затем на `o/master` (предварительно переключившись на эту ветку). Это наглядно продемонстрирует поведение удалённых веток, а также покажет, как изменения влияют на состояние удалённых репозиториев."
"Для завершения уровня выполните коммит единожды на `main`, а затем на `o/main` (предварительно переключившись на эту ветку). Это наглядно продемонстрирует поведение удалённых веток, а также покажет, как изменения влияют на состояние удалённых репозиториев."
]
}
}
@ -718,7 +718,7 @@ exports.level = {
"",
"이제 `git clone`을 직접 확인 해 보셨습니다. 이제 무엇이 변했는지 살펴 봅시다.",
"",
"가장 먼저 알아차릴만한 변화는 우리의 로컬 저장소에 `o/master`라고하는 새 브랜치가 생긴겁니다. 이런 종류의 브랜치는 _원격_브랜치라고 불립니다; 원격 브랜치는 특정한 목적을 제공하기 때문에 특별한 속성들이 있습니다.",
"가장 먼저 알아차릴만한 변화는 우리의 로컬 저장소에 `o/main`라고하는 새 브랜치가 생긴겁니다. 이런 종류의 브랜치는 _원격_브랜치라고 불립니다; 원격 브랜치는 특정한 목적을 제공하기 때문에 특별한 속성들이 있습니다.",
"",
"원격 브랜치는 원격 저장소의 _상태_를 반영합니다(가장 최근 원격 원격저장소와 작업을 했을때를 기준으로). 원격 브랜치는 로컬에서의 작업과 공개적으로 되고있는 작업의 차이를 이해하는데 도와줍니다 -- 다른 사람들과 작업을 공유하기전에 반드시해야할 과정이죠.",
"",
@ -736,7 +736,7 @@ exports.level = {
"",
"* `<remote name>/<branch name>`",
"",
"이런 이유로, 만약 `o/master`라는 이름의 브랜치를 보게되면, 브랜치의 이름은 `master`이고 원격 저장소의 이름은 `o`인겁니다.",
"이런 이유로, 만약 `o/main`라는 이름의 브랜치를 보게되면, 브랜치의 이름은 `main`이고 원격 저장소의 이름은 `o`인겁니다.",
"",
"대부분의 개발자들은 자신의 주 원격 저장소를 `o`가 아닌 `origin`이라고 짓습니다. 사실 보통 다 이렇게 쓰기 때문에 git은 저장소를 `git clone`하게 되면 원격 저장소의 이름을 `origin`이라고 자동으로 설정해놓습니다.",
"",
@ -753,9 +753,9 @@ exports.level = {
"원격 브랜치를 체크아웃하고 무엇이 일어나는지 확인해 봅시다"
],
"afterMarkdowns": [
"보이는것 처럼, git은 우리를 분리된 `HEAD` 모드로 만들고 새로운 커밋을 추가해도 `o/master`를 갱신하지 않습니다. 이것은 `o/master`가 원격 저장소가 갱신될때만 갱신되기 때문입니다."
"보이는것 처럼, git은 우리를 분리된 `HEAD` 모드로 만들고 새로운 커밋을 추가해도 `o/main`를 갱신하지 않습니다. 이것은 `o/main`가 원격 저장소가 갱신될때만 갱신되기 때문입니다."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -763,7 +763,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"다음 레벨로 가기 위해서는 `master`에서 한번 커밋하고 `o/master`를 체크아웃 하고 다시 한번 커밋을 하세요. 이를 통해서 원격 브랜치가 어떻게 다르게 작동하는지 알아보고, 원격 브랜치는 원격 저장소의 상태를 반영하기만 한다는것을 이해해 봅시다."
"다음 레벨로 가기 위해서는 `main`에서 한번 커밋하고 `o/main`를 체크아웃 하고 다시 한번 커밋을 하세요. 이를 통해서 원격 브랜치가 어떻게 다르게 작동하는지 알아보고, 원격 브랜치는 원격 저장소의 상태를 반영하기만 한다는것을 이해해 봅시다."
]
}
}
@ -779,7 +779,7 @@ exports.level = {
"",
"Тепер, коли ти познайомився з `git clone` в дії, розгляньмо деталі й подивімося, що дійсно змінилося.",
"",
"Перше, що ти міг помітити -- це те, що з’явився новий бранч з назвою `o/master`. Такі гілки називаються _віддаленими_ (remote); віддалені гілки в гіт відіграють в певному сенсі унікальну роль, тому в них є деякі спеціальні властивості, непритаманні іншим гілкам.",
"Перше, що ти міг помітити -- це те, що з’явився новий бранч з назвою `o/main`. Такі гілки називаються _віддаленими_ (remote); віддалені гілки в гіт відіграють в певному сенсі унікальну роль, тому в них є деякі спеціальні властивості, непритаманні іншим гілкам.",
"",
"Віддалені гілки відображають _стан_ віддалених репозиторіїв (точніше, стан віддаленого репо на момент останньої синхронізації). Вони дозволяють відрізняти та відслідковувати локальні зміни та зміни інших учасників, що є дуже важливим для успішної синхронізації роботи між різними репозиторіями.",
"",
@ -797,7 +797,7 @@ exports.level = {
"",
"* `<ім’я віддаленого репо>/<ім’я гілки>`",
"",
"Отже, якщо розглянути гілку з назвою `o/master`, то ім’я гілки -- це `master` а ім’я віддаленого репозиторію -- це `o`.",
"Отже, якщо розглянути гілку з назвою `o/main`, то ім’я гілки -- це `main` а ім’я віддаленого репозиторію -- це `o`.",
"",
"Більшість розробників насправді називають ім’я головного віддаленого репозиторію `origin` (початок), а не `o`. Це настільки поширена практика, що гіт автоматично називає віддалений репозиторій `origin` коли ти його клонуєш.",
"",
@ -814,9 +814,9 @@ exports.level = {
"Зробімо checkout віддаленої гілки й подивімось, що буде"
],
"afterMarkdowns": [
"Як бачиш, git перейшов в стан `detached HEAD` і не оновив `o/master` коли ми зробили новий коміт. Це тому, що `o/master` буде оновлено лише тоді, коли буде оновлено віддалений репозиторій."
"Як бачиш, git перейшов в стан `detached HEAD` і не оновив `o/main` коли ми зробили новий коміт. Це тому, що `o/main` буде оновлено лише тоді, коли буде оновлено віддалений репозиторій."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -824,7 +824,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Щоб пройти цей рівень, зроби один коміт в `master`, а потім переключись в `o/master` і закомітся ще раз. Це наглядно продемонструє поведінку віддалених гілок, а також покаже як зміни впливають на стан віддаленого репозиторію."
"Щоб пройти цей рівень, зроби один коміт в `main`, а потім переключись в `o/main` і закомітся ще раз. Це наглядно продемонструє поведінку віддалених гілок, а також покаже як зміни впливають на стан віддаленого репозиторію."
]
}
}
@ -840,7 +840,7 @@ exports.level = {
"",
"Giờ bạn đã thấy cách thức hoạt động của `git clone`, cùng xem xét kỹ hơn những gì đã xảy ra.",
"",
"Điều đầu tiên mà có thể bạn để ý là một nhánh mới xuất hiện trong kho chứa địa phương của ta là `o/master`. Loại nhánh này được gọi là nhánh _từ xa_ (_remote_) ; nhánh từ xa có những thuộc tính đặc biệt vì chúng phục vụ những mục đích duy nhất.",
"Điều đầu tiên mà có thể bạn để ý là một nhánh mới xuất hiện trong kho chứa địa phương của ta là `o/main`. Loại nhánh này được gọi là nhánh _từ xa_ (_remote_) ; nhánh từ xa có những thuộc tính đặc biệt vì chúng phục vụ những mục đích duy nhất.",
"",
"Nhánh từ xa phản ánh _trạng thái_ (_state_) của kho chứa từ xa (kể từ lần cuối cùng bạn tương tác với kho chứa từ xa). Chúng giúp bạn hiểu về sự khác biệt giữa công tác trên kho chứa cục bộ với kho chứa từ xa -- một bước quan trọng trước khi chia sẻ công việc của bạn với người khác.",
"",
@ -858,7 +858,7 @@ exports.level = {
"",
"* `<tên kho từ xa>/<tên nhánh>`",
"",
"Do đó, ở trong `o/master` thì `master` là tên nhánh còn `o` là tên kho chứa từ xa.",
"Do đó, ở trong `o/main` thì `main` là tên nhánh còn `o` là tên kho chứa từ xa.",
"",
"Thực tế thì hầu hết các nhà phát triển đặt tên kho chứa từ xa là `origin` chứ không phải `o`. Nó trở thành thông lệ đến nỗi Git đặt tên `origin` cho kho chứa từ xa khi bạn dùng `git clone` để sao chép một kho chứa.",
"",
@ -875,9 +875,9 @@ exports.level = {
"Hãy thử chuyển sang nhánh từ xa xem điểu gì xảy ra."
],
"afterMarkdowns": [
"Như bạn thấy, git đưa ta vào trạng thái `HEAD` và không cập nhật nhánh `o/master` khi ta thêm một commit. Đó là bởi vì `o/master` chỉ cập nhật khi kho chứa từ xa được cập nhật."
"Như bạn thấy, git đưa ta vào trạng thái `HEAD` và không cập nhật nhánh `o/main` khi ta thêm một commit. Đó là bởi vì `o/main` chỉ cập nhật khi kho chứa từ xa được cập nhật."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -885,7 +885,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Để hoàn thành cấp độ này, commit một lần trên `master` và một lần nữa sau khi chuyển sang `o/master`. Điều nãy sẽ giúp ta hiểu cách nhánh từ xa hành xử, chúng chỉ cập nhật để phản ánh trạng thái của kho chứa từ xa."
"Để hoàn thành cấp độ này, commit một lần trên `main` và một lần nữa sau khi chuyển sang `o/main`. Điều nãy sẽ giúp ta hiểu cách nhánh từ xa hành xử, chúng chỉ cập nhật để phản ánh trạng thái của kho chứa từ xa."
]
}
}
@ -901,7 +901,7 @@ exports.level = {
"",
"Sedaj ko smo videli `git clone` v praksi se poglobimo v dejanske spremembe.",
"",
"Prva stvar, ki si jo morda opazil je, da se je pojavil nov branch na našem lokalnem repotu imenovan `o/master`. Temu tipu brancha pravimo _oddaljen_ (remote) branch; oddaljeni branchi imajo posebne lastnosti, ker služijo določenim namenom.",
"Prva stvar, ki si jo morda opazil je, da se je pojavil nov branch na našem lokalnem repotu imenovan `o/main`. Temu tipu brancha pravimo _oddaljen_ (remote) branch; oddaljeni branchi imajo posebne lastnosti, ker služijo določenim namenom.",
"",
"Oddaljeni branchi odražajo _stanje_ oddaljenega repozitorija (od kar si nazadnje komuniciral z oddaljenim repotom). To ti morda pomaga razumeti razliko med tvojim lokalnim delom in delom, ki je javno -- ključni korak, preden deliš svoje delo z ostalimi.",
"",
@ -919,7 +919,7 @@ exports.level = {
"",
"* `<ime oddaljenega repota>/<ime brancha>`",
"",
"Posledično, če pogledamo branch poimenovan `o/master`, je ime brancha `master`, ime oddaljenega repota pa `o`.",
"Posledično, če pogledamo branch poimenovan `o/main`, je ime brancha `main`, ime oddaljenega repota pa `o`.",
"",
"Večina razvijalcev v bistvu poimenuje njihov glavni oddaljeni repozitorij `origin`, ne `o`. To je takoj pogosto, da git ubistvu nastavi tvoj oddaljen repo z imenom `origin` ko izvedeš `git clone` nad repozitorijem.",
"",
@ -936,9 +936,9 @@ exports.level = {
"Checkoutajmo oddaljen branch in poglejmo kaj se zgodi."
],
"afterMarkdowns": [
"Kot lahko vidiš, nas git postavi v stanje ločenega `HEAD-a` in ne posodobi `o/master`, ko dodamo nov commit. To je zato, ker se bo `o/master` posodobil šele, ko se bo posodobil oddaljen repo."
"Kot lahko vidiš, nas git postavi v stanje ločenega `HEAD-a` in ne posodobi `o/main`, ko dodamo nov commit. To je zato, ker se bo `o/main` posodobil šele, ko se bo posodobil oddaljen repo."
],
"command": "git checkout o/master; git commit",
"command": "git checkout o/main; git commit",
"beforeCommand": "git clone"
}
},
@ -946,7 +946,7 @@ exports.level = {
"type": "ModalAlert",
"options": {
"markdowns": [
"Za dokončanje te stopnje, commitaj enkrat iz `master` in enkrat, ko checkoutaš `o/master`. To ti bo pomagalo osvojiti, kako se oddaljeni branchi obnašajo drugače in se posodobijo le da odražajo stanje na oddaljenem repozitoriju."
"Za dokončanje te stopnje, commitaj enkrat iz `main` in enkrat, ko checkoutaš `o/main`. To ti bo pomagalo osvojiti, kako se oddaljeni branchi obnašajo drugače in se posodobijo le da odražajo stanje na oddaljenem repozitoriju."
]
}
}

30
src/levels/remote/sourceNothing.js
View file

@ -69,7 +69,7 @@ exports.level = {
"There, we successfully deleted the `foo` branch on remote by pushing the concept of \"nothing\" to it. That kinda makes sense..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -122,7 +122,7 @@ exports.level = {
"Ici, nous avons brillamment supprimé la branche `foo` du dépôt distant en lui envoyant le concept de \"rien\". Cela paraît à peu près logique..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -175,7 +175,7 @@ exports.level = {
"Ahí está, borramos la rama `foo` exitosamente del remoto pusheándole el concepto de \"nada\". Tiene algo de sentido..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -228,7 +228,7 @@ exports.level = {
"Ahí está, eliminamos la rama `foo` exitosamente del remoto haciendo push con \"nada\". Tiene algo de sentido..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -281,7 +281,7 @@ exports.level = {
"Aqui, excluímos com sucesso o ramo `foo` do repositório remoto por meio de um push de \"coisa nenhuma\" direcionado a ele. Até que faz sentido..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -334,7 +334,7 @@ exports.level = {
"Ahí está, borramos a rama `foo` exitosamente do remoto empurrando o concepto da \"nada\". Ten algo de sentido..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -387,7 +387,7 @@ exports.level = {
"看吧，我們藉由把 source \"留空\"，成功用 `push` 刪除了 `foo` branch，這合理吧..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -440,7 +440,7 @@ exports.level = {
"就是这样子, 我们通过给 push 传空值 source，成功删除了远程仓库中的 `foo` 分支, 这真有意思..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -474,7 +474,7 @@ exports.level = {
"markdowns": [
"### Die Eigentümlichkeiten von `<Quelle>`",
"",
"Git \"missbraucht\" den `<Quelle>`-Parameter in zwei Fällen. Diese rühren daher, dass man technisch gesehen \"nichts\" als gültige `<Quelle>` sowohl für `git push` als auch für `git fetch` angeben kann. Das macht man so:",
"Git \"missbraucht\" den `<Quelle>`-Parameter in zwei Fällen. Dies rührt daher, dass man technisch gesehen \"nichts\" als gültige `<Quelle>` sowohl für `git push` als auch für `git fetch` angeben kann. Das macht man so:",
"",
"* `git push origin :side`",
"* `git fetch origin :bugFix`",
@ -493,7 +493,7 @@ exports.level = {
"Und schon haben wir `foo` erfolgreich auf dem Remote gelöscht, weil wir \"Leere\" darauf geschoben haben. Ist auf seine Weise irgendwie logisch ..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -546,7 +546,7 @@ exports.level = {
"Как видите, мы удалили ветку `foo` в удаленном репозитории, попытавшить протолкнуть(git push) в неё \"ничего\"."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -599,7 +599,7 @@ exports.level = {
"됬습니다, 원격 저장소의 `foo`브랜치를 성공적으로 삭제했습니다. \"없음\"을 push한다는것이 이것을 이뤘습니다. 흠 말이 되는것 같네요 null을 push했어요..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -652,7 +652,7 @@ exports.level = {
"Ось, ми успішно видалили гілку `foo` на віддаленому сервері, запушивши в неї \"ніщо\". Ну, ніби все правильно..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -705,7 +705,7 @@ exports.level = {
"Đó, ta đã xóa thành công nhánh `foo` trên kho chứa từ xa bằng cách đẩy \"không gì cả\" lên nó. Khá là hợp lý..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{
@ -758,7 +758,7 @@ exports.level = {
"Tako, uspešno smo izbrisali `foo` branch na oddaljenem repotu s konceptom pushanja \"ničesar\" nanj. To ima nekako smisel ..."
],
"command": "git push origin :foo",
"beforeCommand": "git clone; git push origin master:foo"
"beforeCommand": "git clone; git push origin main:foo"
}
},
{

610
src/levels/remote/tracking.js
View file

File diff suppressed because it is too large Load diff

7
src/style/main.css
View file

@ -10,7 +10,7 @@ body {
}
html, body {
font-family: Monaco, Courier, monospace;
font-family: Menlo, Monaco, Consolas, 'Droid Sans Mono', monospace;
color: #eee;
}
@ -553,7 +553,7 @@ p.commandLine span.prompt {
#commandLineBar p.command {
margin: 0;
margin-left: 12px;
margin-left: 20px;
}
#commandLineBar #commandTextField {
@ -685,11 +685,12 @@ div.helperBar.show {
-o-transform: translate3d(0,0,0);
-ms-transform: translate3d(0,0,0);
transform: translate3d(0,0,0);
height: 85px;
min-height: 85px;
}
div.helperBar.show.BaseHelperBar {
height: auto;
min-height: auto;
}
#commandLineBar,

18
src/template.index.html
View file

@ -444,14 +444,16 @@
<div id="helperBarMount">
</div>
<!-- lol inline styles -->
<a class="githubLink" href="https://github.com/pcottle/learnGitBranching" target="_blank">
<img width="149" height="149"
style="position: absolute; top: 0; right: 0; border: 0;"
src="assets/forkme_right_darkblue_121621.png"
alt="Fork me on GitHub"
/>
</a>
<a target="_blank" rel="noreferrer noopener" href="https://github.com/pcottle/learnGitBranching" class="github-corner" aria-label="View source on GitHub">
<svg width, height="7vmin" viewBox="0 0 250 250" style="fill:#151513; color:#fff; position: absolute; top: 0; border: 0; right: 0;" aria-hidden="true">
<path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
<path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
<path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path>
</svg>
</a>
<style>
.github-corner:hover .octo-arm{animation:octocat-wave 560ms ease-in-out}@keyframes octocat-wave{0%,100%{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@media (max-width:500px){.github-corner:hover .octo-arm{animation:none}.github-corner .octo-arm{animation:octocat-wave 560ms ease-in-out}}
</style>
<!-- The advantage of github pages: super-easy, simple, slick static hostic.

36
yarn.lock
View file

@ -526,17 +526,17 @@ bindings@^1.5.0:
file-uri-to-path "1.0.0"
bl@^1.2.1:
version "1.2.2"
resolved "https://registry.yarnpkg.com/bl/-/bl-1.2.2.tgz#a160911717103c07410cef63ef51b397c025af9c"
integrity sha512-e8tQYnZodmebYDWGH7KMRvtzKXaJHx3BbilrgZCfvyLUYdKpK1t5PSPmpkny/SgiTSCnjfLW7v5rlONXVFkQEA==
version "1.2.3"
resolved "https://registry.yarnpkg.com/bl/-/bl-1.2.3.tgz#1e8dd80142eac80d7158c9dccc047fb620e035e7"
integrity sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==
dependencies:
readable-stream "^2.3.5"
safe-buffer "^5.1.1"
bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.1.1, bn.js@^4.4.0:
version "4.11.8"
resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.8.tgz#2cde09eb5ee341f484746bb0309b3253b1b1442f"
integrity sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==
version "4.11.9"
resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.9.tgz#26d556829458f9d1e81fc48952493d0ba3507828"
integrity sha512-E6QoYqCKZfgatHTdHzs1RRKP7ip4vvm+EyRUeE2RF0NblwVvb0p6jSVeNTOFxPn26QXN2o6SMfNxKp6kU8zQaw==
brace-expansion@^1.1.7:
version "1.1.11"
@ -1344,9 +1344,9 @@ each-props@^1.3.0:
object.defaults "^1.1.0"
elliptic@^6.0.0:
version "6.5.2"
resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.2.tgz#05c5678d7173c049d8ca433552224a495d0e3762"
integrity sha512-f4x70okzZbIQl/NSRLkI/+tteV/9WqL98zx+SQ69KbXxmVrmjwsNUPn/gYJJ0sHvEak24cZgHIPegRePAtA/xw==
version "6.5.3"
resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.3.tgz#cb59eb2efdaf73a0bd78ccd7015a62ad6e0f93d6"
integrity sha512-IMqzv5wNQf+E6aHeIqATs0tOLeOTwj1QKbRcS3jBbYkl5oLAserA8yJTT7/VyHUYG91PRmPyeQDObKLPpeS4dw==
dependencies:
bn.js "^4.4.0"
brorand "^1.0.1"
@ -2235,9 +2235,9 @@ inherits@2.0.3:
integrity sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=
ini@^1.3.4:
version "1.3.5"
resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.5.tgz#eee25f56db1c9ec6085e0c22778083f596abf927"
integrity sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==
version "1.3.7"
resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.7.tgz#a09363e1911972ea16d7a8851005d84cf09a9a84"
integrity sha512-iKpRpXP+CrP2jyrxvg1kMUpXDyRUFDWurxbnVT1vQPx+Wz9uCYsMIqYuSBLV+PAaZG/d7kRLKRFc9oDMsH+mFQ==
inline-source-map@~0.6.0:
version "0.6.2"
@ -2982,9 +2982,9 @@ lodash.values@~2.4.1:
lodash.keys "~2.4.1"
lodash@^4.12.0, lodash@^4.17.13, lodash@~4.17.11:
version "4.17.15"
resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.15.tgz#b447f6670a0455bbfeedd11392eff330ea097548"
integrity sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==
version "4.17.19"
resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.19.tgz#e48ddedbe30b3321783c5b4301fbd353bc1e4a4b"
integrity sha512-JNvd8XER9GQX0v2qJgsaN/mzFCNA5BRe/j8JN9d+tWyGLSodKQHKFicdwNYzWwI3wjRnaKPsGj1XkBjx/F96DQ==
loose-envify@^1.0.0, loose-envify@^1.1.0, loose-envify@^1.4.0:
version "1.4.0"
@ -4154,9 +4154,9 @@ ripemd160@^2.0.0, ripemd160@^2.0.1:
inherits "^2.0.1"
safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@~5.2.0:
version "5.2.0"
resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.0.tgz#b74daec49b1148f88c64b68d49b1e815c1f2f519"
integrity sha512-fZEwUGbVl7kouZs1jCdMLdt95hdIv0ZeHg6L7qPeciMZhZ+/gdesW4wgTARkrFWEpspjEATAzUGPG8N2jJiwbg==
version "5.2.1"
resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
safe-buffer@~5.1.0, safe-buffer@~5.1.1:
version "5.1.2"