Configurando Git y Github para Ruby on Rails en Ubuntu 12.04

Esta vez veremos como instalar, configurar y usar, Git y GitHub, trabajare con la version de Git para Linux, en este caso mi distribución es Ubuntu 12.04, pero si bien el procedimiento puede variar en otros sistemas operativos, éste tutorial puede servir de punto de partida para instalarlo, y una vez hecho ese primer paso, es útil para conocer como configurar una cuenta en GitHub y sincronizarla con nuestro repositorio local usando Git.

Que necesitamos?

1. Tener instalado Git Para verificar si ya hemos instalado Git simplemente ejecutamos el comando:

git --version

Si nos devuelve la versión de Git no tenemos de que preocuparnos, en mi caso la versión que tengo instalada es la 1.7.9, si nos devuelve un error entonces significa que no tenemos instalado Git y debemos hacerlo por medio del siguiente comando:

 sudo apt-get install git

 2. Abrir una cuenta en GitHub GitHub es el repositorio web de código, con control de versiones más grande en el mundo, muchas de las principales empresas tecnológicas del mundo tienen repositorios en GitHub que trabajan colaborativamente entre sus empleados o personas externas (si el proyecto en cuestión es libre). Durante el desarrollo del curso de Ruby on Rails usaremos Git para el control de versiones del proyecto, desplegando el código directamente en GitHub, por lo tanto será necesario que se registren en GitHub para poder seguir el proceso.

En resumen:

1. Crearemos una aplicación  en Ruby en Rails
2. Modificaremos el archivo .gitignore del directorio de nuestro nuevo proyecto
3. Iniciaremos Git y haremos nuestro primer commit 
4. Crearemos una llave SSH y configuraremos nuestro repositorio en GitHub
5. Realizaremos algunas pruebas

Comencemos

 1. Creamos una aplicación en Ruby on Rails Para crear una nueva aplicación en Ruby on Rails solo es necesario ejecutar:

rails new nombre_la_aplicacion

Este comando automáticamente nos creará una estructura propia de rails, de preferencia podemos crear un directorio que sea unicamente para las aplicaciones que crearemos en RoR:

mkdir proyectos_rails

Y dentro de ésta carpeta colocaremos nuestro proyecto que en este caso lo denominaremos gitrails

rails new gitrails

2. Modificamos el archivo .gitignore del directorio de nuestro proyecto. Verificamos si nos encontramos en el directorio de nuestro proyecto, de no ser asi cambiamos al directorio, siguiendo con nuestro ejemplo sería:

cd gitrails

Ya dentro del directorio de nuestro proyecto procedemos a modificar el arhico .gitignore, esto lo hacemos por medio de:

gedit .gitignore

En mi caso uso Sublime Text 2 asi que el comando sería un poco diferente:

subl .gitignore

En el archivo .gitignore encontraremos algo como ésto:

# Ignore bundler config
/.bundle

# Ignore the default SQLite database.
/db/*.sqlite3

# Ignore all logfiles and tempfiles.
/log/*.log
/tmp

A esta solo agregamos algunas lineas:

# Ignorar otros archivos innecesarios 
doc/
*.swp
*~
.project
.DS_Store

 3. Iniciaremos Git y haremos nuestro primer commit Para iniciar Git:

git init

Luego agregamos el directorio donde se encuentra nuestra aplicación en RoR:

git add.

Podemos verificar que los directorios se hallan agregado con:

git status

Y por último hacemos nuestro primer commit, o bien nuestra primera versión del proyecto en el que estamos trabajando:

git commit -m "Primera Versión"

-m es el mensaje con el que se guardará la versión que estamos guardando

 4. Crearemos una llave SSH y configuraremos nuestro repositorio en GitHub A estas alturas deberiamos de tener lista nuestra cuenta en GitHub, por lo tanto procedemos a crear una llave SSH para agregarla a GitHub y poder subir nuestro contenido, para ello ejecutamos el comando:

ssh-keygen

Luego nos preguntará acerca de que nombre, ruta o contraseña queremos poner a nuestra llave, en mi caso no incluí ninguno de esos datos por tratarse de una prueba, pero en entornos profesionales es necesario por cuestiones de seguridad.

 

Ahora que tenemos nuestra llave publica creada es necesario que copiemos el contenido de nuestra llave SSH en GitHub, para eso ejecutamos:

cat ~/.ssh/id_rsa.pub

En mi caso estoy usando la llave generada por defecto, si se creo una llave con un nombre diferente debe cambiarse al final del comando, luego procedemos a copiar el contenido de nuestra llave y pegarlo en Github:

Nos vamos a herramientas, y luego en la barra lateral seleccionamos SSH Keys



 Agregamos una nueva clave SSH, pegando los el contenido de nuestra llave:

 A continuación se nos pedirá nuevamente nuestra contraseña, la ingresamos, y estaremos listos crear nuestro primer repositorio y sincronizarlo con nuestro proyecto local, de manera que nos vamos a http://github.com/new o bien nos vamos al primer icono del menú superior derecho...

Ingresamos el nombre del repositorio y opcionalmente una descripción:

 Le damos en crear repositorio y continuación nos mostrará una página con algunos comandos que nos servirán de mucha utilidad, asi que basados en estos procedemos a configurar nuestro repositorio local, copiamos y usamos los siguientes comandos: Ingresamos nuestro nombre...

git config --global user.name "Your Name"

Ingresamos nuestro correo...

git config --global user.email tucorreo@gmail.com

Agregamos el origen...

git remote add origin https://github.com/gerardoortega/gitrails.git

Y por último publicamos nuestro proyecto en GitHub usando:

git push -u origin master

Al momento de publicar la primera versión de nuestro proyecto por medio del comando anterior nos pedirá nuestro nombre de usuario y contraseña.

 

  5. Realizaremos algunas pruebas Con los pasos anteriores conseguimos sincronizar nuestro proyecto con el repositorio de Github que creamos, podemos comprobar que todo salio bien actualizando la URL de nuestro repositorio y confirmando que los archivos han sido publicados:

 

Por último y para conocer más de cerca las ventajas del uso de Git para el control de versiones podemos realizar las siguientes pruebas: * Primero creamos una nueva rama o branch

git checkout -b rama

Las ramas o branches nos sirven para administrar ciertas áreas del proyecto de forma completamente independiente al proyecto principal (el cual se encuentra en la rama principal llamada master), por ejemplo, en un proyecto se ven involucrados diferentes grupos de profesionales, como diseñadores, analistas, testers, etc. se puede crear una rama para cada equipo, para que puedan trabajar en sus áreas sin temor a corromper un componente del proyecto que tenga repercusiones mayores. Para continuar con nuestro ejemplo vamos a modificar el Readme del proyecto en una rama independiente, asi que llamaremos a la rama READMEmodificado

git checkout -b READMEmodificado

(donde -b viene de branch y sirve para crear una nueva rama y checkout sirve para cambiar a una rama especifica) Como hemos cambiado a la nueva rama que hemos creado (READMEmodificado) mediante el comando checkout inmediatamente podemos comenzar a trabajar sobre esta branch, por lo tanto haremos algunas modificaciones:

rm -rf app/

--con esto borramos el contenido de la carpeta app/

git status

--para ver el estado actual y los archivos que han sido eliminados

git checkout -f

--para volver al estado anterior a las modificaciones

git status

--confirmamos que los cambios han sido deshechos, y todo esta como en un principio

rm -rf app/

--volvemos a borrar el directorio app/

git reset --hard HEAD

--regresamos al estado original de otra manera

rm -rf app/

--borramos nuevamente el directorio

git commit -am "Cambios estupidos"

--guardamos una version con los cambios que hemos hecho

git checkout master

--cambiamos a la rama master (la principal)

git branch

--lo usamos para saber en que rama estamos

git branch -D READMEmodificado

--para borrar la rama que creamos hace poco

git checkout -b READMEmodificado

--creamos nuevamente la rama que habíamos borrado y cambiamos a esta nueva rama

gedit README.rdoc

--procedemos a borrar el contenido de README.rdoc y colocamos un contenido alternativo

git mv README.rdoc README.markdown

--cambiamos la extensión del README y lo trasladamos a README.markdown

git commit -am "README Mejorado"

--hacemos un commit de los cambios que hemos hecho con el nombre de "README Mejorado"

git checkout master

--cambiamos a la rama master

git merge READMEmodificado

--combinamos los cambios hechos en la rama que creamos con la rama principal

git log

-- para conocer el registro de cambio

git status

--consultamos el estado de los cambios realizados

git push

--publicamos los cambios en el repositorio de GitHub (ya no es necesario usar origin master, solo se usan la primera vez) Con eso tendremos una mejor noción de lo que podemos realizar con Git, y en general darnos cuenta de lo valiosa que es esta herramienta.