mirror of
https://github.com/pcottle/learnGitBranching.git
synced 2025-08-14 06:58:56 +02:00
Full Spanish translation
This commit is contained in:
mgarciaisaia
parent
f1686932cb
commit
31ea0cedd0
40 changed files with 2397 additions and 4 deletions
|
|
@ -4,6 +4,7 @@ exports.level = {
|
|||
"name": {
|
||||
"en_US": "Clone Intro",
|
||||
"de_DE": "Clone Einführung",
|
||||
"es_AR": "Introducción a clone",
|
||||
"zh_CN": "Clone Intro",
|
||||
"zh_TW": "介紹 clone"
|
||||
},
|
||||
|
|
@ -11,6 +12,7 @@ exports.level = {
|
|||
"en_US": "Just git clone!",
|
||||
"de_DE": "Einfach git clone ausführen!",
|
||||
"zh_CN": "Just git clone!",
|
||||
"es_AR": "Simplemente hacé git clone!",
|
||||
"zh_TW": "只要 git clone 就好了"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -71,6 +73,63 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"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 copadas:",
|
||||
"",
|
||||
"- Primero y principal, los remotos ¡son un genial backup! Los repositorios locales de git tienen la habilidad de restaurar archivos a un estado previo (como ya sabés), pero toda esa información está almacenada localmente. Al tener copias de tu repositorio git en otras computadoras, podés perder todos tus datos locales y aún así retomar de donde 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 el 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 eseñar las bases del trabajo _local_ con repositorios (branchear, 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). Acá 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 hacé `git clone` de tu repositorio existente. El verdadero aprendizaje viene en las próximas lecciones."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -5,12 +5,14 @@ exports.level = {
|
|||
"name": {
|
||||
"en_US": "Faking Teamwork",
|
||||
"de_DE": "Teamarbeit simulieren",
|
||||
"es_AR": "Simulando el trabajo en equipo",
|
||||
"zh_CN": "Faking Teamwork",
|
||||
"zh_TW": "模擬團隊合作"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "remember you can specify the number of commits to fake",
|
||||
"de_DE": "Nicht vergessen, du kannst angeben wieviele Commits simuliert werden sollen.",
|
||||
"es_AR": "Acordate que podés especificar cuántos commits simular",
|
||||
"zh_CN": "记住为fake指定数量",
|
||||
"zh_TW": "你要記得指定要送多少個 commit 出去"
|
||||
},
|
||||
|
|
@ -69,6 +71,60 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Simulando la colaboración",
|
||||
"",
|
||||
"Entonces, hay algo medio tramposo acá -- para algunas de las lecciones siguientes, necesitamos explicarte cómo bajar cambios introducidos en el repositorio remoto.",
|
||||
"",
|
||||
"Eso significa que escencialmente tenemos que \"hacer de cuenta\" que el repositorio remoto fue actualizado por alguú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 auto-explicativo: 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 podés 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.",
|
||||
"",
|
||||
"Animate y creá un remoto (con `git clone`), simulá algunos cambios en ese remoto, commiteá en tu repo local, y luego pulleate esos cambios. ¡Es como varias lecciones en una!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -5,12 +5,14 @@ exports.level = {
|
|||
"name": {
|
||||
"en_US": "Git Fetchin'",
|
||||
"de_DE": "Git Fetch",
|
||||
"es_AR": "git fetch",
|
||||
"zh_CN": "Git Fetchin'",
|
||||
"zh_TW": "git fetch"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "just run git fetch!",
|
||||
"de_DE": "Einfach git fetch ausführen!",
|
||||
"es_AR": "Simplemente ¡hacé git fetch!",
|
||||
"zh_CN": "just run git fetch!",
|
||||
"zh_TW": "只要下 git fetch 指令"
|
||||
},
|
||||
|
|
@ -88,6 +90,79 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"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. 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."
|
||||
],
|
||||
"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 recordás 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 que hablás 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, podés pensar a `git fetch` como un paso de descarga."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, simplemente corré `git fetch` y bajate todos los commits"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Fetch arguments",
|
||||
"zh_CN": "Fetch arguments",
|
||||
"zh_TW": "fetch 的參數",
|
||||
"es_AR": "Parámetros de fetch",
|
||||
"de_DE": "Optionen für Fetch"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Pay attention how the commit ids may have swapped! You can read slides again with \"help 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\"",
|
||||
"de_DE": "Beachte wie die Commit IDs getauscht wurden! Du kannst den Einführungsdialog mit \"help level\" erneut anzeigen"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -138,6 +140,129 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Parámetros de git fetch",
|
||||
"",
|
||||
"Entonces, recién aprendimos todo sobre los parámetros de push, este parámetro `<lugar>` copado, 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 a la vez..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### El parámetro `<lugar>`",
|
||||
"",
|
||||
"Si especificás 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 vos podrías tener trabajo en la rama `foo` que no quieras mezclar. Esto refiere 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 sentís lo suficientemente seguro como para traer commits *directamente* a una rama local, entonces, sí, podés especificarlo usando una referencia con dos puntos. No podés traer commits a una rama que tengas checkouteada, pero en cualquier otro caso git te lo va a permitir.",
|
||||
"",
|
||||
"Este es el único problemita, 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, dificilmente 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": [
|
||||
"¡Wow! Mirá: git resolvió `foo~1` como un lugar en el origin y bajó esos commits a `bar` (que era una rama local). Notá 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 que corra este comando? Veamos el último ejemplo pero sin que `bar` exista de antemano."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Mirá: 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 pushear (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 vale 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, fetcheáte sólo los commits especificados en la visualización del objetivo. ¡Amigate con esos comandos!",
|
||||
"",
|
||||
"Vas a tener que especificar el origen y el destino para ambos comandos fetch. Prestá atención al objetivo dado que ¡los IDs pueden estar invertidos!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Diverged History",
|
||||
"zh_CN": "分散的历史",
|
||||
"zh_TW": "diverged history",
|
||||
"es_AR": "Historia divergente",
|
||||
"de_DE": "Abweichende History"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "check out the ordering from the goal visualization",
|
||||
"zh_CN": "检出可视化目标中的顺序",
|
||||
"zh_TW": "確認視覺化的目標中的順序",
|
||||
"es_AR": "Prestá atención al oren del objetivo",
|
||||
"de_DE": "Beachte die Reihenfolge in der Zieldarstellung"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -158,6 +160,149 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Trabajo divergente",
|
||||
"",
|
||||
"Hasta acá vimos cómo pullear commits de otros y cómo pushear 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": [
|
||||
"Imaginate que clonás un repositorio el lunes y empezás a desarrollar algo. Para el viernes ya estás listo para publicar tu trabajo, pero, ¡oh, oh! Tus colegas también escribieron 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 corrés `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 que la historia divirgió), git no te permite pushear 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 resolvés esta situación? Es fácil, todo lo que tenés 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 mejor rebaseamos antes de pushear..."
|
||||
],
|
||||
"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",
|
||||
"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 rebasear hacemos un merge..."
|
||||
],
|
||||
"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",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"¡Asombroso! ¿Hay forma de hacer esto sin tipear tantos comandos?",
|
||||
"",
|
||||
"¡Claro que sí! Ya sabés 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 esta movida de fetchear, rebasear/mergear y pushear es bastante común. En lecciones futuras vamos a ver formas más complejas de estos flujos de trabajo, pero por ahora probemos esto que vimos.",
|
||||
"",
|
||||
"Para resolver este nivel, hacé lo siguiente:",
|
||||
"",
|
||||
"* Cloná tu repositorio",
|
||||
"* Simulá algo de trabajo de un colega (1 commit)",
|
||||
"* Commiteá algo de trabajo propio (1 commit)",
|
||||
"* Publicá tu trabajo *rebaseando*"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Merging with remotes",
|
||||
"zh_CN": "Merging with remotes",
|
||||
"zh_TW": "merge with remotes",
|
||||
"es_AR": "Mergeando con los remotos",
|
||||
"de_DE": "Änderungen vom Remote zusammenführen"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Pay attention to the goal tree!",
|
||||
"zh_CN": "注意目标树!",
|
||||
"zh_TW": "注意最後要完成的目標！",
|
||||
"es_AR": "¡Prestá atención al árbol final!",
|
||||
"de_DE": "Beachte den Ziel-Baum!"
|
||||
},
|
||||
"compareOnlyMaster": true,
|
||||
|
|
@ -61,6 +63,51 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"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`).",
|
||||
"",
|
||||
"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?",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Hay mucho debate entre los desarrolladores sobre los pros y contras de mergear vs rebasear. Acá tenemos 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 aman preservar la historia, por lo que prefieren 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 ponerse un poco oscuro, pero ilustra la idea bastante bien."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Git Pullin'",
|
||||
"zh_CN": "Git Pullin'",
|
||||
"zh_TW": "git pull'",
|
||||
"es_AR": "git pull",
|
||||
"de_DE": "Git Pull"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Just run git pull!",
|
||||
"zh_CN": "Just run git pull!",
|
||||
"zh_TW": "只要下 git pull 這個指令即可",
|
||||
"es_AR": "Simplemente ¡hacé git pull!",
|
||||
"de_DE": "Führe einfach git pull aus."
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -74,6 +76,65 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"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 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`",
|
||||
"* 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": [
|
||||
"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`)"
|
||||
],
|
||||
"command": "git fetch; git merge o/master",
|
||||
"beforeCommand": "git clone; git commit; git fakeTeamwork"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿Qué pasaría si usáramos `git pull` en cambio?"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Lo mismo! Eso debería dejar bien en claro que `git pull` es básicamente un atajo para hacer `git fetch` seguido por un merge con la rama que sea que hayamos bajado."
|
||||
],
|
||||
"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.",
|
||||
"",
|
||||
"Acordate: podés resolver este comando simplemente con `fetch` y `merge`, pero eso te costaría un comando extra :P"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Pull arguments",
|
||||
"zh_CN": "Pull arguments",
|
||||
"zh_TW": "pull 的參數",
|
||||
"es_AR": "Parámetros de pull",
|
||||
"de_DE": "Optionen für Pull"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember that you can create new local branches with fetch/pull arguments",
|
||||
"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",
|
||||
"de_DE": "Du kannst neue lokale Branches mittels fetch / pull erstellen"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -89,6 +91,80 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Parámetros de git pull",
|
||||
"",
|
||||
"Ahora que sabés prácticamente *todo* lo que hay que saber sobre los parámetros de `git fetch` y `git push`, casi que no queda nada para cubrir de git pull :)",
|
||||
"",
|
||||
"Eso es porque git pull es simplemente un atajo para hacer un fetch seguido de un merge. Podés pensarlo como correr git fetch con los *mismos* parámetros, y después mergear aquello a donde esos commits hayan ido a parar.",
|
||||
"",
|
||||
"Esto aplica incluso cuando usás parámetros hiper-rebuscados. 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 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."
|
||||
],
|
||||
"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": [
|
||||
"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!!!"
|
||||
],
|
||||
"command": "git pull origin master:foo",
|
||||
"beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"OK: para terminar, alcanzá 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"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Git Pushin'",
|
||||
"zh_CN": "Git Pushin'",
|
||||
"zh_TW": "git push",
|
||||
"es_AR": "git push",
|
||||
"de_DE": "Git Push"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember you have to clone before you can push!",
|
||||
"zh_CN": "push之前你需要先克隆.",
|
||||
"zh_TW": "push 之前你需要先 clone",
|
||||
"es_AR": "¡Acordate que tenés que clonar antes de pushear!",
|
||||
"de_DE": "Denk dran, dass du einen Clone brauchst bevor du Pushen kannst!"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -56,6 +58,47 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## git push",
|
||||
"",
|
||||
"Ok, entonces ya bajé los cambios de un repositorio remoto y los integré en mi trabajo localmente. Esto es genial y todo... 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.",
|
||||
"",
|
||||
"Podés pensar en `git push` como un comando para \"publicar\" tu trabajo. Tiene un par de sutilezas con las que vamos a meternos pronto, pero empecemos de a poco."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"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!"
|
||||
],
|
||||
"command": "git push",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, simplemente compartí dos nuevos commits con el remoto. Igual, no te confíes, ¡ya se van a complicar las lecciones!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -9,11 +9,13 @@ exports.level = {
|
|||
"en_US": "Git push arguments",
|
||||
"zh_CN": "Git push 参数",
|
||||
"zh_TW": "git push 的參數",
|
||||
"es_AR": "Parámetros de git push",
|
||||
"de_DE": "Optionen für Git Push"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "You can always look at the last slide of the dialog with \"objective\"",
|
||||
"zh_TW": "你可以利用 \"objective\" 來閱讀對話視窗的最後一頁",
|
||||
"es_AR": "Siempre podés ver el último mensaje tipeando \"objective\"",
|
||||
"de_DE": "Du kannst dir die Zielsetzung des Levels immer wieder mit \"objective\" anzeigen lassen"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -89,6 +91,78 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Parámetros de push",
|
||||
"",
|
||||
"¡Genial! Ahora que sabés acerca de las ramas que trackean remotos podemos empezar a develar algo del misterio detrás de git push, fetch y pull. Vamos a atacar de a un comando a la 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 default 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? Ya vamos a entrar en detalle, pero primero un ejemplo. Correr el comando:",
|
||||
"",
|
||||
"`git push origin master`",
|
||||
"",
|
||||
"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.*",
|
||||
"",
|
||||
"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. Notá en 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 podés ver), porque `HEAD` no está sobre ninguna rama que trackee algún remoto."
|
||||
],
|
||||
"command": "git checkout C0; git push",
|
||||
"beforeCommand": "git clone; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"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!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Git push arguments -- Expanded!",
|
||||
"zh_CN": "Git push 参数2!",
|
||||
"zh_TW": "git push 的參數，延伸討論！",
|
||||
"es_AR": "¡Más! Parámetros de git push",
|
||||
"de_DE": "Optionen fü Git Push -- noch mehr!"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember you can admit defeat and type in \"show solution\" :P",
|
||||
"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",
|
||||
"de_DE": "Vergiss nicht dass du aufgeben kannst, indem du \"show solution\" eingibst :P"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -85,6 +87,76 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"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.",
|
||||
"",
|
||||
"Podrías estár preguntándote ¿Y si quisieramos que el origen y el destino sean distintos? ¿Si quisieras pushear los commits de la rama local `foo` a la rama `bar` del remote?",
|
||||
"",
|
||||
"Bueno, lamentablemente eso no se puede hacer en git... ¡Bazinga! Claro que se puede :)... git es extremadísimamente flexible (casi casi que demsiado).",
|
||||
"",
|
||||
"Veamos cómo hacerlo a continuación..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para especificar tanto el origen como el destino de `<lugar>`, simplemente unilos usando un dos puntos:",
|
||||
"",
|
||||
"`git push origin <origen>:<destino>`",
|
||||
"",
|
||||
"Esto se lo suele llamar refspec con dos puntos. Refspec es simplemente un nombre cool para una ubicación que git puede entender (como la rama `foo`, o incluso `HEAD~1`)",
|
||||
"",
|
||||
"Una vez que especificás tanto el origen como el destino independientemente, podés ponerte bastante cómodo y preciso con los comandos remotos. ¡Veámos una demo!"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Recordá: `origen` es cualquier ubicación que git pueda entender:"
|
||||
],
|
||||
"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",
|
||||
"beforeCommand": "git clone; go -b foo; git commit; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"¿Y qué hay si el destino que al querés pushear no existe? ¡No hay drama! Simplemente dale un nombre al branch 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, tratá de llegar al objetivo final, y acordate del formato:",
|
||||
"",
|
||||
"`<origen>:<destino>`"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Remember you can always use the undo or reset commands",
|
||||
"zh_CN": "你随时都可以使用undo/reset命令.",
|
||||
"zh_TW": "你隨時都可以使用 undo 或 reset 指令。",
|
||||
"es_AR": "Acordate que siempre podés usar los comandos reset y undo",
|
||||
"de_DE": "Denk dran, du kannst immer undo oder reset benutzen, um deine Befehle zurück zu nehmen."
|
||||
},
|
||||
"name": {
|
||||
"en_US": "Push Master!",
|
||||
"zh_CN": "Push Master!",
|
||||
"zh_TW": "push master！",
|
||||
"es_AR": "¡Push Master!",
|
||||
"de_DE": "Push Master!"
|
||||
},
|
||||
"compareOnlyMasterHashAgnostic": true,
|
||||
|
|
@ -69,6 +71,59 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Mergeando feature branches",
|
||||
"",
|
||||
"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.",
|
||||
"",
|
||||
"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": [
|
||||
"Acá 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. Acá tenés algunos lineamientos para resolverlo:",
|
||||
"",
|
||||
"* Tenemos tres ramas específicas -- `side1` `side2` and `side3`",
|
||||
"* Queremos pushear 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 ¡Intenso! ¡Éxitos! Completar este nivel representa un gran avance."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Remote Branches",
|
||||
"zh_CN": "Remote Branches",
|
||||
"zh_TW": "remote branch （遠端分支）",
|
||||
"es_AR": "Ramas remotas",
|
||||
"de_DE": "Branches auf entfernten Servern"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Pay attention to the ordering -- commit on master first!",
|
||||
"zh_CN": "Pay attention to the ordering -- commit on master first!",
|
||||
"zh_TW": "注意順序的問題喔！先在 master branch 上面送 commit",
|
||||
"es_AR": "Prestá atención al orden: ¡commiteá sobre master primero!",
|
||||
"de_DE": "Beachte die Sortierung -- committe zuerst auf dem master!"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -76,6 +78,67 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"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 (como 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 las checkouteás, pasás al modo detached `HEAD`. Git lo hace a propósito porque no podés trabajar en esas ramas directamente: tenés 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 las muestra con el formato:",
|
||||
"",
|
||||
"* `<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`.",
|
||||
"",
|
||||
"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.",
|
||||
"",
|
||||
"Desafortunadamente el nombre `origin` completo no entra en nuestra UI, así que usamos `o` para abreviar :( Simplemente recordá que cuando uses el git real, tu remoto ¡probablemente se llame `origin`!",
|
||||
"",
|
||||
"Hay mucho para procesar, así que veámoslo en acción."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"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."
|
||||
],
|
||||
"command": "git checkout o/master; git commit",
|
||||
"beforeCommand": "git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"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."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Source of nothing",
|
||||
"zh_CN": "没有source",
|
||||
"zh_TW": "沒有 source",
|
||||
"es_AR": "Origen de nada",
|
||||
"de_DE": "Die Quelle des Nichts"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "The branch command is disabled for this level so you'll have to use fetch!",
|
||||
"zh_CN": "本节的分支命令被禁用了, 你只能使用fetch! ",
|
||||
"zh_TW": "在本關卡中，不允許使用 branch 指令，因此你只能使用 fetch！",
|
||||
"es_AR": "El comando branch está deshabilitado para este nivel, así que ¡vas a tener que usar fetch!",
|
||||
"de_DE": "Der branch Befehl ist für diesen Level inaktiv, du musst also fetch benutzen"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -68,6 +70,59 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"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 tecnicamente podés 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 pushear \"nada\" a una rama remota? ¡La elimina!"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"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"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Finalmente, fetchear \"nada\" a un lugar local en realidad crea una nueva rama"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Bastante bizarro, pero, meh, da igual. Así es git."
|
||||
],
|
||||
"command": "git fetch origin :bar",
|
||||
"beforeCommand": "git clone"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Este es un nivel rápido: simplemente borrá una rama remota y creá una nueva usando `git fetch` para completarlo."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ exports.level = {
|
|||
"en_US": "Remote Tracking",
|
||||
"zh_CN": "Remote Tracking",
|
||||
"zh_TW": "remote tracking",
|
||||
"es_AR": "Trackeando remotos",
|
||||
"de_DE": "Remote Tracking"
|
||||
},
|
||||
"hint": {
|
||||
"en_US": "Remember there are two ways to set remote tracking!",
|
||||
"zh_CN": "有两种设置无端跟踪的方法!",
|
||||
"zh_TW": " 記住喔，有兩個方式可以去設定 remote tracking",
|
||||
"es_AR": "¡Acordate de que hay dos formas de trackear un remoto!",
|
||||
"de_DE": "Nicht vergessen, es gibt zwei Arten Remote Tracking einzurichten!"
|
||||
},
|
||||
"startDialog": {
|
||||
|
|
@ -133,6 +135,126 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_AR": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Ramas que trackean remotos",
|
||||
"",
|
||||
"Una de las cosas que 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",
|
||||
"",
|
||||
"Haciéndola corta, 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 vos no corriste ningún comando para especificarlo. Bueno, cuando clonás un repositorio con git, esta propiedad se asigna por vos 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 tenés una única rama local (para que no te asustes) pero podés ver todas las ramas que del remoto (si fueras tan 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í! Podés 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 signfica que podés correr `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 checkoutear 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": [
|
||||
"Suficiente charla, ¡veamos una demo! Vamos a checkoutear una nueva rama llamada `foo` y hacer que trackee a `master` en el remoto."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Como podés ver, usamos el objetivo implícito de merge `o/master` para actualizar la rama `foo`. ¡Notá 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": [
|
||||
"Boom. Pusheamos 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 podés 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. ¡Una belleza!"
|
||||
],
|
||||
"command": "git branch -u o/master foo; git commit; git push",
|
||||
"beforeCommand": "git clone; git checkout -b foo"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"¡Ok! Para este nivel, pusheá 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"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"zh_TW": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue