Administrador de dependencias Composer

Composer es un administrador de dependencias para el lenguaje PHP, es decir, una herramienta que permite declarar de qué bibliotecas depende tu proyecto y ofrece comandos para instalar y actualizar estas dependencias.

De hecho, en el mundo del desarrollo de software, es normal utilizar bibliotecas externas (o de terceros) que implementan las diversas funciones del entorno útiles para tu proyecto. No queremos girar la rueda desde cero cada vez, queremos centrarnos en las necesidades principales de nuestro proyecto. Para esto, por ejemplo, podemos decidir agregar cierta biblioteca como una dependencia a nuestro proyecto que nos permita verificar si una dirección de correo electrónico es válida y existente, y luego usarla en el flujo de registro de usuarios del sitio con el que estamos desarrollando Laravel.

Desde este punto de vista, Laravel en sí mismo es una biblioteca externa (un conjunto de bibliotecas individuales), incluida como una dependencia de nuestro proyecto a través de Composer.

Para completar, anticipemos de inmediato que Composer se encarga no solo de definir y recuperar las diversas dependencias del proyecto, sino también de la carga automática de clases PHP, como ilustraremos más adelante.

Cómo instalar Composer

La instalación de Composer requiere que PHP 7.2.5 o el más reciente esté instalado en tu ordenador.

Las instrucciones de instalación exactas difieren dependiendo de si está utilizando un sistema operativo similar a UNIX-Like (linux o macOS) o Windows.

Las instrucciones exactas se pueden consultar en el sitio web de Composer:

Setup de un proyecto

Un proyecto que usa Composer se caracteriza por la presencia de un archivo composer.json en tu directory principal.

Tal archivo contiene las dependencias del proyecto y contiene información adicional. 

Un ejemplo mínimo de un archivo de configuración es el siguiente: 

{
    "require": {
        "monolog/monolog": "^3.0.0"
    }
}

Tal archivo nos dice que la única dependencia del proyecto (la sección require) es Monolog (una biblioteca PHP para el logging).

Cada dependencia se compone de:

• el nombre del paquete (package name): monolog/monolog, compuesto a su vez por el nombre del vendor y el nombre del paquete, separados por /
• un selector de versión (version contraint): ^3.0.0 es una indicación de compatibilidad deseada entre las versiones que se encontrarán. 

En el momento en el que daremos el comando composer install, la configuración se usará para buscar online, en el registro de los paquetes, un paquete compatible con las indicaciones ofrecidas.

$ composer install          
No composer.lock file present. Updating dependencies to latest instead of installing from lock file. See https://getcomposer.org/install for more information.
Loading composer repositories with package information
Updating dependencies
Lock file operations: 2 installs, 0 updates, 0 removals
  - Locking monolog/monolog (3.2.0)
  - Locking psr/log (3.0.0)
Writing lock file
Installing dependencies from lock file (including require-dev)
Package operations: 2 installs, 0 updates, 0 removals
  - Downloading psr/log (3.0.0)
  - Downloading monolog/monolog (3.2.0)
  - Installing psr/log (3.0.0): Extracting archive
  - Installing monolog/monolog (3.2.0): Extracting archive
10 package suggestions were added by new dependencies, use `composer suggest` to see details.
Generating autoload files

Durante su ejecución Composer ha:

• encontrado que es necesario otro paquete, psr/log para instalar Monolog
• elegido la última versión disponible de Monolog, la 3.2.0, ya que es “compatible” con el selector indicado (^3.0.0 es decir “cada versión mayor de 3.0.0, pero no la 4.0.0 y siguientes”)
• agregado el archivo composer.lock, un archivo especial que se usa para “bloquear” la versión exacta de las dependencias recuperadas
• creado la directory vendor en el que se han extraído los archivos PHP que componen las dos bibliotecas recuperadas
• creado en la directory vendor el archivo autoload.php que podemos usar en nuestros archivos PHP para gestionar el autoload de las clases

Por lo tanto, será posible agregar un directorio src a nuestro mini proyecto en el que crear un archivo log_me.php con el siguiente contenido:

<?php

// Autoload files using the Composer autoloader.
require_once __DIR__ . '/../vendor/autoload.php';

use Monolog\Level;
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

// create a log channel
$log = new Logger('name');
$log->pushHandler(new StreamHandler('path/to/your.log', Level::Warning));

// add records to the log
$log->warning('Foo');
$log->error('Bar');

Entonces, podemos ejecutar el script PHP escribiendo en la terminal

php src/log_me.php

Gestión de dependencias

Composer proporciona varios comandos para administrar la adición y actualización de dependencias, en particular:

• composer update - recupera la versión más reciente compatible con el selector de versión indicado de todas las dependencias 
• composer update vendor1/package1 vendor2/package2 ... - como arriba, pero solo para los paquetes indicados
• composer require vendor/package - añade un paquete a las dependencias
• composer show vendor/package - muestra información del paquete
• composer require vendor/package --dev - añade un paquete a las dependencias de tipo “dev”

Más información sobre los comandos disponibles y las diversas opciones pueden ser recuperadas al ejecutar composer list y composer help.

Los varios paquetes Composer están distribuidos a través del paquete Packagist. Es posible buscar paquetes y consultar los detalles relacionados tanto a través del sitio web - https://packagist.org/ - como a través del comando composer search.

Creación de proyectos a partir de plantillas

Con Composer también es posible crear un nuevo proyecto basado en una plantilla existente. En la práctica, en lugar de crear un proyecto vacío y agregar gradualmente las dependencias individuales, es posible indicarle a composer que cree un nuevo proyecto basado en una plantilla que ya contiene todas las dependencias necesarias.

Una plantilla de proyecto se crea y distribuye a su vez como un paquete: su nombre es, por lo tanto, en la forma proveedor/proyecto y pueden existir diferentes versiones. Si no se indica una versión, Composer recupera la última plantilla disponible. La plantilla contiene los paquetes (y la versión relativa) elegidos por quien creó la plantilla más, posiblemente, todos los archivos necesarios para que un proyecto se ejecute de inmediato.

Para crear un nuevo proyecto usando una plantilla podemos usar el comando create-project, indicando el paquete de plantilla a usar y el nombre del proyecto que queremos crear:

composer create-project vendor/project:version nombre-proyecto

Se creará un directorio de nombre de proyecto en el que encontraremos el archivo composer.json, el directory vendor y posiblemente directorios y archivos creados por los scripts de inicialización de la plantilla.

Como veremos en la próxima lección, es posible crear un nuevo proyecto que use Laravel con este comando.

Dependencias de desarrollo

Composer permite distinguir entre dos grupos de dependencias, las require y las require-dev:

{
    "require": {
        "monolog/monolog": "^3.0.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^9.5"
    }
}

En el primer grupo se deben incluir aquellas dependencias que se utilizan para que nuestra aplicación funcione, en el segundo todas las dependencias que no son utilizadas por el código de "producción", pero que son de apoyo durante las fases de desarrollo.

En el ejemplo anterior, incluimos la biblioteca de prueba PhpUnit como una dependencia de desarrollo.

Dependencias de plataforma

En la lista de requisitos también es posible indicar algunas dependencias del "sistema". Composer, de hecho, define internamente algunos "platform package", paquetes virtuales que Composer no puede instalar, pero que están o deben estar instalados en el sistema. Esa lista incluye:

• el mismo php, para el cual es posible indicar la versión requerida o necesaria a nuestro proyecto
• las extensiones de PHP, en el formato ext-<name>
• algunas bibliotecas de sistema, en el formato lib-<name>

Aunque con algunas limitaciones, definir estos platform package nos permite saber si estamos instalando la aplicación PHP en una máquina que tiene todo lo necesario para su ejecución.

Autoloading

Sin embargo, una de las características más importantes de Composer es administrar el autoloading de clases de PHP.

Intentemos ejecutar los siguientes comandos desde la terminal y, cuando se pregunte cómo configurar, presiona enter en las líneas donde no se dio respuesta en el siguiente ejemplo:

$ mkdir composer-demo
$ cd composer-demo
$ composer init --name=acme/composer-demo --type=project

This command will guide you through creating your composer.json config.

Package name (<vendor>/<name>) [acme/composer-demo]:
Description []:
Author [n to skip]: n
Minimum Stability []:
Package Type (e.g. library, project, metapackage, composer-plugin) [project]:
License []:

Define your dependencies.

Would you like to define your dependencies (require) interactively [yes]? no
Would you like to define your dev dependencies (require-dev) interactively [yes]? no
Add PSR-4 autoload mapping? Maps namespace "Acme\ComposerDemo" to the entered relative path. [src/, n to skip]:
{
    "name": "acme/composer-demo",
    "type": "project",
    "autoload": {
        "psr-4": {
            "Acme\\ComposerDemo\\": "src/"
        }
    },
    "require": {}
}

Do you confirm generation [yes]? yes
Generating autoload files
Generated autoload files
PSR-4 autoloading configured. Use "namespace Acme\ComposerDemo;" in src/
Include the Composer autoloader with: require 'vendor/autoload.php';

Vamos a crear los archivos src/Greetings.php y src/run.php con el siguiente contenido:

// src/Greetings.php
<?php

namespace Acme\ComposerDemo;

class Greetings
{
    public static function sayHelloWorld() {
        return 'Hello World';
    }
}

// src/run.php
<?php

// Autoload files using the Composer autoloader.
require_once __DIR__ . '/../vendor/autoload.php';

use Acme\ComposerDemo\Greetings;

echo Greetings::sayHelloWorld();

Si ejecutamos nuestro script desde el terminar obtendremos:

$ php src/run.php
Hello World

La configuración de la sección autoload del archivo composer.json ajusta el contenido del archivo vendor/autoload.php. En particular, en nuestra configuración de ejemplo, le hemos dado instrucciones al autoload para recuperar las clases del espacio de nombres Acme\ComposerDemo en el directorio src.

Si quisiéramos cambiar el directory o cambiar el nombre del namespace, tendríamos que actualizar los archivos PHP y el contenido del archivo composer.json y luego ejecutar el comando composer dump-autoload para actualizar el contenido del archivo vendor/autoload.php.

Veremos, más adelante, cómo los proyectos usan Laravel al explotar esta función para administrar el árbol de directorios del proyecto de manera consistente y predecible.