Drupal 8 + Composer + Git

Composer como gestor de dependencias con Drupal 8
22 Noviembre 2016 por jorge.maestre en Desarrollo

Instalar Composer

Lo primero que necesitas es instalar Composer tal y como se indica en Getting Started on getcomposer.org.

Plantillas Composer para Drupal

Una vez instalado Composer puedes usarlo para instalar Drupal. Actualmente existen dos plantillas que pueden ser usadas con Composer

  1. drupal/drupal. Utiliza Drupal en sí mismo como plantilla de Composer. Sencillo de instalar pero carece de alguna funcionalidad interesante.
  2. drupal-composer/drupal-project. Es una plantilla de Drupal adaptada para arrancar proyectos con Composer. Incluye configuraciones y alguna funcionalidad que agiliza el proceso como la instalación de drush o drupal console.

Una comparación de ambos proyectos:

Caraterística drupal/drupal drupal-composer/drupal-project
open source yes yes
directory structure docroot is repo root docroot is subdir
installer-paths config no yes
repositories config no yes
updates scaffold files no yes
includes drush no yes
includes drupal console no yes

Archivos Scaffold

Son archivos de Drupal pero que no se encuentran dentro del core como .htaccess, robots.txt, index.php, update.php, etc. En el caso de la plantilla drupal/drupal para Composer no se define ningún mecanismo para generarlos desde Composer y se incluyen tal cual. Por su lado usando la plantilla drupal-composer/drupal-project Composer puede ejecutar scripts mediante drupal/scaffold a los que se puede indicar qué archivos copiar y dónde. Muy útil para los cambios de entorno.

En nuestro proyecto vamos a usar la segunda opción drupal-composer/drupal-project con una plantilla Drupal adaptada a Composer. La otra alternativa la puedes encontrar descrita en aquí.

¿Cómo creo un proyecto Drupal con Composer?

  1. $ composer create-project drupal-composer/drupal-project:8.x-dev my_site_name-dir --stability dev --no-interaction

Este comando descarga drupal-composer/drupal-project en el directorio my_site_name y ejecuta composer install. La estructura de archivos que genera es:

  • composer.json: archivo de Composer con las dependencias del proyecto
  • /web: contiene la versión de Drupal seleccionada con varias configuraciones ya realizadas por Composer durante la instalación y según se define en la plantilla
  • /vendor: contiene las librerías de nuestro proyecto que se cargan desde /web/autoload.php

Por tanto necesitaremos apuntar nuestro servidor web al directorio /web donde está el archivo index.php de Drupal.

Drupal.org como repositorio de paquetes Drupal

Nuestra plantilla de Composer realiza además varia configuraciones. Una de ellas es establecer Drupal.org como repositorio fuente de paquetes Drupal, de manera que podamos instalar los módulos y temas de Drupal desde Composer. Para ello propia plantilla añade la siguientes lineas a composer.json de nuestro directorio raíz:

  1. {
  2.     "repositories": {
  3.         "drupal": {
  4.             "type": "composer",
  5.             "url": "https://packages.drupal.org/8"
  6.         }
  7.     }
  8. }

Directorios donde se descargan los módulos y temas

La plantilla seleccionada también configura los directorios donde se instalarán los módulos y temas gráficos de nuestro proyecto Drupal. Para ello hace uso del paquete composer/installers que permite definir dichos directorios en el archivo composer.json de la raíz:

  1. "extra": {
  2.     "installer-paths": {
  3.         "modules/contrib/{$name}": ["type:drupal-module"],
  4.         "modules/custom/{$name}": ["type:drupal-custom-module"],
  5.         "profiles/contrib/{$name}": ["type:drupal-profile"],
  6.         "themes/contrib/{$name}": ["type:drupal-theme"],
  7.         "themes/custom/{$name}": ["type:drupal-custom-theme"]
  8.     }
  9. }

¿Cómo puedo instalar un módulo o tema Drupal con Composer?

Para instalar módulos o temas Drupal en tu proyecto sólo tienes que hacer:

  1. $ composer require drupal/<modulename> --prefer-dist

Por ejemplo:

  1. $ composer require drupal/token --prefer-dist

Composer automáticamente actualizará composer.json añadiendo la dependencia:

  1. {
  2.     "require": {
  3.         "drupal/token": "1.x-dev"
  4.     }
  5. }

Es recomendable usar --prefer-dist para evitar descargar dependencias con el historial .git y evitar submódulos git.

Eligiendo una versión concreta

Puedes indicar una versión concreta de un módulo o tema:

  1. $ composer require drupal/<modulename>:<version>

Por ejemplo:

  1. $ composer require drupal/ctools:3.0.0-alpha26
  2. $ composer require drupal/token:1.x-dev

En estos ejemplo la versión composer 3.0.0-alpha26 equivale a la versión drupal.org 8.x-3.0-alpha26 y 1.x-dev equivale a la rama 8.x-1.x en drupal.org. Si especificas una rama como 1.x tienes que añadir -dev al final de la versión.

¿Qué más puedo hacer con Composer y Drupal?

Composer search

Drupal.org soporta Composer search por lo que podemos buscar proyectos desde la línea de comandos, por ejemplo:

  1. $ composer search views

Composer browse

Drupal.org también soporta Composer browse para ver más información de un proyecto concreto, por ejemplo:

  1. $ composer browse drupal/token

Aplicando parches con Composer

Es posible aplicar parches automáticamente con Composer usando cweagans/composer-patches. Por ejemplo, para añadir un parche al módulo foobar de drupal añade esto a la sección “patches” de composer.json:

  1. "extra": {
  2.     "patches": {
  3.         "drupal/foobar": {
  4.             "Patch description": "URL to patch"
  5.         }
  6.     }
  7. }

Estrategia de control de versiones con Git para un proyecto Drupal + Composer

Por lo general la mayoría de documentación de Composer apuesta por mantener el directorio /vendor fuera del control de versiones. Estas recomendaciones se basan en la existencia de algún nivel de abstracción entre el repositorio de código donde los desarrolladores realizan los commits y el proceso de despliegue en el entorno de producción. En estos casos cada vez que se cambia de entorno, por ejemplo en local, es necesario actualizar las dependencias con Composer. Los sistemas de integración contínua se benefician de este flujo. Sin embargo es posible que en casos más sencillos se decida hacer commit del directorio /vendor y de todas las dependencias. Al fin y al cabo hay gente que se siente más segura viendo que lo que tienen es exactamente lo que hay.

Nuestro caso: versionamos sólo lo necesario

En nuestros proyectos hemos optado por versionar sólo lo estrictamente necesario y delegar toda la gestión de dependencias a Composer. La plantilla drupal-composer/drupal-project sigue esta misma idea e incluye el siguiente archivo .gitignore:

  1. # Ignore directories generated by Composer
  2. drush/contrib
  3. vendor
  4. web/core
  5. web/modules/contrib
  6. web/themes/contrib
  7. web/profiles/contrib
  8.  
  9. # Ignore Drupal's file directory
  10. web/sites/*/files
  11.  
  12. # Ignore SimpleTest multi-site environment.
  13. web/sites/simpletest
  14.  
  15. # Ignore files generated by PhpStorm
  16. .idea

Como vemos en las primeras líneas quedan fuera del control de versiones el propio core de Drupal así como los módulos, temas gráficos y profiles contribuidos. Al fin y al cabo todos ellos se gestionan como dependencias con Composer. También quedan fuera los archivos estáticos de /sites/*/files.

Nuestro repositorio queda reducido al mínimo y prácticamente sólo incluye el archivo de dependencias raíz composer.json y los directorios web/modules/custom y web/themes/custom donde tenemos nuestros propios desarrollos específicos del proyecto. Incluso estos se podrían crear en un repositorio git como módulo para Composer y ser incluidos también como dependencias del proyecto.

De esta forma conseguimos un repositorio muy reducido y sencillo de mantener. Sin embargo tenemos que vigilar de cerca el archivo raíz composer.json, tener claras las versiones de cada módulo o tema, fijarlas a una versión concreta si es necesario y ejecutar el update de drupal cada vez que se actualize algún componente de Drupal a una nueva versión.

Referencias

Etiquetas: Composer, drupal, git