Git

El panel Version Control lleva tu proyecto con Git sin salir del IDE: ves qué ficheros han cambiado, haces commits, creas ramas y cambias de una a otra, miras el historial y subes y bajas tus cambios de un servidor (GitHub, GitLab o el tuyo).

Se abre con Home › View › Git. Es un panel como los demás (La interfaz).

• Trabaja sobre la carpeta del proyecto abierto. Sin proyecto, el panel sale vacío.
• Hace falta tener Git instalado: el panel ejecuta el comando git para todo, así que tiene que funcionar desde una consola. Git también tiene que saber tu nombre y tu correo (mira «Crear el repositorio»).
• No enseña qué líneas han cambiado ni deja descartar cambios. Para eso, usa otra herramienta de Git sobre la misma carpeta.

Un recorrido

Un proyecto con Git, desde el primer commit hasta el servidor.

1. Crea el repositorio. Abre el panel. Si el proyecto no tiene repositorio, dice «This project is not under version control yet.»: pulsa Initialize Repository. El IDE crea el repositorio y hace un primer commit con todos los ficheros.
2. Cambia algo. Edita un fichero y guárdalo. En el panel, pulsa el botón de refrescar, la flecha redonda que hay a la derecha de History: el fichero sale en Unstaged como Modified.
3. Prepáralo. Elígelo y pulsa Stage, o pulsa Stage All para pasarlos todos: sale en Staged.
4. Haz el commit. Borra el texto de la casilla de abajo, escribe qué has cambiado y pulsa Commit.
5. Súbelo. Crea un repositorio vacío en tu servidor y copia su dirección. Pulsa Remote Config, pégala en Remote Repository URL y pulsa Connect and Push. El Output cuenta cómo va.

Crear el repositorio

Si la carpeta del proyecto no tiene repositorio (no hay .git), el panel solo enseña Initialize Repository. Al pulsarlo, el IDE:

1. crea el repositorio (git init);
2. pasa a Staged todos los ficheros de la carpeta, menos los que deje fuera un .gitignore;
3. hace el primer commit, con el mensaje First commit.

También lo puedes crear al hacer el proyecto, con la casilla Initialize Git repository del asistente (Proyectos). Esa casilla escribe además un .gitignore, que deja fuera la carpeta Build y otros ficheros que no hacen falta. El botón del panel no lo escribe: su primer commit se lleva todo lo que haya en la carpeta, Build incluida. Si no la quieres en el repositorio, crea antes en la carpeta del proyecto un .gitignore con la línea Build/.

Dile a Git quién eres

Cada commit lleva tu nombre y tu correo, y el IDE no te los pide. Si Git no los tiene, el commit falla y el Output dice por qué. Pónselos una vez, desde una consola:

git config --global user.name "Tu nombre"
git config --global user.email "tu@correo.com"

Estado de los ficheros

La vista principal tiene, de arriba abajo:

• la rama actual, en una lista desplegable, y New Branch;
• Fetch, Pull, Push, History y el botón de refrescar;
• Staged: lo que entra en el próximo commit;
• Unstaged: el resto de ficheros del proyecto;
• la casilla del mensaje y Commit;
• la lista de ramas.

El panel no vigila el disco: lo que guardes no sale hasta que pulses el botón de refrescar. Se pone al día solo al abrirlo, al cambiar de proyecto y después de cada operación.

Unstaged enseña el resto: los ficheros que han cambiado, los nuevos y también los que no han cambiado. Cada fichero lleva su estado, con su color:

Estado	Qué quiere decir
Modified	Ha cambiado desde el último commit.
Untracked	Es nuevo: Git todavía no lo sigue.
Deleted	Lo has borrado.
Staged	Es nuevo y ya está en Staged.
Renamed	Lo has renombrado.
Conflict	Ha chocado en un merge o un pull (mira «Ramas»).
Unmodified	No ha cambiado.

Para pasar ficheros de una lista a otra:

• Stage pasa a Staged el fichero elegido en Unstaged. Se elige uno cada vez.
• Stage All pasa a Staged todo lo que ha cambiado, también los ficheros nuevos y los borrados.
• Unstage saca de Staged el fichero elegido.
• El botón derecho, en las dos listas, tiene también Stage y Unstage.

Commit

Escribe el mensaje en la casilla de abajo y pulsa Commit. El commit se lleva lo que hay en Staged; lo que sigue en Unstaged se queda fuera. Al acabar, la casilla se vacía y las listas se ponen al día.

• Sin mensaje, no hace nada y te lo dice: «Please enter a commit message.».
• Sin nada en Staged, Git no hace el commit: sale «Error committing changes.», y el motivo, en el Output.

La casilla no está vacía

Al abrir el panel, la casilla trae escrito «Briefly describe the changes made.». No es una pista, es texto: bórralo antes de escribir, o irá en el mensaje del commit.

Ramas

La rama actual sale arriba, en la lista desplegable, y abajo, en la lista de ramas, con un * delante. La lista de abajo tiene todas: las tuyas (Local) y las del servidor (Remote, como origin/main), que salen después de un Fetch, un Pull o un Push.

• New Branch pide el nombre de la rama. Crea la rama en el commit actual y cambia a ella. Lo que no tenga commit pasa contigo a la rama nueva. El nombre no puede llevar espacios.
• Para cambiar de rama, elígela en la lista de arriba o haz doble clic en ella en la de abajo. Solo puedes cambiar a una rama local: para trabajar en una del servidor, crea antes, desde una consola, una rama local que la siga.

El botón derecho, en la lista de abajo:

• Switch to this branch (checkout): cambia a esa rama.
• Merge into current branch...: después de preguntar, une esa rama a la actual (git merge). Solo con ramas locales.
• Delete local branch...: después de preguntar, borra la rama. No borra la actual. Si la rama tiene commits que no se han unido a la actual, Git no la borra y lo dice en el Output.
• Delete remote branch...: después de un aviso, borra la rama del servidor (origin).

Al cambiar de rama, el IDE guarda antes todo lo que tengas sin guardar en los editores, como Home › Project › Save, y cambia sin forzar: los cambios sin commit de los ficheros que la otra rama no toca pasan contigo a ella. Si la otra rama cambia un fichero en el que tienes cambios sin commit, Git no cambia de rama: el IDE te avisa y el Output dice qué fichero es. Haz commit de ese cambio, o deshazlo, y vuelve a probar.

Después, el IDE mira qué ficheros son distintos. Si cambia el .jpr del proyecto, te pregunta si recarga el proyecto entero. Si cambia un fichero que tienes abierto en un editor (el de código, el de imágenes, el de sprites, el Music Tracker, el de mapas o el de escenas), te pregunta si lo recarga.

Si un merge (o un pull) choca, los ficheros en conflicto salen en Unstaged como Conflict. Arréglalos en el editor, pásalos a Staged y haz commit.

Historial

History cambia el panel a la vista del historial, y Back vuelve. Arriba dice la rama actual (Branch:) y cuántos commits hay entre todas las ramas (Total Commits:).

La lista tiene los commits de todas las ramas, del más nuevo al más viejo, con su mensaje (Message), su autor (Author), su fecha (Date) y su hash corto (Hash). La primera columna pone una marca de color en cada commit, más a la derecha si es de otra rama:

• un círculo es un commit normal, y un cuadrado, un merge;
• el borde blanco quiere decir que una rama o una etiqueta apunta a ese commit.

No dibuja las líneas que unen los commits.

Haz clic en un commit, o muévete por la lista con las flechas: abajo sale su hash, su autor, su fecha y su mensaje entero, y debajo, los ficheros que cambió, con su estado (File y Status). Para ver qué líneas cambiaron, usa otra herramienta de Git.

Remotos

Un remoto es el repositorio de un servidor al que subes tus commits. El panel trabaja con uno, origin.

Mientras el proyecto no tiene remoto, Fetch, Pull y Push están apagados, y al lado de Unstage sale Remote Config. Para conectarlo:

1. Crea en el servidor un repositorio vacío y copia su dirección.
2. Pulsa Remote Config y pega la dirección en Remote Repository URL. Tiene que empezar por http (https://…) o por git@.
3. Pulsa Connect and Push: el IDE añade el remoto como origin y sube la rama actual. Cancel vuelve sin hacer nada.

Desde entonces, Remote Config ya no sale, y se encienden los otros tres:

• Fetch trae las novedades del servidor sin tocar tus ficheros: las ramas del servidor se ponen al día, y las que se han borrado allí desaparecen de la lista.
• Pull trae los commits de la rama del servidor y los une a la tuya (git pull). Una rama que nunca has subido no tiene de dónde traerlos: súbela antes con Push.
• Push sube tus commits. La primera vez que subes una rama, la crea en el servidor y la deja enlazada a la tuya; desde entonces, Push y Pull van a esa.

Los tres van en segundo plano: el Output dice qué hace Git y cómo acaba, y al terminar, el panel se pone al día. El panel no tiene dónde escribir un usuario o una contraseña: si el servidor los pide, Git usa lo que tenga configurado.

Problemas conocidos

• La casilla del mensaje no está vacía: trae escrito «Briefly describe the changes made.» (mira «Commit»).
• Un fichero cambiado después de Stage sale solo en Staged. Si cambias un fichero que ya está en Staged, no vuelve a salir en Unstaged, y el commit se lleva la versión que pasaste a Staged, no la última. Pulsa Stage All antes de Commit.
• El panel no se pone al día tras un merge o al borrar una rama del servidor. Después de Merge into current branch... y Delete remote branch..., las listas siguen como antes: pulsa el botón de refrescar.
• Una dirección del remoto mal escrita se queda. Connect and Push añade el remoto aunque la subida falle, y desde entonces Remote Config ya no sale. Cámbiala desde una consola con git remote set-url origin <dirección>.

Todos los problemas conocidos de JARU, juntos, están en Problemas conocidos.