9 Control de cambios con Git y Github

Paquetes para este capítulo

  if (!require('afex')) install.packages('afex'); library('afex')
  if (!require('correlation')) install.packages("correlation"); library('correlation')
  if (!require('corrr')) install.packages('corrr'); library('corrr')
  if (!require('dplyr')) install.packages('dplyr'); library('dplyr')
  if (!require('DT')) install.packages('DT'); library('DT')
  if (!require('ggraph')) install.packages('ggraph'); library('ggraph')
  if (!require('here')) install.packages('here'); library('here')
  if (!require('gtsummary')) install.packages('gtsummary'); library('gtsummary')
  if (!require('knitr')) install.packages('knitr'); library('knitr')
  if (!require('papaja')) install.packages("papaja"); library('papaja')
  if (!require('parameters')) install.packages('parameters'); library('parameters')
  if (!require('remotes')) install.packages('remotes'); library('remotes')
  if (!require('renv')) install.packages("renv"); library('renv')
  if (!require('report')) install.packages("report"); library('report')
  if (!require('rticles')) install.packages('rticles'); library('rticles')
  if (!require('see')) install.packages("see"); library('see')
  if (!require('sjPlot')) install.packages('sjPlot'); library('sjPlot')
  if (!require('stringi')) install.packages('stringi'); library('stringi')
  if (!require('tinytex')) install.packages('tinytex'); library('tinytex')
  if (!require('usethis')) install.packages('usethis'); library('usethis')

Dependencias

Vamos a necesitar Git para poder trabajar:

Instalar Git

Ver instrucciones para Windows, Mac y Linux.

Windows: en el paso Adjusting your PATH environment, selecciona Git from the command line and also from 3rd-party software

9.1 Git

Un segundo elemento que nos va a ayudar a trabajar en equipo, y a evitar problemas en proyectos relativamente complejos es el uso de un sistema de control de versiones como Git. Los proyectos de RStudio hacen especialmente sencillo usar algunas funcionalidades básicas de Git.

Algunas referencias útiles:

9.2 Github

Github es una plataforma web muy popular donde almacenar proyectos de programación que usa como motor. Muchos de los paquetes de R, el mismo RStudio, etc, tienen repositorios abiertos en Github. Una de las ventajas fundamentales de usar Github es que esta plataforma integra algunas herramientas para hacer más sencillo el control de versiones, como el pull request, que nos permite combinar ramas de proyectos sin apenas problemas.

Github tiene un programa especial para estudiantes: https://education.github.com/

9.3 Clonar un repositorio existente

Algo que podemos hacer con todos los repositorios de Github es clonarlos localmente:

Clonar repositorio Github

Primero, copiamos la repository URL del repo de Github (ver imagen de abajo). Será algo similar a https://github.com/VUESTRO_NOMBRE_DE_USUARIO/NOMBRE_REPOSITORIO.git

Segundo, en RStudio: File > New Project > Version Control > Git

9.4 Crear un proyecto en RStudio asociado a Github

Tener nuestros proyectos de RStudio asociados a repositorios en Github es muy útil para poder compartir el código y datos asociados a nuestras investigaciones, disponer de una copia de seguridad online, y, si lo usamos adecuadamente, detectar de manera más rápida cual de los últimos cambios es responsable de los errores que nos aparezcan.

Creando personal access token

La primera vez que usemos Github asociado a RStudio tendremos que crear un personal access token.

Método automático:

usethis::create_github_token()

Método manual, como los animales:

En tu página de Github, haz click en tu icono (arriba a la derecha) -> Settings -> Developer settings -> Personal access tokens -> [Generate new token] -> Give gist, repo and workflow permissions.

La manera más sencilla de tener un proyecto de RStudio vinculado a repositorio de Github es empezar creando un repositorio en Github.

Empezando desde 0 [recomendado]

Podemos empezar creando un repositorio en Github, para después clonarlo localmente. Para eso, en Github:

Creamos repositorio nuevo
Initialize this repository with a README
Clonar repositorio

Alternativamente, si ya tenemos un proyecto de RStudio y hemos avanzado en nuestra preparación, análisis de datos, etc. podemos usar usethis::use_github() para que nos cree y asocie automáticamente un repositorio de Github.

Si ya tenemos el proyecto de RStudio creado

Preparación

Crear un repositorio local de git (solo si no lo tenemos aún): usethis::use_git() (se crea una carpeta oculta llamada .git)
Insertar token en archivo .Renviron (si no lo tienes, ver arriba, Creando personal access token): usethis::edit_r_environ()

Asociando a repositorio en Github

Crear Github repo: usethis::use_github()
Empujar el repositorio local a Github: git push --set-upstream origin master

Ejercicios

Ejercicio 1: Github-RStudio

Vamos a poner a prueba lo anterior, creando un repositorio en Github llamado Github_Rstudio, y clonándolo para tener un proyecto de RStudio asociado.

Abre una cuenta en Github y/o haz login
Crea un repositorio en Github (después podrás borrarlo si quieres)
Sigue los pasos de arriba para clonar el repositorio de Github

Ejercicio 2: RStudio-Github

Ahora podemos usar el método inverso. Si tenemos un proyecto de RStudio, vamos a crear un repositorio de Github asociado.

Crea un nuevo repositorio de RStudio. Si marcas la pestaña Create a git repository te ahorrarás uno de los pasos (usethis::use_git())
Crea un script donde hagas algo muy sencillo (puedes copiar algún fragmento de código de temas anteriores)
Sigue los pasos de arriba para crear automáticamente un repositorio de Github asociado

9.5 Commits

Git es extraordinariamente potente, pero vamos a empezar por la funcionalidad básica, commit(enviar/encomendar) archivos.

Si partimos de un nuevo proyecto de RStudio llamado mi_primer_proyecto en el que hemos añadido un repositorio de Git (usethis::use_git()), y creado un nuevo archivo llamado mi_primer_archivo.R, en el panel Git veremos algo similar a esto:

Si hacemos cambios en mi_primer_archivo.R y hacemos click en Commit Commit , aparecerá una ventana para revisar los cambios. Hacemos doble click en mi_primer_archivo.R, y veremos que se pone en verde. Añadimos un Commit message, y estamos listos para hacer click en el botón Commit.

A partir de este momento, cualquier cambio en mi_primer_archivo.R será detectado por Git.

Por ejemplo, si añadimos una línea, veremos que el icono junto al archivo se convierte en una M en un recuadro azul.

Si hacemos de nuevo click en Commit Commit , podemos ver los cambios en mi_primer_archivo.R.

9.6 Pull, Push

Con los comandos pull y push:

Pull: nos aseguramos que nuestro repositorio local esta actualizado

Push: subimos los cambios commiteados de la rama a Github

Ejercicio

Nuestro primer commit

Usando el proyecto de RStudio de antes, crea un nuevo documento de Quarto (.qmd):

Haz un commit de ese archivo y súbelo (push) a Github (asegúrate que esta allá!). No olvides hacer un pull!
Ahora haz cambios en el archivo localmente. Una vez hechos:
- Commitealos
- Súbelos (Pull & Push)
- Sincroniza tu repo local (Pull final)

9.7 Workflow

Hay diferentes filosofías sobre cual es la mejor manera de trabajar con Git.

En este post por Vincent Driessen podéis ver una explicación bien detallada, complementada con imágenes como la que se ve a continuación.

El modelo básico implica la existencia de dos ramas. Una main o master (“producción”), donde tenemos código que siempre debe funcionar, y una development (para desarrollo), donde experimentamos, rompemos cosas, etc.

Podéis ver un manual super completo llamado Happy Git and GitHub for the useR elaborado por Jenny Bryan, Jim Hester, entre otros.

En RStudio podemos trabajar gráficamente, Usando el panel Git.

Usando el entorno gráfico

Empezamos en la rama master:

Pull : nos aseguramos que nuestro repositorio local esta actualizado
Branch : Creamos nueva rama llamada development
Hacemos cambios en nuestros scripts
Commit : Commiteamos los cambios
Push : subimos la rama a Github
Pull request (En Github):

Compare & Pull request

Pull : nos aseguramos que nuestro repositorio local esta actualizado

Como hacerlo usando el terminal

Pull: nos aseguramos que nuestro repositorio local esta actualizado: git pull
Branch: Creamos nueva rama llamada development: git checkout -b development
Hacemos cambios en nuestros scripts
Commit: Commiteamos los cambios

Añadimos archivos: git add foo.txt
Hacemos el commit: git commit --message "A commit message"

Push: subimos la rama a Github: git push origin development
Pull request (En Github):

Compare & Pull request

Pull: nos aseguramos que nuestro repositorio local esta actualizado: git pull

9.7.1 Pull request en 3 sencillos pasos

Los Pull request son una funcionalidad de Github que facilita colaborar con otras personas, contribuir a proyectos, etc. En esencia, automatizan la comprobación de cambios y, si no hay conflictos, permiten combinar el código nuevo con unos pocos clicks.

Después de hacer el push de arriba (paso 4), al entrar en nuestro repositorio de Github deberíamos ver algo parecido a lo siguiente (si no lo vemos, ir a branches). La única dificultad es saber cual de los botones verdes apretar:

Paso 1. Compare & pull request

Paso 2. Create pull request

Paso 3. Merge pull request

Borrar rama antigua

Bibliografía

Guia de estilo del tidyverse

Hadley Wickham’s Style guide

Happy Git and GitHub for the useR

targets

Scheel, A. M., Schijen, M., & Lakens, D. (in press). An excess of positive results: Comparing the standard Psychology literature with Registered Reports. Advances in Methods and Practices in Psychological Science.

Xie, Y., Allaire, J. J., & Grolemund, G. (2018). R Markdown: The Definitive Guide. CRC Press. https://bookdown.org/yihui/rmarkdown/

Yihui Xie (2018). bookdown: Authoring Books and Technical Documents with R Markdown https://bookdown.org/yihui/bookdown/markdown-syntax.html

Mas cosas sobre reproducibilidad:
- Reproducibility project: Psychology
- Many labs 2