Qué es Composer y en qué puede ayudarme

Cuando creas un nuevo proyecto de desarrollo de código, sea en el lenguaje que sea, no creo que empieces desde cero y teclees todo el código desde principio a fin. Normalmente vas a utilizar partes de algún proyecto ya desarrollado, por ti u otra persona, como eje del proyecto y luego irás añadiendo librerías por aquí y por allá para empezar con alguna base. Me arriesgaría a decir que todo este código “importado” puede llegar a suponer el 75% del proyecto.

Normalmente lo que hacemos para esta tarea es copiar una carpeta de una librería que usamos en un proyecto del año pasado, otra que encontramos hace poco en la web, código que hemos desarrollado para un proyecto anterior y que poco a poco vamos adaptando a este, etc.

El problema es que vamos mezclando versiones de librería que muchos veces son incompatibles entre si (no las librerías, sino las versiones) o que son incompatibles con nuestra versión actual de PHP. Además suele ser una locura casarlas entre si, llamar a unas desde otra y, no digamos ya, actualizarlas cuando salgan nuevas versiones o parches de seguridad.

Para este tipo de escenarios, propios de una peli de terror, se inventaron los gestores de dependencias, que no son otra cosa que utilidades que te ayudan a instalar los paquetes que necesites y a ir comprobando e instalado las dependencias que, a su vez, tienen esos paquetes para funcionar.

A nivel de sistema operativo un ejemplo serían apt y yum en Linux; para Javascript existen npm o bower y Java tiene Maven. Para PHP tenemos la fortuna de contar con Composer

Instalación desde Windows

Descarga el ejecutable para hacer una instalación automatizada desde la web de Composer https://getcomposer.org/doc/00-intro.md#installation-windows

Tras la instalación podrás utilizar Composer desde cualquier directorio utilizando la línea de comandos y tecleando php composer.phar

Instalación desde Linux y Mac

Accede a la página de instalación de Composer y sigue las instrucciones https://getcomposer.org/download/ (el proceso de instalación cambia con cada versión así que es mejor que lo mires allí). Desde estos sistemas se puede utilizar Composer directamente desde línea de comando como si fuera un ejecutable sin necesidad de invocar a php. Así que, una vez instalado abre un terminal y teclea composer

Comenzar a utilizar Composer

Composer no funciona a nivel global, sino a nivel de proyecto. Una vez instalado accede desde una terminal o línea de comandos al directorio raíz de tu proyecto y teclea composer init ó php composer.phar init si desarrollas con Windows.

Esto arranca el generador de configuración de Composer, que, de manera interactiva te irá pidiendo datos para generar el fichero de configuración de dependencias para tu proyecto, el fichero composer.json.

Te recomiendo irlo haciendo en paralelo a medida que vas siguiendo este tutorial.

Primero te pide el nombre del proyecto que vas a generar, en realidad el lo llama “package” porque para Composer todo son paquetes y el formato que suele usarse es: nombre_desarrollador/nombre_paquete , si eres un pistolero solitario, o nombre_empresa/nombre_paquete si desarrollas para una empresa u organización. Luego te pide una descripción del proyecto, un número de versión para reflejar el estado de madurez del mismo (puedes dejarlo en blanco de momento), el tipo de paquete que vas a crear: librería, proyecto, metapaquete, plugin de Composer y por último el tipo de licencia que vas a usar para tu proyecto (propietaria, GPL, BSD, MIT, etc. ).

Con esto ya tienes los parámetros básicos de tu proyecto, a continuación puedes empezar a declarar las dependencias que vas a utilizar. Para ello, continúa con la configuración (dile Yes cuando te pregunte si vas a definir dependencias).

Para cada dependencia que quieras definir primero pones el nombre aproximado del paquete para que Composer lo busque en su base de datos de paquetes (https://packagist.org/), luego eliges uno de entre los resultados y a continuación pones la versión que quieres (déjalo en blanco si quieres la última). A modo de ejemplo instala el gestor de plantillas twig/twig. Tardará un poquito y de nuevo te preguntará si quieres seguir agregando dependencias.

Si quieres puedes seguir definiendo dependencias, cuando quieras parar pulsa la tecla enter la próxima vez que te pregunte Search for a package:

Cuidado no pulses CTRL-C ni cierres el terminal antes de terminar porque abortarías todo el proceso.

A continuación te pregunta si quieres definir dependencias en fase de desarrollo, si tienes alguna clara, adelante, si no teclea No para salir. Entonces te preguntará si quieres crear el fichero de configuración con los datos que has ido proporcionando, teclea Yes o pulsa enter para terminar.

Con esto se genera un fichero que se graba en la carpeta de tu proyecto como composer.json Abre el fichero para darle un vistazo y verás que contiene las opciones que has ido indicando.

{  
    "name": "galatar/tuto_composer",  
    "description": "Tutorial sobre composer",  
    "type": "project",  
    "require": {  
        "twig/twig": "^2.4"  
    },  
    "authors": [  
        {  
            "name": "Juanan Ruiz",  
            "email": "juanan@us.es"  
        }  
    ]  
}

De momento no se ha descargado nada, ni se ha creado ningún otro fichero, para que Composer ejecute el fichero de configuración que acabas de definir escribe composer install en tu terminal.

Una vez que termine el proceso de descarga, a veces tarda un rato, puedes echar un vistazo a las carpetas y ficheros que se han creado en tu proyecto, en principio tendrás un nuevo fichero composer.lock y una carpeta vendor

.  
├── composer.json  
├── composer.lock  
└── vendor  
    ├── autoload.php  
    ├── composer  
    ├── symfony  
    └── twig

El fichero composer.lock almacena los datos de los paquetes que Composer ha descargado, si le das un vistazo verás que contiene bastante información porque cada paquete que descargas tiene su propio fichero de dependencias (su propio composer.json) que queda reflejado en este fichero. Ten cuidado porque nunca debes tocar este fichero a mano, los cambios que necesites realizar los haces en tu fichero composer.json y luego los haces efectivos con la orden composer update. Por último, pero no menos importante, Composer crea la carpeta vendor donde se guardan los ficheros de los paquetes que has instalado y los ficheros que el propio Composer necesita para funcionar.

Instalar paquetes para el entorno de desarrollo

Composer también te permite especificar paquetes que en principio estarán disponibles sólo en modo “desarrollo”, o sea, que solo deberían descargarse y utilizarse en los equipos de desarrollo y testeo de tu aplicación.

Habrás visto que una de las opciones que aparece al final del asistente de composer init dice algo así:

Would you like to define your dev dependencies (require-dev) interactively [yes]?

Pues los paquetes que instales en ese momento se instalarán en una rama especial del fichero composer.json llamada require-dev.

Si no lo haces en ese momento también podrás añadir paquetes a esa rama en cualquier momento desde la línea de comandos usando algo como: composer require monolog/monolog –dev

Que instala Monolog un paquete de gestión de información super completo para hacer el seguimiento de logs de tu proyecto en modo desarrollo. Dentro de tu archivo composer.json se añadirá algo así:

...  
"require-dev": {  
    "monolog/monolog": "^1.23",  
},  
...

En cualquier caso ten en cuenta que Composer no puede averiguar por arte de magia cuando está en un equipo de desarrollo y cuando en uno de producción, por lo que cuando estés desplegando tu proyecto en este último utiliza siempre composer install –no-dev o composer update –no-dev

Trabajar con un proyecto existente que utiliza Composer

Si trabajas en equipo puede que otra persona haya creado y compartido contigo el proyecto. O puede que lo hayas creado tú siguiendo este tutorial y ahora quieras compartirlo con alguien más.

En este caso ya partes de un fichero composer.json que has debido recibir o compartir con el resto del proyecto. Lo que no has debido recibir ni compartir, si estás haciendo las cosas bien, es la carpeta vendor y su contenido.

Esa carpeta con sus ficheros y sus carpetas se van a crear en el nuevo entorno ejecutando composer install desde la raíz del proyecto.

Si utilizas un gestor de dependencias como git para programar en equipo (o simplemente para guardarte las espaldas) debes incluir en tu repositorio los archivos composer.json y composer.lock , pero debes excluir el directorio vendor. Este se creará solito en nuevas instancias de tu proyectos cuando ejecutes el comando composer install como has visto arriba.

Autocarga de paquetes

La mayoría de los paquetes que descargues incluirán su propia información de autoload, para poder instanciar las clases que contienen. Otro de las ventajas de Composer es que el se encarga de organizar todo la autocarga directamente desde un fichero centralizado, este fichero se llama autoload.php y lo encontrarás en la carpeta vendor de tu proyecto.

Para poder acceder a cualquier clase sólo tendrás que incluir el fichero autoload.php desde tu script.

<?php  
require_once '../vendor/autoload.php';  
$twig_loader = new Twig_Loader_Filesystem('../templates');  
$twig = new Twig_Environment($twig_loader, array('cache' => '../cache/twig',));

También puedes cargar tus propias clases utilizando Composer, sigue leyendo.

Carga tus clases automáticamente con Composer

Si ya sabes de que van los espacios de nombre en PHP (espero que si) ahora es el momento de declarar el espacio de nombre raíz para tu proyecto y la carpeta donde el interprete de php debe buscar tus clases. Para ello añade algo parecido a lo siguiente en el fichero composer.json

"autoload": {  
    "psr-4": {  
    "Galatar\\TutoComposer\": "src"  
    }  
}

Con lo que tendrás algo así:

{  
  "name": "galatar/tuto_composer",  
  "description": "Tutorial sobre composer",  
  "type": "project",  
  "require": {  
      "twig/twig": "^2.4"  
  },  
  "require-dev": {  
      "monolog/monolog": "^1.23",  
  },  
  "autoload": {  
      "psr-4": {  
          "Galatar\\TutoComposer\": "src"  
      }  
  },  
  "authors": [  
      {  
          "name": "Juanan Ruiz",  
          "email": "juanan@us.es"  
      }  
  ]  
}

Ahora por fin podrás empezar a escribir tus primeras clases dejando en manos de Composer la carga automática de las mismas (autoload).

Crea una carpeta src en la raíz del proyecto y crea dentro de ella un fichero Persona.php con el siguiente contenido:

<?php  
// src/Persona.php  
namespace Galatar\TutoComposer;  
class Persona  
{  
    public function saluda()  
    {  
        print("Hola soy una persona");  
    }  
}

Crea también en la raíz del proyecto una carpeta public y escribe en ella un fichero index.php con el siguiente contenido:

<?php  
// tuto_galatar/public/index.php  
require_once '../vendor/autoload.php';  
use Galatar\TutoComposer\Persona;  
$persona = new Persona();  
$persona->saluda();

Ahora tu estructura de directorios debería parecerse a esto, si te fijas ya tienes un pequeño framework:

.  
├── composer.json  
├── composer.lock  
├── public  
│   └── index.php  
├── src  
│   └── Persona.php  
└── vendor  
    ├── autoload.php  
    ├── composer  
    ├── symfony  
    └── twig

Activa desde consola el servidor web que viene integrado con php utilizando la orden: php -S localhost:8000

Ahora ve a tu navegador web y teclea: http://localhost:8000

Debería aparecer una página con la frase: Hola soy una persona

Gracias por haber llegado hasta aquí y espero que este tutorial te haya sido de utilidad.

Si algo no ha ido bien repasa de nuevo las instrucciones anteriores. Si tienes alguna duda o te gustaría que hablara del algún tema relacionado déjame un comentario e intentaré atenderte en cuanto pueda.

Para más información

• Libros Web: Composer, el manual oficial