mirror of
https://github.com/pcottle/learnGitBranching.git
synced 2025-06-26 07:58:34 +02:00
Translated 'remote' levels to Spanish 'es_ES'
This commit is contained in:
flyingbot91
parent
159cf8dce2
commit
4631475b39
15 changed files with 1128 additions and 0 deletions
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"de_DE": "Clone Einführung",
|
||||
"ja" : "Clone入門",
|
||||
"es_AR": "Introducción a clone",
|
||||
"es_ES": "Introducción a clone",
|
||||
"pt_BR": "Introdução à clonagem",
|
||||
"gl" : "Introducción a clone",
|
||||
"zh_CN": "Git Clone",
|
||||
|
|
@ -22,6 +23,7 @@ exports.level = {
|
|||
"ja" : "単にgit clone!",
|
||||
"zh_CN": "只要 git clone 就可以了!",
|
||||
"es_AR": "Simplemente hacé git clone!",
|
||||
"es_ES": "¡Simplemente escribe `git clone`!",
|
||||
"pt_BR": "Basta fazer um git clone!",
|
||||
"gl" : "¡Chega con facer git clone!",
|
||||
"zh_TW": "只要 git clone 就好了",
|
||||
|
|
@ -201,6 +203,63 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git Remotes",
|
||||
"",
|
||||
"Los repositorios remotos no son _tan_ complicados. En el mundo actual de la computación en la nube es bastante facil pensar que hay un montón de magia detrás de los remotes de git, pero en realidad sólo son copias de tu repositorio en otra computadora. Típicamente vas a hablar con esta otra computadora a través de Internet, lo que permite transferir commits de un lado a otro.",
|
||||
"",
|
||||
"Habiendo dicho eso, los repositorios remotos tienen un par de propiedades interesantes:",
|
||||
"",
|
||||
"- Primero y principal, los remotos ¡son un backup genial! Los repositorios locales de git tienen la habilidad de restaurar archivos a un estado previo (como ya sabes), pero toda esa información se encuentra almacenada localmente. Al tener copias de tu repositorio git en otras computadoras, puedes perder todos tus datos locales y aún así retomar el trabajo en el punto donde lo habías dejado.",
|
||||
"",
|
||||
"- Más importante, ¡los remotos sociabilizan la programación! Ahora que hay una copia de tu proyecto hosteada en otro lugar, tus amigos pueden contribuir a tu proyecto (o bajarse los últimos cambios) de un modo muy sencillo.",
|
||||
"",
|
||||
"Se volvió bastante popular el uso de sitios web que muestran la actividad de los repositorios (como [Github](https://github.com/) or [Phabricator](http://phabricator.org/)), pero esos repositorios remotos _siempre_ sirven como la base subyacente de esas herramientas. Así que ¡es importante entenderlos!"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Nuestro comando para crear remotos",
|
||||
"",
|
||||
"Hasta este punto, Learn Git Branching se centró en enseñar las bases del trabajo _local_ con repositorios (crear ramas, mergear, rebasear, etc). Sin embargo, ahora que queremos aprender sobre el trabajo con repositorios remotos, necesitamos un comando para inicializar nuestro entorno para esas lecciones. Ese comando será `git clone`",
|
||||
"",
|
||||
"Técnicamente, `git clone` en el mundo real es el comando que usarías para crear copias _locales_ de un repositorio remoto (uno de GitHub, por ejemplo). Aquí usamos este comando de un modo un tanto distinto, en cambio -- `git clone` va a crear un repositorio remoto a partir del tuyo local. Estamos de acuerdo en que es el significado técnicamente opuesto al del comando real, pero ayuda bastante a entender la conexión entre el clonado y el trabajo en un repositorio remoto, así que vamos a vivir con ello por ahora.",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Comencemos despacio y simplemente veamos cómo se ve un repositorio remoto en nuestra visualización.",
|
||||
""
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Ahí está! Ahora tenemos un repositorio remoto de nuestro proyecto. Parece bastante similar, salvando algunos cambios visuales para hacer evidente la distinción -- en niveles posteriores vas a ver cómo compartir trabajo entre estos repositorios."
|
||||
],
|
||||
"command": "git clone",
|
||||
"beforeCommand": ""
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, simplemente ejecuta `git clone` en tu repositorio existente. El verdadero aprendizaje viene en las próximas lecciones."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ exports.level = {
|
|||
"de_DE": "Teamarbeit simulieren",
|
||||
"ja" : "擬似的なチーム作業",
|
||||
"es_AR": "Simulando el trabajo en equipo",
|
||||
"es_ES": "Simulando el trabajo en equipo",
|
||||
"pt_BR": "Simulando trabalho em equipe",
|
||||
"gl" : "Simulando o traballo no repositorio",
|
||||
"zh_CN": "模拟团队合作",
|
||||
|
|
@ -22,6 +23,7 @@ exports.level = {
|
|||
"de_DE": "Nicht vergessen, du kannst angeben wieviele Commits simuliert werden sollen.",
|
||||
"ja" : "擬似的に作成するコミット数を指定できるのをお忘れなく",
|
||||
"es_AR": "Acordate que podés especificar cuántos commits simular",
|
||||
"es_ES": "Recuerda que puedes especificar cuántos commits simular",
|
||||
"pt_BR": "Lembre-se que você pode especificar quantos commits quer simular",
|
||||
"gl" : "Lembra que podes especifar cantos commits queres simular",
|
||||
"zh_CN": "记住你可以指定仿真提交的个数",
|
||||
|
|
@ -193,6 +195,60 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Simulando la colaboración",
|
||||
"",
|
||||
"Entonces, hay algo un poco tramposo -- para algunas de las lecciones siguientes, necesitamos explicarte cómo descargar cambios introducidos en el repositorio remoto.",
|
||||
"",
|
||||
"Eso significa que escencialmente tenemos que \"tener en cuenta\" que el repositorio remoto fue actualizado por algún colega, amigo o colaborador tuyo, incluso a veces en alguna rama específica o una cantidad determinada de commits.",
|
||||
"",
|
||||
"Para lograr esto, introdujimos el bien llamado comando ¡`git fakeTeamwork`! Es bastante autoexplicativo: simula trabajo de nuestros colegas. Veamos una demo..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"El comportamiento por default de `fakeTeamwork` es simplemente crear un commit en master"
|
||||
],
|
||||
"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`."
|
||||
],
|
||||
"command": "git fakeTeamwork",
|
||||
"beforeCommand": "git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"También puedes especificar la cantidad de commits o la ramma agregándolos al comando"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Con un único comando simulamos que un compañero de equipo pusheó tres commits a la rama `foo` de nuestro remoto"
|
||||
],
|
||||
"command": "git fakeTeamwork foo 3",
|
||||
"beforeCommand": "git branch foo; git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Los niveles siguientes van a ser algo difíciles, así que vamos a exigirte un poco más en este nivel.",
|
||||
"",
|
||||
"Anímate y crea un remoto (con `git clone`), simula algunos cambios en ese remoto, haz commit en tu repo local, y luego haz pull de esos cambios. ¡Es como si fueran varias lecciones en una!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ exports.level = {
|
|||
"de_DE": "Git Fetch",
|
||||
"ja" : "Git Fetch",
|
||||
"es_AR": "git fetch",
|
||||
"es_ES": "git fetch",
|
||||
"pt_BR": "Git Fetch",
|
||||
"gl" : "Git Fetch",
|
||||
"zh_CN": "Git Fetch",
|
||||
|
|
@ -22,6 +23,7 @@ exports.level = {
|
|||
"de_DE": "Einfach git fetch ausführen!",
|
||||
"ja" : "単にgit fetchを実行！",
|
||||
"es_AR": "Simplemente ¡hacé git fetch!",
|
||||
"es_ES": "Simplemente ¡escribe git fetch!",
|
||||
"pt_BR": "Simplesmente chame git fetch!",
|
||||
"gl" : "¡Sinxelamente fai git fetch!",
|
||||
"zh_CN": "只需要运行 git fetch 命令!",
|
||||
|
|
@ -250,6 +252,79 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git Fetch",
|
||||
"",
|
||||
"Trabajar con remotos en git en realidad se reduce a transferir datos _de_ y _hacia_ otros repositorios. Mientras podamos mandar commits de un lado al otro, podemos compartir cualquier tipo de actualización registrada por git (y, por ende, compartir trabajo, archivos nuevos, ideas nuevas, cartas de amor, etc).",
|
||||
"",
|
||||
"En esta lección aprenderemos cómo traer (hacer `fetch`) datos _desde_ un repositorio remoto - el comando para esto se llama, convenientemente, `git fetch`).",
|
||||
"",
|
||||
"Vas a notar que a medida que actualicemos nuestra representación de nuestro repositorio remoto, nuestras ramas _remotas_ van a actualizarse para reflejar esa nueva representación. Esto está ligado a la lección anterior sobre ramas remotas"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"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."
|
||||
],
|
||||
"command": "git fetch",
|
||||
"beforeCommand": "git clone; git fakeTeamwork 2"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### ¿Qué hace fetch?",
|
||||
"",
|
||||
"`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`)",
|
||||
"",
|
||||
"`git fetch` escencialmente sincroniza nuestra representación _local_ del repositorio remoto con el _verdadero_ estado del repositorio remoto (en este momento).",
|
||||
"",
|
||||
"Si recuerdas la lección anterior, dijimos que las ramas remotas reflejan el estado de los repositorios remotos _desde_ la última vez que hablaste con ellos. ¡`git fetch` es la manera en la que hablas con esos remotos! Espero que ahora esté clara la conexión entre las ramas remotas y `git fetch`.",
|
||||
"",
|
||||
"Usualmente, `git fetch` habla con el repositorio a través de internet (usando un protocolo como `http://` o `git://`).",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"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.",
|
||||
"",
|
||||
"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",
|
||||
"",
|
||||
"Entonces, después de todo, puedes pensar sobre `git fetch` como un proceso de descarga."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, simplemente ejecuta `git fetch` y bájate todos los commits"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ exports.level = {
|
|||
"zh_CN": "Git fetch 的参数",
|
||||
"zh_TW": "fetch 的參數",
|
||||
"es_AR": "Parámetros de fetch",
|
||||
"es_ES": "Parámetros de fetch",
|
||||
"pt_BR": "Parâmetros do fetch",
|
||||
"gl" : "Parámetros de fetch",
|
||||
"de_DE": "Optionen für Fetch",
|
||||
|
|
@ -22,6 +23,7 @@ exports.level = {
|
|||
"zh_CN": "注意下提交对象的 id 是如何交换的! 你可以通过 `help level` 重新阅读本关卡的所有对话框!",
|
||||
"zh_TW": "注意 commit 的 id 是怎麼被交換的！你可以透過 `help level` 來閱讀對話視窗！",
|
||||
"es_AR": "¡Prestá atención a cómo podrían haberse invertido los ids de los commits! Podés volver a leer toda la lección usando \"help level\"",
|
||||
"es_ES": "¡Presta atención a cómo podrían haberse invertido los ids de los commits! Puedes volver a leer toda la lección usando \"help level\"",
|
||||
"pt_BR": "Preste atenção em como os identificadores dos commits podem ter trocado! Você pode ler os slides novamente com \"help level\"",
|
||||
"gl" : "Preste atención en como poderían invertirse os ids dos commits! Podes volver ler toda a lección usando \"help level\"",
|
||||
"de_DE": "Beachte wie die Commit IDs getauscht wurden! Du kannst den Einführungsdialog mit \"help level\" erneut anzeigen",
|
||||
|
|
@ -400,6 +402,129 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Parámetros de git fetch",
|
||||
"",
|
||||
"Acabamos de aprender todo sobre los parámetros de push, como el parámetro `<lugar>`, e incluso las referencias separadas por dos puntos (`<origen>:<destino>`). ¿Podremos usar todo ese conocimiento para `git fetch`, también?",
|
||||
"",
|
||||
"¡Dalo por hecho! Los parámetros para `git fetch` son realmente *muy, muy* similares a los de `git push`. Es el mismo tipo de conceptos, pero aplicados en la dirección opuesta (dado que ahora estás bajando commits en lugar de subirlos).",
|
||||
"",
|
||||
"Veamos los conceptos de a uno en uno..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### El parámetro `<lugar>`",
|
||||
"",
|
||||
"Si especificas un lugar con git fetch como en el comando siguiente:",
|
||||
"",
|
||||
"`git fetch origin foo`",
|
||||
"",
|
||||
"Git va a ir a la rama `foo` en el remoto, va a traer todos los commits que no estén presentes localmente, y luego los aplicará sobre la rama `o/foo` localmente.",
|
||||
"",
|
||||
"Veámoslo en acción (refresquemos el concepto)."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Especificando un lugar..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Sólo bajamos los commits de `foo` y los ubicamos en `o/foo`"
|
||||
],
|
||||
"command": "git fetch origin foo",
|
||||
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Te podrás estar preguntando \"¿Por qué git aplicó esos commits sobre la rama `origin/foo` en lugar de aplicarlos sobre la rama `foo` local? Pensé que el parámetro `<lugar>` era un lugar que existía tanto local como remotamente\"",
|
||||
"",
|
||||
"Bueno, git hace una excepción especial en este caso, porque podrías tener trabajo en la rama `foo` que no quieras mezclar. Esto hace referencia a la lección anterior sobre `git fetch` - no actualiza tus ramas locales no-remotas, sólo descarga los commits (para que pueadas verlos o mergearlos después).",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"\"Bueno, y, en ese caso, ¿qué pasa si explícitamente defino el origen y destino con `<origen>:<destino>`?\"",
|
||||
"",
|
||||
"Si te sientes lo suficientemente seguro como para traer commits *directamente* a una rama local, entonces, sí, puedes especificarlo usando una referencia con dos puntos. No puedes traer commits a una rama que sobre la que hayas hecho checkout, pero en cualquier otro caso git te lo va a permitir.",
|
||||
"",
|
||||
"Este es el único problema, igual: `<origen>` es ahora un lugar en el *remoto*, y `<destino>` es un lugar *local* en donde poner esos commits. Es exactamente lo opuesto a git push, y eso tiene sentido dado que ¡estamos transfiriendo los datos en la dirección opuesta!",
|
||||
"",
|
||||
"Habiendo dicho esto, difícilmente alguien use esto en la práctica. Lo estoy presentando principalmente como un modo de conceptualizar que `fetch` y `push` son bastante similares, sólo que en direcciones opuestas."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Veamos esta locura en acción:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Caramba! Mira: git resolvió `foo~1` como un lugar en el origin y bajó esos commits a `bar` (que era una rama local). Observa como `foo` y `o/foo` no fueron actualizados, dado que especificamos un destino."
|
||||
],
|
||||
"command": "git fetch origin foo~1:bar",
|
||||
"beforeCommand": "git branch foo; git clone; git branch bar; git fakeTeamwork foo 2"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿Qué pasa si el destino no existe antes de ejecutar este comando? Veamos el último ejemplo pero sin que `bar` exista de antemano."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Mira: es IGUAL que git push. Git creó el destino localmente antes de hacer el fetch, tal como git creará el destino en el remoto antes de hacer push (si no existiera)."
|
||||
],
|
||||
"command": "git fetch origin foo~1:bar",
|
||||
"beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿Sin argumentos?",
|
||||
"",
|
||||
"Si `git fetch` no recibe ningún argumento, simplemente descarga todos los commits del remoto a todas las ramas remotas..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"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"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Bueno, demasiada charla. Para completar este nivel, haz fetch sólo de los commits especificados en la visualización del objetivo. ¡Familiarízate con esos comandos!",
|
||||
"",
|
||||
"Vas a tener que especificar el origen y el destino para ambos comandos fetch. Presta atención al objetivo dado que ¡los IDs pueden estar invertidos!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"zh_CN": "偏离的提交历史",
|
||||
"zh_TW": "diverged history",
|
||||
"es_AR": "Historia divergente",
|
||||
"es_ES": "Historia divergente",
|
||||
"pt_BR": "Histórico divergente",
|
||||
"gl" : "Histórico diverxente",
|
||||
"de_DE": "Abweichende History",
|
||||
|
|
@ -21,6 +22,7 @@ exports.level = {
|
|||
"zh_CN": "按照目标中的提交树的顺序进行检出",
|
||||
"zh_TW": "確認視覺化的目標中的順序",
|
||||
"es_AR": "Prestá atención al orden del objetivo",
|
||||
"es_ES": "Presta atención al orden del objetivo",
|
||||
"pt_BR": "Preste atenção na ordem da visualização do objetivo",
|
||||
"gl" : "Presta atención ó orixe do obxectivo",
|
||||
"de_DE": "Beachte die Reihenfolge in der Zieldarstellung",
|
||||
|
|
@ -460,6 +462,149 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Trabajo divergente",
|
||||
"",
|
||||
"Hasta ahora hemos visto cómo hacer pull a commits de otros y cómo hacer push a los nuestros. Parece bastante simple, así que ¿cómo puede confundirse tanto la gente?",
|
||||
"",
|
||||
"La dificultad viene cuando la historia de los repositorios *diverge*. Antes de entrar en detalles, veamos un ejemplo...",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Imagínate que clonas un repositorio el lunes y empiezas a desarrollar algo. Para el viernes ya estás listo para publicar tu trabajo, pero, ¡vaya! Tus colegas también han estado escribiendo código durante la semana, haciendo que tu trabajo quede desactualizado (y obsoleto). Además, ellos publicaron esos commits en el repositorio remoto, así que ahora *tu* trabajo está basado en una versión *vieja* del proyecto, que ya no le interesa a nadie.",
|
||||
"",
|
||||
"En este caso, el comando `git push` es ambiguo. Si ejecutas `git push`, ¿git debería cambiar el repositorio a como estaba el lunes? ¿Debería tratar de agregar tu código sin eliminar el código nuevo? ¿O debería ignorar completamente tus cambios porque están desactualizados?",
|
||||
"",
|
||||
"Como hay tanta ambiguedad en esta situación (en la que la historia divirgió), git no te permite hacer push de tus cambios. En cambio, te fuerza a integrar el último estado del repositorio remoto antes de poder compartir tu trabajo."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¡Demasiada charla, veámoslo en acción!"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¿Ves? No pasó nada, porque el comando falla. `git push` falla porque `C3`, tu commit más reciente, está basado en el remoto sobre `C1`. El remoto fue actualizado a `C2` desde entonces, por lo que git rechaza tu push"
|
||||
],
|
||||
"command": "git push",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"¿Cómo puedes resolver esta situación? Es fácil, todo lo que tienes que hacer es basar tu trabajo en la versión más reciente de la rama remota.",
|
||||
"",
|
||||
"Hay un par de maneras de hacer esto, pero la más simple es mover tu trabajo haciendo un rebase. Probémoslo a ver cómo se ve."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Ahora, si hacemos rebase antes de hacer push..."
|
||||
],
|
||||
"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",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"¿Hay otra manera de actualizar mi trabajo si actualizaron el repositorio remoto? ¡Claro que sí! Veamos cómo hacer lo mismo pero usando `merge`.",
|
||||
"",
|
||||
"Por más que `git merge` no mueva tu trabajo (sólo crea un commit de merge), es un modo de decirle a git que integraste todos los cambios del remoto. Esto es porque ahora una rama remota pasó a ser un *ancestro* de tu propia rama, lo que significa que tu commit refleja los cambios de todos los commits de la rama remota.",
|
||||
"",
|
||||
"Veamos una muestra..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Si en lugar de hacer rebase hacemos un merge..."
|
||||
],
|
||||
"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",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"¡Asombroso! ¿Hay forma de hacer esto sin escribir tantos comandos?",
|
||||
"",
|
||||
"¡Claro que sí! Ya sabes que `git pull` es simplemente un atajo para hacer fetch y merge. Convenientemente, ¡`git pull --rebase` es un atajo para hacer fetch y rebase!",
|
||||
"",
|
||||
"Veamos estos atajos funcionando."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Primero con `--rebase`..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Igual que antes! Sólo que bastante más corto."
|
||||
],
|
||||
"command": "git pull --rebase; git push",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Y ahora un `pull` común"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Otra vez, ¡exactamente lo mismo que antes!"
|
||||
],
|
||||
"command": "git pull; git push",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Toda este tinglado de hacer fetch, rebase/merge y push es bastante común. En lecciones futuras vamos a ver formas más complejas de estos flujos de trabajo, pero por ahora vamos a probar esto que acabamos de ver.",
|
||||
"",
|
||||
"Para resolver este nivel, haz lo siguiente:",
|
||||
"",
|
||||
"* Clona tu repositorio",
|
||||
"* Simula algo de trabajo de un colega (1 commit)",
|
||||
"* Haz commit de algún cambio tuyo (1 commit)",
|
||||
"* Publica tu trabajo *rebaseando*"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"zh_CN": "合并远程仓库",
|
||||
"zh_TW": "merge with remotes",
|
||||
"es_AR": "Mergeando con los remotos",
|
||||
"es_ES": "Haciendo merge con los remotos",
|
||||
"pt_BR": "Merge com remotos",
|
||||
"gl" : "Merge cos repos remotos",
|
||||
"de_DE": "Änderungen vom Remote zusammenführen",
|
||||
|
|
@ -21,6 +22,7 @@ exports.level = {
|
|||
"zh_CN": "注意目标树!",
|
||||
"zh_TW": "注意最後要完成的目標！",
|
||||
"es_AR": "¡Prestá atención al árbol final!",
|
||||
"es_ES": "¡Presta atención al árbol final!",
|
||||
"pt_BR": "Preste atenção na árvore do objetivo!",
|
||||
"gl" : "Presta atención á arbore final!",
|
||||
"de_DE": "Beachte den Ziel-Baum!",
|
||||
|
|
@ -167,6 +169,51 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"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`).",
|
||||
"",
|
||||
"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?",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Hay mucho debate entre los desarrolladores sobre los pros y contras de mergear vs rebasear. Aquí te mostraré los pros y contras de rebasear:",
|
||||
"",
|
||||
"Pros:",
|
||||
"",
|
||||
"* Rebasear hace que tu árbol de commits se vea bastante limpio, porque todos los commits siguen una única línea",
|
||||
"",
|
||||
"Contras:",
|
||||
"",
|
||||
"* Rebasear modifica la historia (aparente) de tu árbol de commits.",
|
||||
"",
|
||||
"Por ejemplo, el commit `C1` puede rebasearse para que aparezca *después* de `C3`. Entonces, parece que el trabajo de `C1'` se hizo después de `C3`, cuando en realizad se había hecho antes.",
|
||||
"",
|
||||
"Algunos desarrolladores prefieren preservar la historia, por lo que deciden mergear. Otros (como yo) preferimos tener un árbol de commits limpios, y preferimos rebasear. Todo es una cuestión de preferencias :D"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para este nivel, tratemos de resolver el nivel anterior, pero *mergeando*. Puede volverse un poco cuesta arriba, pero ilustra la idea bastante bien."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"zh_CN": "Git Pull",
|
||||
"zh_TW": "git pull",
|
||||
"es_AR": "git pull",
|
||||
"es_ES": "git pull",
|
||||
"pt_BR": "Git Pull",
|
||||
"gl" : "Git Pull",
|
||||
"de_DE": "Git Pull",
|
||||
|
|
@ -21,6 +22,7 @@ exports.level = {
|
|||
"zh_CN": "运行 git pull 命令就可以了！",
|
||||
"zh_TW": "只要下 git pull 這個指令即可",
|
||||
"es_AR": "Simplemente ¡hacé git pull!",
|
||||
"es_ES": "Simplemente ¡ejecuta git pull!",
|
||||
"pt_BR": "Basta executar git pull!",
|
||||
"gl" : "Sinxelamente fai git pull!",
|
||||
"de_DE": "Führe einfach git pull aus.",
|
||||
|
|
@ -208,6 +210,65 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git Pull",
|
||||
"",
|
||||
"Ahora que vimos cómo traer datos de un repositorio remoto con `git fetch`, ¡actualicemos nuestro trabajo local para reflejar esos cambios!",
|
||||
"",
|
||||
"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`",
|
||||
"* 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`!"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"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`)"
|
||||
],
|
||||
"command": "git fetch; git merge o/master",
|
||||
"beforeCommand": "git clone; git commit; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿Qué pasaría si en cambio utilizásemos `git pull`?"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Lo mismo! Eso debería dejar bien claro que `git pull` es básicamente un atajo para hacer `git fetch` seguido por un merge con la rama que hayamos descargado."
|
||||
],
|
||||
"command": "git pull",
|
||||
"beforeCommand": "git clone; git commit; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Exploraremos los detalles de `git pull` después (incluyendo sus opciones y parámetros), pero por ahora probémoslo en este nivel.",
|
||||
"",
|
||||
"Recuerda: puedes ejecutar este comando simplemente con `fetch` y `merge`, pero eso te costaría un comando extra :P"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"zh_CN": "Git pull 的参数",
|
||||
"zh_TW": "pull 的參數",
|
||||
"es_AR": "Parámetros de pull",
|
||||
"es_ES": "Parámetros de pull",
|
||||
"pt_BR": "Parâmetros do pull",
|
||||
"gl" : "Parámetros de pull",
|
||||
"de_DE": "Optionen für Pull",
|
||||
|
|
@ -21,6 +22,7 @@ exports.level = {
|
|||
"zh_CN": "记住, 你可以通过 fetch/pull 创建本地分支",
|
||||
"zh_TW": "記住，你可以透過 fetch 以及 pull 來建立一個新的 local 的 branch",
|
||||
"es_AR": "Acordate de que podés crear nuevas ramas locales usando los parámetros de fetch/pull",
|
||||
"es_ES": "Recuerda que puedes crear nuevas ramas locales usando los parámetros de fetch/pull",
|
||||
"pt_BR": "Lembre-se que você pode criar novos ramos locais com parâmetros de fetch/pull",
|
||||
"gl" : "Lémbrate que podes crear novas ramas locais con parámetros de fetch/pull",
|
||||
"de_DE": "Du kannst neue lokale Branches mittels fetch / pull erstellen",
|
||||
|
|
@ -253,6 +255,80 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Parámetros de git pull",
|
||||
"",
|
||||
"Ahora que sabes prácticamente *todo* lo que hay que saber sobre los parámetros de `git fetch` y `git push`, casi no queda nada por cubrir del comando git pull :)",
|
||||
"",
|
||||
"Eso es porque git pull es simplemente un atajo para hacer un fetch seguido de un merge. Puedes imaginártelo como ejecutar git fetch con los *mismos* parámetros, y después hacer merge de ello hacia donde esos commits hayan ido a parar.",
|
||||
"",
|
||||
"Esto aplica incluso cuando utilizas parámetros rebuscados en exceso. Veamos algunos ejemplos:"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Estos son algunos comandos equivalentes de git:",
|
||||
"",
|
||||
"`git pull origin foo` equivale a:",
|
||||
"",
|
||||
"`git fetch origin foo; git merge o/foo`",
|
||||
"",
|
||||
"Y...",
|
||||
"",
|
||||
"`git pull origin bar~1:bugFix` equivale a:",
|
||||
"",
|
||||
"`git fetch origin bar~1:bugFix; git merge bugFix`",
|
||||
"",
|
||||
"¿Ves? git pull es simplemente un atajo para un fetch + merge, y todo lo que le importa a git pull es dónde terminaron esos commits (el parámetro `destino` que determina durante el fetch).",
|
||||
"",
|
||||
"Veamos una demostración:"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"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."
|
||||
],
|
||||
"command": "git pull origin master",
|
||||
"beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿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!!!"
|
||||
],
|
||||
"command": "git pull origin master:foo",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"OK: para terminar, intenta alcanzar el estado del objetivo. Vas a necesitar descargar algunos commits, crear algunas ramas nuevas, y mergear esas ramas junto con otras, pero no debería llevar demasiados comandos :P"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ exports.level = {
|
|||
"zh_CN": "Git Push",
|
||||
"zh_TW": "git push",
|
||||
"es_AR": "git push",
|
||||
"es_ES": "git push",
|
||||
"pt_BR": "Git Push",
|
||||
"gl" : "Git Push",
|
||||
"de_DE": "Git Push",
|
||||
|
|
@ -24,6 +25,7 @@ exports.level = {
|
|||
"zh_CN": "推送之前需要先克隆",
|
||||
"zh_TW": "push 之前你需要先 clone",
|
||||
"es_AR": "¡Acordate que tenés que clonar antes de pushear!",
|
||||
"es_ES": "¡Recuerda que tienes que clonar antes de hacer push!",
|
||||
"pt_BR": "Lembre-se de clonar antes de fazer o push!",
|
||||
"de_DE": "Denk dran, dass du einen Clone brauchst bevor du Pushen kannst!",
|
||||
"ja" : "Pushができるようになるには、まずリポジトリをcloneする必要があるのをお忘れなく",
|
||||
|
|
@ -160,6 +162,47 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## git push",
|
||||
"",
|
||||
"Entendido, entonces ya descargué los cambios de un repositorio remoto y los integré en mi trabajo localmente. Esto suena muy bien... pero ¿cómo comparto _mis_ cambios con el resto?",
|
||||
"",
|
||||
"Bueno, la forma de subir el trabajo compartido es la opuesta a cómo descargar trabajo. Y ¿qué es lo opuesto a `git pull`? ¡`git push`!",
|
||||
"",
|
||||
"`git push` es el responsable de subir _tus_ cambios a un remoto específico y de actualizar ese remoto para incluir tus nuevos commits. Cuando `git push` termina, todos tus amigos pueden descargar tu trabajo del remoto.",
|
||||
"",
|
||||
"Puedes imaginarte `git push` como un comando para \"publicar\" tu trabajo. Tiene un par de sutilezas con las que vamos a meternos pronto, pero empecemos poco a poco."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"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!"
|
||||
],
|
||||
"command": "git push",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, simplemente comparte dos nuevos commits con el remoto. Igualmente, no te confíes, ¡las lecciones van a empezar a complicarse!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ exports.level = {
|
|||
"zh_CN": "Git push 的参数",
|
||||
"zh_TW": "git push 的參數",
|
||||
"es_AR": "Parámetros de git push",
|
||||
"es_ES": "Parámetros de git push",
|
||||
"pt_BR": "Parâmetros do git push",
|
||||
"gl" : "Parámetros de git push",
|
||||
"de_DE": "Optionen für Git Push",
|
||||
|
|
@ -24,6 +25,7 @@ exports.level = {
|
|||
"zh_CN": "你可以利用“objective”来阅读对话窗口的最后一页",
|
||||
"zh_TW": "你可以利用 \"objective\" 來閱讀對話視窗的最後一頁",
|
||||
"es_AR": "Siempre podés ver el último mensaje tipeando \"objective\"",
|
||||
"es_ES": "Siempre puedes ver el último mensaje escribiendo \"objective\"",
|
||||
"pt_BR": "Você sempre pode rever o último slide com o comando \"objective\"",
|
||||
"gl" : "Ti sempre podes desfacer último mensaxe escribindo \"objective\"",
|
||||
"de_DE": "Du kannst dir die Zielsetzung des Levels immer wieder mit \"objective\" anzeigen lassen",
|
||||
|
|
@ -253,6 +255,78 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Parámetros de push",
|
||||
"",
|
||||
"¡Genial! Ahora que has aprendido sobre las ramas que trackean remotos podemos empezar a desvelar algo del misterio detrás de git push, fetch y pull. Vamos a atacar un comando cada vez, pero los conceptos entre ellos son muy similares.",
|
||||
"",
|
||||
"Veamos primero `git push`. Ya aprendiste en la lección sobre ramas remotas que git determinó el remoto *y* la rama a la que pushear mirando las propiedades de la rama actual (el remoto al que \"trackea\"). Este es el comportamiento por defecto para cuando no se especifican parámetros, pero git push toma, opcionalmente, parámetros de la forma:",
|
||||
"",
|
||||
"`git push <remoto> <lugar>`",
|
||||
"",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"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`",
|
||||
"",
|
||||
"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.*",
|
||||
"",
|
||||
"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.",
|
||||
"",
|
||||
"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¡"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"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."
|
||||
],
|
||||
"command": "git checkout C0; git push origin master",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿Y si no especificabamos los parámetros? ¿Qué hubiera pasado?"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"El comando falla (como puedes ver), porque `HEAD` no está sobre ninguna rama que apunte a algún remoto."
|
||||
],
|
||||
"command": "git checkout C0; git push",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"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!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"zh_CN": "Git push 参数 2",
|
||||
"zh_TW": "git push 的參數，延伸討論！",
|
||||
"es_AR": "¡Más! Parámetros de git push",
|
||||
"es_ES": "¡Más! Parámetros de git push",
|
||||
"pt_BR": "Parâmetros do git push -- expandido",
|
||||
"gl" : "Parámetros de git push -- ampliado",
|
||||
"de_DE": "Optionen für Git Push -- noch mehr!",
|
||||
|
|
@ -21,6 +22,7 @@ exports.level = {
|
|||
"zh_CN": "如果你认输的话，可以通过“show solution”查看解决方案 :P",
|
||||
"zh_TW": "如果你失敗了，可以利用 \"show solution\" 來找到解答:P",
|
||||
"es_AR": "Recordá que podés admitir tu derrota y tipear \"show solution\" para ver la solución :P",
|
||||
"es_ES": "Recuerda que puedes admitir tu derrota y escribir \"show solution\" para ver la solución :P",
|
||||
"pt_BR": "Lembre-se que você pode admitir que foi derrotado e digitar \"show solution\" :P",
|
||||
"gl" : "Lembrate que podes admitir que fuches derrotado e escribir \"show solution\" para amosala solución :P",
|
||||
"de_DE": "Vergiss nicht dass du aufgeben kannst, indem du \"show solution\" eingibst :P",
|
||||
|
|
@ -241,6 +243,76 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"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.",
|
||||
"",
|
||||
"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?",
|
||||
"",
|
||||
"Bueno, lamentablemente eso no se puede hacer en git... ¡zasca! Claro que se puede :)... git es extremadamente flexible (casi casi que demasiado).",
|
||||
"",
|
||||
"Veamos cómo hacerlo a continuación..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para especificar tanto el origen como el destino de `<lugar>`, simplemente únelos usando el signo `dos puntos`:",
|
||||
"",
|
||||
"`git push origin <origen>:<destino>`",
|
||||
"",
|
||||
"A esto se le suele llamar refspec con dos puntos. Refspec es simplemente un nombre genial para una ubicación que git puede entender (como la rama `foo`, o incluso `HEAD~1`)",
|
||||
"",
|
||||
"Una vez que especificas tanto el origen como el destino independientemente, puedes ponerte bastante cómodo y preciso con los comandos remotos. ¡Veamos una demo!"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Recuerda: `origen` es cualquier ubicación que git pueda entender:"
|
||||
],
|
||||
"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",
|
||||
"beforeCommand": "git clone; go -b foo; git commit; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿Y qué ocurre si el destino al que quieres hacer push no existe? ¡Sin problema! Simplemente dale un nombre a la rama y git se va a encargar de creártelo en el remoto."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Genial, simplemente fluye :D"
|
||||
],
|
||||
"command": "git push origin master:newBranch",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para este nivel, trata de llegar al objetivo final, y recuerda el formato:",
|
||||
"",
|
||||
"`<origen>:<destino>`"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"zh_CN": "你随时都可以使用 undo 或 reset 命令。",
|
||||
"zh_TW": "你隨時都可以使用 undo 或 reset 指令。",
|
||||
"es_AR": "Acordate que siempre podés usar los comandos reset y undo",
|
||||
"es_ES": "Recuerda que siempre puedes usar los comandos reset y undo",
|
||||
"pt_BR": "Lembre-se que você sempre pode usar undo ou reset",
|
||||
"gl" : "Lembra que sempre podes usar undo ou reset",
|
||||
"de_DE": "Denk dran, du kannst immer undo oder reset benutzen, um deine Befehle zurück zu nehmen.",
|
||||
|
|
@ -21,6 +22,7 @@ exports.level = {
|
|||
"zh_CN": "推送主分支",
|
||||
"zh_TW": "push master！",
|
||||
"es_AR": "¡Push Master!",
|
||||
"es_ES": "¡Push Master!",
|
||||
"pt_BR": "Push Master!",
|
||||
"gl" : "Empurra ó Master!",
|
||||
"de_DE": "Push Master!",
|
||||
|
|
@ -191,6 +193,59 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Haciendo merge con ramas de trabajo",
|
||||
"",
|
||||
"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.",
|
||||
"",
|
||||
"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`).",
|
||||
"",
|
||||
"Entonces, en este flujo de trabajo combinamos dos cosas:",
|
||||
"",
|
||||
"* integramos el trabajo de las ramas específicas a `master`, y",
|
||||
"* pusheamos y pulleamos del remoto"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Refresquemos un poco cómo actualizar `master` y pushear nuestro trabajo."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Ahora ejecutamos dos comandos que:",
|
||||
"",
|
||||
"* rebasearon nuestro trabajo sobre los nuevos commits del remoto, y",
|
||||
"* publicamos nuestro trabajo en ese remoto"
|
||||
],
|
||||
"command": "git pull --rebase; git push",
|
||||
"beforeCommand": "git clone; git commit; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Este nivel es bastante pesado. Aquí tienes algunas ideas para resolverlo:",
|
||||
"",
|
||||
"* Tenemos tres ramas específicas -- `side1` `side2` and `side3`",
|
||||
"* Queremos hacer push de cada una de esas ramas, en orden, al remoto",
|
||||
"* El remoto fue actualizado, así que vamos a tener que integrar esos cambios también",
|
||||
"",
|
||||
":O ¡Genial! ¡Éxito! Completar este nivel representa un gran avance."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"zh_CN": "远程分支",
|
||||
"zh_TW": "remote branch （遠端分支）",
|
||||
"es_AR": "Ramas remotas",
|
||||
"es_ES": "Ramas remotas",
|
||||
"pt_BR": "Ramos remotos",
|
||||
"gl" : "Ramas remotas",
|
||||
"de_DE": "Branches auf entfernten Servern",
|
||||
|
|
@ -21,6 +22,7 @@ exports.level = {
|
|||
"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!",
|
||||
|
|
@ -214,6 +216,67 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Ramas remotas de git",
|
||||
"",
|
||||
"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.",
|
||||
"",
|
||||
"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.",
|
||||
"",
|
||||
"Las ramas remotas tienen la propiedad especial de que cuando haces checkout sobre ellas, pasas al modo detached `HEAD`. Git lo hace a propósito porque no puedes trabajar en esas ramas directamente: tienes que trabajar en algún otro lado y después compartir tu trabajo con el remoto (tras lo que tus ramas remotas se actualizarán)."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### ¿Qué es `o/`?",
|
||||
"",
|
||||
"Podrías estar preguntándote qué significa ese `o/` al principio de las ramas remotas. Bueno, las ramas remotas también tienen una convención de nombres obligatoria -- se muestran con el formato:",
|
||||
"",
|
||||
"* `<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`.",
|
||||
"",
|
||||
"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.",
|
||||
"",
|
||||
"Desafortunadamente el nombre `origin` completo no entra en nuestra UI (interfaz de usuario), así que usamos `o` para abreviar :(Simplemente recuerda que cuando uses el git real, tu remoto ¡probablemente se llame `origin`!",
|
||||
"",
|
||||
"Queda mucho por aprender, así que veámoslo en acción."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"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."
|
||||
],
|
||||
"command": "git checkout o/master; git commit",
|
||||
"beforeCommand": "git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"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."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ exports.level = {
|
|||
"zh_CN": "没有 source 的 source",
|
||||
"zh_TW": "沒有 source",
|
||||
"es_AR": "Origen de nada",
|
||||
"es_ES": "Origen de nada",
|
||||
"pt_BR": "Origem vazia",
|
||||
"gl" : "Orixen de nada",
|
||||
"de_DE": "Die Quelle des Nichts",
|
||||
|
|
@ -25,6 +26,7 @@ exports.level = {
|
|||
"zh_CN": "本关的 branch 命令被禁用了，你只能用 fetch！",
|
||||
"zh_TW": "在本關卡中，不允許使用 branch 指令，因此你只能使用 fetch！",
|
||||
"es_AR": "El comando branch está deshabilitado para este nivel, así que ¡vas a tener que usar fetch!",
|
||||
"es_ES": "El comando branch está deshabilitado para este nivel, así que ¡vas a tener que usar fetch!",
|
||||
"pt_BR": "O comando branch está desabilitado para este nível, então você terá de usar o fetch!",
|
||||
"gl" : "O comando branch está deshabilitado para este nivel, entón terás que empregar o comando fetch!",
|
||||
"de_DE": "Der branch Befehl ist für diesen Level inaktiv, du musst also fetch benutzen",
|
||||
|
|
@ -194,6 +196,59 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Rarezas de `<origen>`",
|
||||
"",
|
||||
"Git abusa del parámetro `<origen>` de dos extrañas maneras. Estos dos abusos vienen del hecho de que técnicamente puedes especificar \"la nada\" como un `origen` válido tanto para git push como para git fetch. El modo de especificar la nada es a través de un parámetro vacío:",
|
||||
"",
|
||||
"* `git push origin :side`",
|
||||
"* `git fetch origin :bugFix`",
|
||||
"",
|
||||
"Veamos qué hacen estos..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿Qué hace el hacer push de \"nada\" a una rama remota? ¡La elimina!"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"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"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Finalmente, hacer fetch de \"nada\" a un lugar local en realidad crea una nueva rama"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Bastante extraño, pero bueno, da igual. Así es git."
|
||||
],
|
||||
"command": "git fetch origin :bar",
|
||||
"beforeCommand": "git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Este es un nivel breve: simplemente elimina una rama remota y crea una nueva usando `git fetch` para completarlo."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ exports.level = {
|
|||
"zh_CN": "远程追踪",
|
||||
"zh_TW": "remote tracking",
|
||||
"es_AR": "Trackeando remotos",
|
||||
"es_ES": "Trackeando remotos",
|
||||
"pt_BR": "Seguindo remotos",
|
||||
"gl" : "Traceando os remotos",
|
||||
"de_DE": "Remote Tracking",
|
||||
|
|
@ -21,6 +22,7 @@ exports.level = {
|
|||
"zh_CN": "记住，有两种设置 remote tracking 的方法!",
|
||||
"zh_TW": "記住喔，有兩個方式可以去設定 remote tracking",
|
||||
"es_AR": "¡Acordate de que hay dos formas de trackear un remoto!",
|
||||
"es_ES": "¡Recuerda que hay dos formas de trackear un remoto!",
|
||||
"pt_BR": "Lembre-se que há duas formas de seguir um ramo remoto!",
|
||||
"gl" : "¡Lembrate de que hai dúas formas de seguir unha rama remota!",
|
||||
"de_DE": "Nicht vergessen, es gibt zwei Arten Remote Tracking einzurichten!",
|
||||
|
|
@ -387,6 +389,126 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_ES": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Ramas que trackean remotos",
|
||||
"",
|
||||
"Una de las cosas que te pueden haber parecido \"mágicas\" de las últimas lecciones es que git sabía que la rama `master` estaba relacionada con `o/master`. Obviamente, estas ramas tienen nombres parecidos, y podría parecer lógico conectar la rama `master` del remoto con la rama `master` local, pero esta conexión es bien evidente en dos escenarios:",
|
||||
"",
|
||||
"* Durante una operación de pull, los commits se descargan a `o/master` y después se *mergean* a la rama `master`. El objetivo implícito del merge se determina con esta conexión.",
|
||||
"* Durante un push, el trabajo de la rama `master` se sube a la rama `master` del remoto (que estaba representada localmente por `o/master`). El *destino* del push se determina con esta conexión entre `master` y `o/master`.",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Trackeando remotos",
|
||||
"",
|
||||
"Resumiendo, esta conexión entre `master` y `o/master` se explica simplemente por la propiedad de \"trackear (seguir) remotos\" de las ramas. La rama `master` está configurada para trackear `o/master` -- osea, que hay un objetivo implícito para el merge y un destino implícito para de la rama `master`.",
|
||||
"",
|
||||
"Podrías estar pensando cómo esa propiedad apareció en tu rama `master` si no ejecutaste ningún comando para especificarlo. Bueno, cuando clonas un repositorio con git, esta propiedad es asignada por ti automáticamente.",
|
||||
"",
|
||||
"Durante un clone, git crea una rama remota por cada rama en el remoto (por ejemplo, ramas como `o/master`). Pero después crea una rama local que trackea la rama activa del remote, que suele ser `master`.",
|
||||
"",
|
||||
"Una vez completado el git clone, sólo tienes una única rama local (para que no te asustes) pero puedes ver todas las ramas del remoto (si fueses curioso). ¡Es lo mejor de ambos mundos!",
|
||||
"",
|
||||
"Esto también explica por qué podrías ver un mensaje como este durante la clonación:",
|
||||
"",
|
||||
" local branch \"master\" set to track remote branch \"o/master\"",
|
||||
"",
|
||||
" rama local \"master\" establecida para trackear la rama remota \"o/master\""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### ¿Puedo especificarlo yo?",
|
||||
"",
|
||||
"¡Claro que sí! Puedes hacer que cualquier rama que quieras trackee `o/master`, y si lo hicieras, esa rama va a tener el mismo destino implícito de push y objetivo implícito de merge que `master`. Eso significa que puedes ejecutar `git push` en una rama llamada `absolutamenteNoEsMaster` y ¡que tu trabajo se pushee a la rama `master` del remoto!",
|
||||
"",
|
||||
"Hay dos formas de establecer esta propiedad. La primera es hacer checkout sobre una nueva rama usando una rama remota como la referencia especificada. Ejecutar",
|
||||
"",
|
||||
"`git checkout -b absolutamenteNoEsMaster o/master`",
|
||||
"",
|
||||
"Crea una nueva rama llamada `absolutamenteNoEsMaster` y la hace trackear a `o/master`."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Basta de charla, ¡veamos un ejemplo! Vamos a hacer checkout de una nueva rama llamada `foo` y hacer que trackee a `master` en el remoto."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Como puedes ver, usamos el objetivo implícito de merge `o/master` para actualizar la rama `foo`. ¡Observa cómo `master` no fue actualizada!"
|
||||
],
|
||||
"command": "git checkout -b foo o/master; git pull",
|
||||
"beforeCommand": "git clone; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Lo mismo aplica para git push"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Zas. Hacemos push de nuestro trabajo a la rama `master` del remoto incluso cuando nuestra rama se llamaba totalmente distinto"
|
||||
],
|
||||
"command": "git checkout -b foo o/master; git commit; git push",
|
||||
"beforeCommand": "git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Forma número 2",
|
||||
"",
|
||||
"Otra forma de especificar la rama a trackear es usar la opción `git branch -u`. Ejecutando",
|
||||
"",
|
||||
"`git branch -u o/master foo`",
|
||||
"",
|
||||
"establecemos que la rama `foo` trackee a `o/master`. Si encima estás parado en `foo`, incluso puedes obviarlo:",
|
||||
"",
|
||||
"`git branch -u o/master`",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Veamos rápidamente esta otra forma de especificar la rama a trackear..."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Lo mismo que antes, sólo que con un comando bastante más explícito. ¡Muy útil!"
|
||||
],
|
||||
"command": "git branch -u o/master foo; git commit; git push",
|
||||
"beforeCommand": "git clone; git checkout -b foo"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"¡Perfecto! Para este nivel, haz push de tu trabajo a la rama `master` del remoto *sin* estar parado sobre `master` localmente. Te dejo que te des cuenta del resto solo, que para algo este es el curso avanzado :P"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue