Merge pull request #1089 from casillas-m/es_MX

Added es_MX to multiple levels

src/levels/mixed/describe.js

@@ -16,6 +16,7 @@ exports.level = {
     "de_DE": "Git Describe",
     "ja": "Git Describe",
     "es_AR": "Git Describe",
+    "es_MX": "Git Describe",
     "es_ES": "Git Describe",
     "pt_BR": "Git Describe",
     "gl": "Git Describe",
@@ -35,6 +36,7 @@ exports.level = {
     "de_DE": "Committe nur einmal auf bugFix, wenn du soweit bist",
     "ja": "次に進む準備が整ったなら、bugFixに対して一回commitしてください",
     "es_AR": "Simplemente commiteá una vez en bugFix cuando estés listo para seguir",
+    "es_MX": "Simplemente crea un commit en la rama bugFix cuando estés listo para continuar",
     "es_ES": "Simplemente crea un commit en la rama bugFix cuando estés listo para seguir",
     "pt_BR": "Simplesmente commite uma vez em bugFix quando quiser parar de experimentar",
     "gl": "Simplemente fai commit en bugFix cando estés listo para continuar.",
@@ -366,6 +368,69 @@ exports.level = {
         }
       ]
     },
+    "es_ES": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Git Describe",
+              "",
+              "Como los tags sirven genial como \"marcas\" en el código, git tiene un comando para _describir_ dónde estás relativo a la \"marca\" (es decir, al \"tag\") más cercana. Y ese comamndo se llama ¡`git describe`!",
+              "",
+              "`git describe` puede ayudarte a saber dónde estás después de haberte movido varios commits hacia adelante o atrás en la historia. Esto puede pasarte después de que termines un _git bisect_ (una búsqueda de debug) o cuando te sientas delante de la computadora de un compañero de trabajo que acaba de volver de vacaciones."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Git describe tiene la siguiente forma:",
+              "",
+              "`git describe <ref>`",
+              "",
+              "Donde `<ref>` es cualquier cosa que git puede resolver a un commit. Si no especificas ninguna referencia, git simplemente usa el commit en el que estás en ese momento (`HEAD`).",
+              "",
+              "La salida de ese comando se ve así:",
+              "",
+              "`<tag>_<numCommits>_g<hash>`",
+              "",
+              "Donde `tag` es el tag más cercano en la historia, `numCommits` es a cuántos commits de ese tag estás, y `<hash>` es el hash del commit que está siendo descrito."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Veamos un ejemplo rápido. Para este árbol de commits:"
+            ],
+            "afterMarkdowns": [
+              "El comando `git describe main` mostraría:",
+              "",
+              "`v1_2_gC2`",
+              "",
+              "Mientras que `git describe side` mostraría:",
+              "",
+              "`v2_1_gC4`"
+            ],
+            "command": "git tag v2 C3",
+            "beforeCommand": "git commit; go -b side HEAD~1; gc; gc; git tag v1 C0"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "¡Eso es prácticamente todo lo que hay sobre git describe! Prueba describiendo algunas _ubicaciones_ en este nivel para familiarizarte con el comando.",
+              "",
+              "Cuando estés listo, crea un commit para terminar el nivel. Te estamos dejando este nivel de regalo. :P"
+            ]
+          }
+        }
+      ]
+    },
     "es_ES": {
       "childViews": [
         {

src/levels/rebase/manyRebases.js

@@ -11,6 +11,7 @@ exports.level = {
     "en_US": "Rebasing over 9000 times",
     "de_DE": "10000 Rebases unter dem `HEAD`",
     "es_AR": "Rebaseando más de 9000 veces",
+    "es_MX": "Rebaseando más de 8000... veces",
     "es_ES": "Rebaseando más de 9000 veces",
     "pt_BR": "Fazendo mais de 9000 rebases",
     "gl": "Facendo máis de 9000 rebases",
@@ -30,6 +31,7 @@ exports.level = {
     "en_US": "Remember, the most efficient way might be to only update main at the end...",
     "de_DE": "Nicht vergessen: Nur den main zu aktualisieren könnte die effizienteste Möglichkeit sein ...",
     "es_AR": "Acordate, la manera más eficiente podría ser actualizar main sólo al final...",
+    "es_MX": "Recuerda, la manera más eficiente podría ser actualizar main hasta el final...",
     "es_ES": "Recuerda, la manera más eficiente podría ser actualizar main sólo al final...",
     "pt_BR": "Lembre-se, a forma mais eficiente pode ser atualizar o main por último...",
     "gl": "Lembra, a forma máis eficiente pode ser actualizar a rama main ó final...",
@@ -83,6 +85,24 @@ exports.level = {
         }
       ]
     },
+    "es_MX": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Rebaseando múltiples ramas",
+              "",
+              "Mira eso, ¡hay un montón de ramas aquí! Hagamos rebase de todo el trabajo de esas ramas hacia main.",
+              "",
+              "La alta dirección nos está haciendo las cosas un poco más complicadas -- quieren que nuestros commits estén todos en orden secuencial. Esto significa que nuestro árbol final tendría que tener `C7'` al final, `C6'` antes de ese, y así, todos en orden.",
+              "",
+              "Si te revuelves durante el camino, siéntete libre de usar `reset` para empezar de nuevo. ¡Asegúrate de verificar nuestra solución y ver si puedes lograrlo en un número menor de comandos!"
+            ]
+          }
+        }
+      ]
+    },
     "es_ES": {
       "childViews": [
         {
@@ -95,7 +115,7 @@ exports.level = {
               "",
               "La gente de administración nos está haciendo las cosas un poco complicadas, igual -- quieren que nuestros commits estén todos en orden secuencial. Esto significa que nuestro árbol final tendría que tener `C7` al final, `C6` antes de ese, y así siguiendo, todos en orden.",
               "",
-              "Si te haces un lío durante el proceso, siéntete libre de usar `reset` para empezar de nuevo. ¡Asegúrate de verificar tu solución y ver si puedes realizarla en un número inferior de commandos!"
+              "Si te haces un lío durante el proceso, siéntete libre de usar `reset` para empezar de nuevo. ¡Asegúrate de verificar tu solución y ver si puedes realizarla en un número inferior de comandos!"
             ]
           }
         }

src/levels/rebase/selectiveRebase.js

@@ -12,6 +12,7 @@ exports.level = {
     "fr_FR": "Branche spaghetti",
     "de_DE": "Branch-Spaghetti",
     "es_AR": "Ensalada de branches",
+    "es_MX": "Espagueti de ramas",
     "es_ES": "Ensalada de ramas",
     "pt_BR": "Espaguete de ramos",
     "gl": "Espaguete de ramas",
@@ -30,6 +31,7 @@ exports.level = {
     "fr_FR": "Faites attention à tout faire dans le bon ordre ! La première branche d'abord, puis la seconde, puis la troisième",
     "de_DE": "Stelle sicher, dass du alles in der richtigen Reihenfolge machst! Branche erst one, dann two, dann three.",
     "es_AR": "¡Asegurate de hacer las cosas en el orden correcto! Brancheá `one` primero, después `two`, y después `three`.",
+    "es_MX": "¡Asegúrate de hacer las cosas en el orden correcto! Primero la rama uno, después la dos, y después la tres.",
     "es_ES": "¡Asegúrate de hacer las cosas en el orden correcto! Crea primero la rama `one`, después `two`, y después `three`.",
     "pt_BR": "Certifique-se de fazer tudo na ordem correta! Crie o ramo `one` primeiro, depois `two`, depois `three`.",
     "gl": "¡Afiánzate de facer as cousas no orde correcto! Crea ramas `one` de primeiras, e logo `two` e `three`.",
@@ -105,6 +107,26 @@ exports.level = {
         }
       ]
     },
+    "es_MX": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Espagueti de ramas",
+              "",
+              "¡Oh vaya! Tenemos un _pequeño_ objetivo al que llegar en este nivel.",
+              "",
+              "La rama `main` se encuentra algunos commits por delante de las ramas `one`, `two` y `three`. Por alguna razón, necesitamos actualizar esas tres ramas con versiones modificadas de los últimos commits de main.",
+              "",
+              "La rama `one` necesita esos commits reordenados, y eliminar/excluir a `C5`. La rama `two` sólo necesita reordenarlos, y `three` ¡sólo necesita avanzar un commit!",
+              "",
+              "Vamos a dejar que averigues cómo resolver este -- asegúrate de revisar nuestra solución después, usando `show solution`. "
+            ]
+          }
+        }
+      ]
+    },
     "es_ES": {
       "childViews": [
         {

src/levels/remote/fetch.js

@@ -8,6 +8,7 @@ exports.level = {
     "de_DE": "Git Fetch",
     "ja": "Git Fetch",
     "es_AR": "git fetch",
+    "es_MX": "Git fetch",
     "es_ES": "git fetch",
     "pt_BR": "Git Fetch",
     "gl": "Git Fetch",
@@ -27,6 +28,7 @@ exports.level = {
     "de_DE": "Einfach git fetch ausführen!",
     "ja": "単にgit fetchを実行！",
     "es_AR": "Simplemente ¡hacé git fetch!",
+    "es_MX": "Simplemente ¡escribe git fetch!",
     "es_ES": "Simplemente ¡escribe git fetch!",
     "pt_BR": "Simplesmente chame git fetch!",
     "gl": "¡Sinxelamente fai git fetch!",
@@ -260,6 +262,79 @@ exports.level = {
         }
       ]
     },
+    "es_MX": {
+      "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 a otro, podemos compartir cualquier tipo de actualización monitoreada por git (y, por lo tanto, compartir trabajo, archivos nuevos, ideas nuevas, cartas de amor, etc.).",
+              "",
+              "En esta lección vamos a aprender cómo traer datos _desde_ un repositorio remoto - el comando para esto se llama, `git fetch`.",
+              "",
+              "Vas a notar que a medida que actualicemos nuestra representación del repositorio remoto, nuestras ramas _remotas_ van a actualizarse para reflejar esa nueva representación. Esto va 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": [
+              "¡Ahí está! Descargamos los commits `C2` y `C3` a nuestro repositorio local, y nuestra rama remota `o/main` fue actualizada para reflejar este cambio."
+            ],
+            "command": "git fetch",
+            "beforeCommand": "git clone; git fakeTeamwork 2"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### ¿Qué hace fetch?",
+              "",
+              "`git fetch` hace principalmente dos pasos, y sólo esos dos pasos:",
+              "",
+              "* descarga 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/main`)",
+              "",
+              "`git fetch` escencialmente pone nuestra representación _local_ del repositorio remoto en sincronía con el _verdadero_ estado del repositorio remoto (en ese momento).",
+              "",
+              "Si recuerdas la lección anterior, dijimos que las ramas remotas reflejan el estado de los repositorios remotos _desde_ la última vez que te comunicaste con ellos. ¡`git fetch` es la manera con la que te comunicas con esos remotos! Espero que la relación entre las ramas remotas y `git fetch` sea evidente ahora.",
+              "",
+              "`git fetch` usualmente habla con el repositorio remoto a través de internet (mediante un protocolo como `http://` o `git://`).",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### ¿Qué *no* hace fetch?",
+              "",
+              "Sin embargo, `git fetch` no modifica en nada _tu_ estado local. No va a actualizar tu rama `main` ni va a cambiar nada sobre cómo se ve tu sistema de archivos en ese momento.",
+              "",
+              "Es importante entender esto, porque un montón de desarrolladores piensan que correr `git fetch` hará que su trabajo local refleje el estado del remoto. Puede que `git fetch` descargue los datos necesarios para hacerlo, pero realmente *no* cambia ninguno de tus archivos locales. Vamos a aprender otros comandos para hacer eso más adelante. :D",
+              "",
+              "Así que, a fin de cuentas, puedes imaginar a `git fetch` como un proceso de descarga."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Para completar este nivel, simplemente ejecuta `git fetch` y descarga todos los commits."
+            ]
+          }
+        }
+      ]
+    },
     "es_ES": {
       "childViews": [
         {

src/levels/remote/pullArgs.js

@@ -7,6 +7,7 @@ exports.level = {
     "zh_CN": "Git pull 的参数",
     "zh_TW": "pull 的參數",
     "es_AR": "Parámetros de pull",
+    "es_MX": "Parámetros de pull",
     "es_ES": "Parámetros de pull",
     "pt_BR": "Parâmetros do pull",
     "gl": "Parámetros de pull",
@@ -26,6 +27,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_MX": "Recuerda que puedes 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",
@@ -263,6 +265,80 @@ exports.level = {
         }
       ]
     },
+    "es_MX": {
+      "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 revisar del comando git pull :)",
+              "",
+              "Eso es porque, al final, 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 hacia donde esos commits hayan quedado.",
+              "",
+              "Esto aplica incluso cuando utilizas parámetros absurdamente complicados. 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 hacemos merge con lo que se obtuvo de fetch."
+            ],
+            "afterMarkdowns": [
+              "¡Ves! Especificando `main` descargamos los commits a `o/main` como siempre. Después hacemos merge de `o/main` a nuestra rama actual, la cual *no* es la rama local `main`. Por este motivo puede hacer sentido ejecutar git pull múltiples ocasiones (con los mismos argumentos) desde diferentes ubicaciones con el fin de actualizar múltiples ramas."
+            ],
+            "command": "git pull origin main",
+            "beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "¿Esto también funciona especificando origen y destino? ¡Puedes apostarlo! Veámoslo:"
+            ],
+            "afterMarkdowns": [
+              "Increible, eso es MUCHISIMO en un único comando. Creamos una nueva rama local llamada `foo`, descargamos los commits del main remoto a la rama `foo`, y después hicimos merge esa rama a nuestra rama actual `bar`. ¡¡¡Su poder es de más de 8000!!!"
+            ],
+            "command": "git pull origin main: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 hacer merge de esas ramas junto con otras, pero no debería llevarte demasiados comandos :P"
+            ]
+          }
+        }
+      ]
+    },
     "es_ES": {
       "childViews": [
         {

src/levels/remote/remoteBranches.js

@@ -7,6 +7,7 @@ exports.level = {
     "zh_CN": "远程分支",
     "zh_TW": "remote branch （遠端分支）",
     "es_AR": "Ramas remotas",
+    "es_MX": "Ramas remotas",
     "es_ES": "Ramas remotas",
     "pt_BR": "Ramos remotos",
     "gl": "Ramas remotas",
@@ -26,6 +27,7 @@ exports.level = {
     "zh_CN": "注意顺序 —— 先在 main 分支上提交!",
     "zh_TW": "注意順序的問題喔！先在 main branch 上面送 commit",
     "es_AR": "Prestá atención al orden: ¡commiteá sobre main primero!",
+    "es_MX": "Presta atención al orden: ¡haz commit sobre main primero!",
     "es_ES": "Presta atención al orden: ¡haz commit sobre main primero!",
     "pt_BR": "Preste atenção na ordem: commite no main primeiro!",
     "gl": "Preta atención á orde: fai commit no main primeiro",
@@ -226,6 +228,69 @@ exports.level = {
         }
       ]
     },
+    "es_MX": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Ramas remotas de git",
+              "",
+              "Ahora que viste `git clone` en acción, profundicemos en lo que realmente cambió.",
+              "",
+              "Lo primero que habrás notado es que apareció una nueva rama en nuestro repositorio local llamada `o/main`. A este tipo de ramas se les llama ramas _remotas_. Las ramas remotas tienen propiedades especiales porque sirven para un propósito específico.",
+              "",
+              "Las ramas remotas reflejan el _estado_ de los repositorios remotos (como estaban la última vez que te comunicaste 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 cual tus ramas remotas serán actualizadas).",
+              "",
+              "Para ser claros: Las ramas remotas están en tu repositorio local, no en el repositorio remoto"
+            ]
+          }
+        },
+        {
+          "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 siguiente formato:",
+              "",
+              "* `<nombre del remoto>/<nombre de la rama>`",
+              "",
+              "Entonces, si observas una rama llamada `o/main`, el nombre de la rama es `main`, y el nombre del remoto es `o`.",
+              "",
+              "Realmente, la mayoría de los desarrolladores llaman `origin` a su remoto en lugar de `o`. Esto es tan común que git directamente crea tu remoto llamándolo `origin` cuando haces `git clone` de un repositorio.",
+              "",
+              "Desafortunadamente, el nombre `origin` no cabe 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`!",
+              "",
+              "Eso es mucho para digerir, así que veámoslo en acción."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Hagamos checkout sobre una rama remota y veamos qué pasa."
+            ],
+            "afterMarkdowns": [
+              "Como puedes ver, git nos puso en el modo detached `HEAD` y no actualizó `o/main` cuando creamos un nuevo commit. Esto es porque `o/main` sólo va a actualizarse cuando el remoto se actualice."
+            ],
+            "command": "git checkout o/main; git commit",
+            "beforeCommand": "git clone"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Para terminar este nivel, haz un commit sobre `main` y uno después de hacer checkout a `o/main`. Esto te va a ayudar a aprender cómo se comportan las ramas remotas, y que sólo se actualizan para reflejar el estado del remoto."
+            ]
+          }
+        }
+      ]
+    },
     "es_ES": {
       "childViews": [
         {