One place for hosting & domains

      Composer

      Comment installer et utiliser Composer sur Ubuntu 20.04


      Introduction

      Composer est un outil populaire de gestion des dépendances pour PHP, créé principalement pour faciliter l’installation et les mises à jour des dépendances des projets. Il vérifiera de quels autres paquets un projet spécifique dépend et les installera pour vous en utilisant les versions appropriées selon les exigences du projet. Composer est également couramment utilisé pour lancer de nouveaux projets basés sur des cadres PHP populaires tels que Symfony et Laravel.

      Dans ce tutoriel, vous allez installer et commencer à utiliser Composer sur un système Ubuntu 20.04.

      Conditions préalables

      Pour pouvoir suivre ce guide, vous devez avoir accès à un serveur Ubuntu 20.04 en tant que non-root sudo user, et un pare-feu activé sur votre serveur. Pour configurer cela, vous pouvez notre guide de configuration initiale du serveur pour Ubuntu 20.04.

      Étape 1 – Installer PHP et des dépendances supplémentaires

      En plus des dépendances qui devraient déjà être incluses dans votre système Ubuntu 20.04, telles que git et curl, Composer nécessite php-cli pour exécuter les scripts PHP en ligne de commande, et unzip pour extraire les archives zippées.   Nous allons maintenant installer ces dépendances.

      Tout d’abord, mettez à jour le cache du gestionnaire de paquets en exécutant :

      Ensuite, exécutez la commande suivante pour installer les paquets requis :

      • sudo apt install php-cli unzip

      Vous serez invité à confirmer l’installation en tapant Y et ensuite ENTER.

      Une fois les prérequis installés, vous pouvez procéder à l’installation de Composer.

      Étape 2 – Téléchargement et installation de Composer

      Composer fournit un script d’installation écrit en PHP. Nous allons le télécharger, vérifier qu’il n’est pas corrompu, puis l’utiliser pour installer Composer.

      Assurez-vous que vous êtes dans votre répertoire d’origine, puis récupérez l’installateur en utilisant curl : 

      • cd ~
      • curl -sS https://getcomposer.org/installer -o composer-setup.php

      Ensuite, nous allons vérifier que l’installateur téléchargé correspond au hachage SHA-384 pour le dernier installateur trouvé sur la page des clés publiques/signatures de Composer.   Pour faciliter l’étape de vérification, vous pouvez utiliser la commande suivante pour obtenir par programmation le dernier hachage de la page de Composer et le stocker dans une variable shell :

      • HASH=`curl -sS https://composer.github.io/installer.sig`

      Si vous voulez vérifier la valeur obtenue, vous pouvez exécuter :

      Output

      e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

      Exécutez maintenant le code PHP suivant tel que fourni dans la page de téléchargement de Composer pour vérifier que le script d’installation peut être exécuté en toute sécurité : 

      • php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

      Vous verrez la sortie suivante :

      Output

      Installer verified
      

      Si la sortie indique que l'installateur est corrompu, vous devrez télécharger à nouveau le script d’installation et vérifier que vous utilisez le bon hachage. Ensuite, répétez le processus de vérification. Lorsque vous avez un installateur vérifié, vous pouvez continuer.

      Pour installer Composer globalement, utilisez la commande suivante qui téléchargera et installera Composer sous la forme d’une commande système nommée composer, sous /usr/local/bin :

      • sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

      Vous verrez une sortie semblable à celle-ci :

      Output

      All settings correct for using Composer Downloading... Composer (version 1.10.5) successfully installed to: /usr/local/bin/composer Use it: php /usr/local/bin/composer

      Pour tester votre installation, exécutez :

      Output

      ______ / ____/___ ____ ___ ____ ____ ________ _____ / / / __ / __ `__ / __ / __ / ___/ _ / ___/ / /___/ /_/ / / / / / / /_/ / /_/ (__ ) __/ / ____/____/_/ /_/ /_/ .___/____/____/___/_/ /_/ Composer version 1.10.5 2020-04-10 11:44:22 Usage: command [options] [arguments] Options: -h, --help Display this help message -q, --quiet Do not output any message -V, --version Display this application version --ansi Force ANSI output --no-ansi Disable ANSI output -n, --no-interaction Do not ask any interactive question --profile Display timing and memory usage information --no-plugins Whether to disable plugins. -d, --working-dir=WORKING-DIR If specified, use the given directory as working directory. --no-cache Prevent use of the cache -v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug ...

      Cela permet de vérifier que Composer a été installé avec succès sur votre système et qu’il est disponible dans tout le système.

      Note : Si vous préférez avoir des exécutables de Composer séparés pour chaque projet que vous hébergez sur ce serveur, vous pouvez l’installer localement, par projet. Cette méthode est également utile lorsque l’utilisateur de votre système n’a pas la permission d’installer un logiciel dans tout le système.

      Pour ce faire, utilisez la commande php composer-setup.php. Cela va générer un fichier composer.phar dans votre répertoire actuel qui peut être exécuté avec php composer.phar.

      Voyons maintenant comment utiliser Composer pour gérer les dépendances.

      Étape 3 – Utilisation de Composer dans un projet PHP

      Les projets PHP dépendent souvent de bibliothèques externes, et la gestion de ces dépendances et de leurs versions peut être délicate. Composer résout ce problème en gardant la trace des versions et des dépendances du projet, tout en facilitant le processus de recherche, d’installation et de mise à jour des paquets requis par un projet.

      Pour utiliser Composer dans votre projet, vous aurez besoin d’un fichier composer.json. Le fichier composer.json indique au compositeur quelles dépendances il doit télécharger pour votre projet, et quelles versions de chaque paquet peuvent être installées. Ceci est extrêmement important pour maintenir la cohérence de votre projet et éviter d’installer des versions instables qui pourraient potentiellement causer des problèmes de rétrocompatibilité.

      Vous n’avez pas besoin de créer ce fichier manuellement – il est fréquent de rencontrer des erreurs de syntaxe lorsque vous le faites. Composer offre un moyen interactif de créer un nouveau fichier composer.json basé sur la contribution de l’utilisateur, ce qui est un bon choix si vous prévoyez de partager votre projet plus tard en tant que paquet public sur Packagist. Composer génère aussi automatiquement un fichier barebones composer.json lorsque vous lancez une commande composer require pour inclure une dépendance dans un projet nouvellement créé.

      Le processus d’utilisation de Composer pour installer un paquet en tant que dépendance dans un projet implique les étapes suivantes :

      • Identifiez le type de bibliothèque dont la demande a besoin.
      • Recherchez une bibliothèque open source appropriée sur Packagist.org, le dépôt officiel de paquets pour Composer.
      • Choisissez le paquet dont vous voulez dépendre.
      • Exécutez composer require pour inclure la dépendance dans le fichier composer.json et installez le paquet.

      Essayons cela avec une application de démonstration.

      L’objectif de cette application est de transformer une phrase donnée en une chaîne facile à utiliser pour les URL – a slug. Cette méthode est couramment utilisée pour convertir les titres des pages en chemins d’accès URL (comme la dernière partie de l’URL pour ce tutoriel).

      Commençons par créer un répertoire pour notre projet. Nous l’appellerons slugify :

      • cd ~
      • mkdir slugify
      • cd slugify

      Bien que ce ne soit pas obligatoire, vous pouvez maintenant lancer une commande composer init pour créer un fichier composer.json détaillé pour votre projet. Comme le seul objectif de notre projet est de démontrer comment installer des dépendances avec Composer, nous utiliserons un fichier composer.json plus simple qui sera généré automatiquement lorsque nous aurons besoin de notre premier paquet.

      Il est maintenant temps de rechercher sur Packagist.org un paquet qui peut nous aider à générer des slugs. Si vous recherchez le terme slug sur Packagist, vous obtiendrez un résultat similaire à celui-ci :

      Résultats de la recherche pour le terme slug

      Vous verrez deux numéros sur le côté droit de chaque paquet dans la liste. Le chiffre du haut représente le nombre de fois que le paquet a été installé via Composer, et le chiffre du bas indique le nombre de fois qu’un paquet a été mis en vedette sur GitHub. D’une manière générale, les paquets comportant plus d’installations et plus d’étoiles ont tendance à être plus stables, puisque beaucoup de gens les utilisent. Il est également important de vérifier la pertinence de la description du paquet pour s’assurer qu’il correspond à vos besoins.

      Nous avons besoin d’un convertisseur de chaîne de caractères en slug. D’après les résultats de la recherche, le paquet cocur/slugify qui apparaît comme premier résultat dans cette page semble être une bonne correspondance avec un nombre raisonnable d’installations et d’étoiles.

      Les paquets sur Packagist ont un nom de vendeur et un nom de paquet. Chaque paquet possède un identifiant unique (un espace de noms) dans le même format que celui utilisé par GitHub pour ses dépôts : vendor/package La bibliothèque que nous voulons installer utilise l’espace de noms cocur/slugify. Vous avez besoin de l’espace de noms d’un paquet afin de l’exiger dans votre projet.

      Maintenant que vous savez exactement quel paquet vous voulez installer, vous pouvez lancer composer require pour l’inclure comme dépendance et aussi générer le fichier composer.json pour votre projet. Une chose qu’il est important de noter quand on demande des paquets, c’est que Composer suit à la fois les dépendances au niveau de l’application et celles au niveau du système. Les dépendances au niveau du système sont importantes pour indiquer sur quels modules PHP un paquet repose. Dans le cas de lacocur/slugify, il nécessite un module PHP que nous n’avons pas encore installé.

      Lorsqu’un paquet requis repose sur une bibliothèque système qui n’est actuellement pas installée sur votre serveur, vous obtenez une erreur vous indiquant quelle exigence est manquante :

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been updated Loading composer repositories with package information Updating dependencies (including require-dev) Your requirements could not be resolved to an installable set of packages. Problem 1 - Installation request for cocur/slugify ^4.0 -> satisfiable by cocur/slugify[v4.0.0]. - cocur/slugify v4.0.0 requires ext-mbstring * -> the requested PHP extension mbstring is missing from your system. ...

      Pour résoudre le problème de dépendance du système, nous pouvons rechercher le paquet manquant en utilisant la recherche apt : 

      Output

      Sorting... Done Full Text Search... Done php-mbstring/focal 2:7.4+75 all MBSTRING module for PHP [default] php-patchwork-utf8/focal 1.3.1-1 all UTF-8 strings handling for PHP php7.4-mbstring/focal 7.4.3-4ubuntu1 amd64 MBSTRING module for PHP

      Après avoir trouvé le nom de paquet correct, vous pouvez à nouveau utiliser apt pour installer la dépendance du système :

      • sudo apt install php-mbstring

      Une fois l’installation terminée, vous pouvez relancer la commande composer require :

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been created Loading composer repositories with package information Updating dependencies (including require-dev) Package operations: 1 install, 0 updates, 0 removals - Installing cocur/slugify (v4.0.0): Downloading (100%) Writing lock file Generating autoload files

      Comme vous pouvez le voir sur la sortie, Composer a automatiquement décidé de la version du paquet à utiliser. Si vous vérifiez maintenant le répertoire de votre projet, il contiendra deux nouveaux fichiers : composer.json et composer.lock, ainsi qu’un répertoire vendor :

      Output

      total 12 -rw-rw-r-- 1 sammy sammy 59 May 4 13:56 composer.json -rw-rw-r-- 1 sammy sammy 3229 May 4 13:56 composer.lock drwxrwxr-x 4 sammy sammy 4096 May 4 13:56 vendor

      Le fichier composer.lock est utilisé pour stocker des informations sur les versions de chaque paquet qui sont installées, et s’assurer que les mêmes versions sont utilisées si quelqu’un d’autre clone votre projet et installe ses dépendances. Le répertoire vendor est l’endroit où se trouvent les dépendances du projet. Le dossier vendor ne doit pas être intégré dans le contrôle de version – vous devez seulement inclure les fichiers composer.json *et *composer.lock.

      Lors de l’installation d’un projet qui contient déjà un fichier composer.json, lancez composer install afin de télécharger les dépendances du projet.

      Jetons un coup d’œil rapide aux contraintes de version. Si vous vérifiez le contenu de votre fichier composer.json, vous verrez quelque chose comme ceci :

      Output

      { "require": { "cocur/slugify": "^4.0" } }

      Vous remarquerez peut-être le caractère spécial ^ avant le numéro de version dans composer.json. Composer accepte plusieurs contraintes et formats différents pour définir la version de paquet requise afin d’offrir une certaine souplesse tout en maintenant la stabilité de votre projet. L’opérateur caret (^) utilisé par le fichier composer.json généré automatiquement est l’opérateur recommandé pour une interopérabilité maximale, après le versionnage sémantique. Dans ce cas, elle définit4.0 comme version minimale compatible, et permet les mises à jour de toute version future inférieure à 5.0.

      D’une manière générale, vous n’aurez pas besoin de modifier les contraintes de version dans votre fichier composer.json. Toutefois, certaines situations peuvent vous obliger à modifier manuellement les contraintes, par exemple lorsqu’une nouvelle version importante de votre bibliothèque requise est publiée et que vous souhaitez la mettre à niveau, ou lorsque la bibliothèque que vous souhaitez utiliser ne suit pas la sémantique des versions.

      Voici quelques exemples pour vous donner une meilleure compréhension du fonctionnement des contraintes de version de Composer :

      Contrainte Signification Exemples de versions autorisées
      ^1.0 >= 1,0 < 2,0 1.0, 1.2.3, 1.9.9
      ^1.1.0 >= 1.1.0 < 2.0 1.1.0, 1.5.6, 1.9.9
      ~1.0 >= 1,0 < 2.0.0 1.0, 1.4.1, 1.9.9
      ~1.0.0 >= 1.0.0 < 1.1 1.0.9
      1.2.1 1.2.1 1.2.1
      1.* >= 1,0 < 2,0 1.0.9, 1.4.5, 1.9.9
      1.2. * >= 1.2 < 1.3 1.2.0, 1.2.3, 1.2.9

      Pour une vue plus approfondie des contraintes des versions de Composer, voir la documentation officielle.

      Ensuite, voyons comment charger des dépendances automatiquement avec Composer.

      Étape 4 – Inclure le script d’autochargement

      Comme PHP lui-même ne charge pas automatiquement les classes, Composer fournit un script d’autochargement que vous pouvez inclure dans votre projet afin que l’autochargement fonctionne pour votre projet. Ce fichier est automatiquement généré par Composer lorsque vous ajoutez votre première dépendance.

      La seule chose que vous devez faire est d’inclure le fichier vendor/autoload.php dans vos scripts PHP avant toute instanciation de classe.

      Essayons-le dans notre application de démonstration. Ouvrez un nouveau fichier appelé test.php dans votre éditeur de texte :

      Ajoutez le code suivant qui apporte le fichier vendor/autoload.php, lance la dépendance cocur/slugify et l’utilise pour créer un slug :

      test.php

      <?php
      require __DIR__ . '/vendor/autoload.php';
      
      use CocurSlugifySlugify;
      
      $slugify = new Slugify();
      
      echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');
      

      Enregistrez le fichier et quittez votre éditeur.

      Maintenant, lancez le script :

      Cela produit le résultat "hello-world-this-is-a-long-sentence-and--i-need-to-make-a-slug-from-it.

      Les dépendances ont besoin de mises à jour lorsque de nouvelles versions sortent, alors regardons comment gérer cela.

      Étape 5 – Mettre à jour les dépendances des projets

      Chaque fois que vous souhaitez mettre à jour les dépendances de votre projet vers des versions plus récentes, lancez la commande update:

      Cela permettra de vérifier s’il existe des versions plus récentes des bibliothèques dont vous avez eu besoin dans votre projet. Si une version plus récente est trouvée et qu’elle est compatible avec la contrainte de version définie dans le fichier composer.json, Composer remplacera la version précédente installée. Le fichier composer.lock sera mis à jour pour refléter ces changements.

      Vous pouvez également mettre à jour une ou plusieurs bibliothèques spécifiques en les spécifiant comme ceci :

      • composer update vendor/package vendor2/package2

      N’oubliez pas de vérifier vos fichiers composer.json et composer.lock dans votre système de contrôle de version après avoir mis à jour vos dépendances afin que d’autres puissent également installer ces nouvelles versions. 

      Conclusion

      Composer est un outil puissant qui peut grandement faciliter le travail de gestion des dépendances dans les projets PHP. Il fournit un moyen fiable de découvrir, d’installer et de mettre à jour les paquets PHP dont dépend un projet. Dans ce guide, nous avons vu comment installer Composer, comment inclure de nouvelles dépendances dans un projet, et comment mettre à jour ces dépendances lorsque de nouvelles versions sont disponibles.



      Source link

      Cómo instalar y utilizar Composer en Ubuntu 20.04


      Introducción

      Composer es una herramienta popular de administración de dependencias para PHP, creada principalmente para facilitar la instalación y actualización de dependencias de proyectos. Comprueba los demás paquetes de los que depende un proyecto específico y los instala utilizando las versiones apropiadas según los requisitos de este. Composer también se utiliza comúnmente para iniciar nuevos proyectos en función de marcos PHP populares, como Symfony y Laravel.

      A través de este tutorial, instalará y comenzará a utilizar Composer en un sistema Ubuntu 20.04.

      Requisitos previos

      Para seguir esta guía, necesitará acceso a un servidor de Ubuntu 20.04 como un non-root sudo user y un firewall habilitado en su servidor. Para configurarlo, puede consultar nuestra Guía de configuración inicial de servidores para Ubuntu 20.04.

      Paso 1: Instalar PHP y dependencias adicionales

      Además de las dependencias que ya deben estar incluidas en su sistema de Ubuntu 20.04, como git y curl, Composer requiere php-cli para ejecutar las secuencias de comandos PHP en la línea de comandos y unzip para extraer los archivos comprimidos. Instalaremos estas dependencias ahora.

      Primero, actualice la caché del administrador de paquetes ejecutando lo siguiente:

      Luego, ejecute el siguiente comando para instalar los paquetes requeridos:

      • sudo apt install php-cli unzip

      Se le solicitará confirmar la instalación escribiendo Y y luego ENTER.

      Una vez que haya instalado lo que se estipula en los requisitos previos, podrá proceder con la instalación de Composer.

      Paso 2: Descargar e instalar Composer

      Composer ofrece una secuencia de comandos de instalación escrita en PHP. La descargaremos, comprobaremos que no esté dañada y la utilizaremos para instalar Composer.

      Asegúrese de posicionarse en su directorio de inicio y obtenga el instalador usando curl:

      • cd ~
      • curl -sS https://getcomposer.org/installer -o composer-setup.php

      A continuación, verificaremos que el instalador descargado coincida con el hash SHA-384 para el instalador más reciente disponible en la página Composer Public Keys/Signatures. A fin de facilitar el paso de verificación, puede utilizar el siguiente comando para obtener de forma programática el hash más reciente de la página de Composer y almacenarlo en una variable de shell:

      • HASH=`curl -sS https://composer.github.io/installer.sig`

      Si desea verificar el valor obtenido, puede ejecutar lo siguiente:

      Output

      e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

      Ahora, ejecute el siguiente código PHP, como se indica en la página de descarga de Composer, para verificar que la secuencia de comandos de instalación se pueda ejecutar de forma segura:

      • php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

      Verá el siguiente resultado:

      Output

      Installer verified
      

      Si aparece el mensaje Installer corrupt, tendrá que volver a descargar la secuencia de comandos de instalación y verificar nuevamente si utilizó el hash correcto. Luego, repita el proceso de verificación. Cuando cuente con un instalador verificado, podrá continuar.

      Para instalar composer de manera global, utilice el siguiente comando que lo descargará e instalará en todo el sistema como un comando llamado composer, en /usr/local/bin:

      • sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

      Verá un resultado similar a este:

      Output

      All settings correct for using Composer Downloading... Composer (version 1.10.5) successfully installed to: /usr/local/bin/composer Use it: php /usr/local/bin/composer

      Para comprobar su instalación, ejecute lo siguiente:

      Output

      ______ / ____/___ ____ ___ ____ ____ ________ _____ / / / __ / __ `__ / __ / __ / ___/ _ / ___/ / /___/ /_/ / / / / / / /_/ / /_/ (__ ) __/ / ____/____/_/ /_/ /_/ .___/____/____/___/_/ /_/ Composer version 1.10.5 2020-04-10 11:44:22 Usage: command [options] [arguments] Options: -h, --help Display this help message -q, --quiet Do not output any message -V, --version Display this application version --ansi Force ANSI output --no-ansi Disable ANSI output -n, --no-interaction Do not ask any interactive question --profile Display timing and memory usage information --no-plugins Whether to disable plugins. -d, --working-dir=WORKING-DIR If specified, use the given directory as working directory. --no-cache Prevent use of the cache -v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug ...

      Esto comprueba que Composer se instaló con éxito y está disponible en todo el sistema.

      Nota: Si prefiere tener ejecutables de Composer separados para cada proyecto que aloje en este servidor, puede instalarlos localmente para cada proyecto. Este método también es útil cuando su usuario de sistema no tiene permisos para instalar software en todo el sistema.

      Para ello, utilice el comando php composer-setup.php. Con esto, se generará un archivo composer.phar en su directorio actual que puede ejecutarse con php composer.phar.

      Ahora, veamos el uso de Composer para administrar dependencias.

      Paso 3: Usar Composer en un proyecto de PHP

      Los proyectos de PHP a menudo dependen de bibliotecas externas y la administración de estas dependencias y sus versiones puede ser complicada. Composer resuelve ese problema realizando un seguimiento de las versiones y dependencias del proyecto, al mismo tiempo que facilita el proceso de búsqueda, instalación y actualización de los paquetes que requiere el proyecto.

      Para utilizar Composer en su proyecto, necesitará un archivo composer.json. El archivo composer.json indica a Composer las dependencias que debe descargar para su proyecto y las versiones de cada paquete cuya instalación está permitida. Esto es extremadamente importante para preservar la uniformidad de su proyecto y evitar la instalación de versiones inestables que podrían causar problemas de compatibilidad con versiones anteriores.

      No necesita crear este archivo de forma manual; hay muchas probabilidades de cometer errores de sintaxis al hacerlo. Composer ofrece una opción interactiva para crear un nuevo archivo composer.json en base a la entrada del usuario, una buena opción si planea compartir su proyecto más adelante como paquete público en Packagist. Composer también genera de forma automática un archivo composer.json​​ barebones cuando ejecuta un comando composer require para incluir una dependencia a un proyecto recién creado.

      Para usar Composer en la instalación de un paquete como dependencia en un proyecto, se deben seguir estos pasos:

      • Identifique el tipo de biblioteca que requiere la aplicación.
      • Busque una biblioteca de código abierto adecuada  en Packagist.org, el repositorio oficial de paquetes de Composer.
      • Elija el paquete que desee usar.
      • Ejecute composer require para incluir la dependencia en el archivo composer.json e instale el paquete.

      Probemos esto con una aplicación de demostración.

      El objetivo de esta aplicación es transformar una oración en una cadena compatible con una URL; un slug. Esto se utiliza comúnmente para convertir los títulos de páginas en rutas URL (como la parte final de la URL de este tutorial).

      Comencemos creando un directorio para nuestro proyecto. Lo llamaremos slugify:

      • cd ~
      • mkdir slugify
      • cd slugify

      Aunque no sea obligatorio, ahora podrá ejecutar un comando composer init a fin de crear un archivo composer.json detallado para su proyecto. Ya que que el único objetivo de nuestro proyecto es demostrar la forma de instalar dependencias con Composer, utilizaremos un archivo composer.json más sencillo que se generará automáticamente cuando necesitemos nuestro primer paquete.

      Ahora será el momento de buscar en Packagist.org un paquete que puede servirnos para generar slugs. Si busca el término “slug” en Packagist, obtendrá un resultado similar a este:

      Resultados de búsqueda en Packagist para el término

      Observará dos números en el lado derecho de cada paquete de la lista. El número de la parte superior representa la cantidad de veces que se instaló el paquete a través de Composer y el de la parte inferior la cantidad de veces que se destacó un paquete en GitHub. En general, los paquetes con más instalaciones y más estrellas suelen ser más estables, ya que muchas personas los utilizan. También es importante revisar la descripción del paquete para asegurarse de que se adecue a lo que usted requiere.

      Necesitamos un convertidor de cadena a slug. Conforme a los resultados de la búsqueda, el paquete cocur/slugify, que aparece como el primer resultado de esa página, parece ser una buena opción al ofrecer una cantidad razonable de instalaciones y estrellas.

      Los paquetes en Packagist tienen un nombre de proveedor y un nombre de paquete. Cada paquete tiene un identificador único (un espacio de nombres) en el mismo formato que GitHub utiliza para sus repositorios: vendor/package​​​. La biblioteca que deseamos instalar utiliza el espacio de nombres cocur/slugify. Necesita el espacio de nombres del paquete para solicitarlo en su proyecto.

      Ahora que sabe exactamente qué paquete desea instalar, puede ejecutar composer require para incluirlo como una dependencia y generar también el archivo composer.json para su proyecto: Algo que es importante destacar al requerir paquetes es que Composer realiza un seguimiento tanto de las dependencias a nivel de aplicación como de las dependencias a nivel de sistema. Las dependencias a nivel de sistema son importantes para indicar en qué módulos PHP se basa un paquete. En el caso del paquete cocur/slugify, requiere un módulo PHP que aún no hemos instalado.

      Cuando un paquete requerido se basa en una biblioteca del sistema que no esté instalada actualmente en su servidor, recibirá un mensaje de error indicando el requisito que falta:

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been updated Loading composer repositories with package information Updating dependencies (including require-dev) Your requirements could not be resolved to an installable set of packages. Problem 1 - Installation request for cocur/slugify ^4.0 -> satisfiable by cocur/slugify[v4.0.0]. - cocur/slugify v4.0.0 requires ext-mbstring * -> the requested PHP extension mbstring is missing from your system. ...

      Para resolver el problema de dependencia del sistema, podemos buscar el paquete que falta utilizando apt search​​​:

      Output

      Sorting... Done Full Text Search... Done php-mbstring/focal 2:7.4+75 all MBSTRING module for PHP [default] php-patchwork-utf8/focal 1.3.1-1 all UTF-8 strings handling for PHP php7.4-mbstring/focal 7.4.3-4ubuntu1 amd64 MBSTRING module for PHP

      Después de ubicar el nombre del paquete correcto, puede utilizar apt una vez más para instalar la dependencia del sistema:

      • sudo apt install php-mbstring

      Una vez que la instalación haya finalizado, podrá ejecutar el comando composer require de nuevo:

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been created Loading composer repositories with package information Updating dependencies (including require-dev) Package operations: 1 install, 0 updates, 0 removals - Installing cocur/slugify (v4.0.0): Downloading (100%) Writing lock file Generating autoload files

      Como se observa en el resultado, Composer automáticamente decidió la versión del paquete que utilizará. Si revisa el directorio de su proyecto, este contendrá dos nuevos archivos, composer.json y composer.lock, y un directorio vendor:

      Output

      total 12 -rw-rw-r-- 1 sammy sammy 59 May 4 13:56 composer.json -rw-rw-r-- 1 sammy sammy 3229 May 4 13:56 composer.lock drwxrwxr-x 4 sammy sammy 4096 May 4 13:56 vendor

      El archivo composer.lock se utiliza para almacenar información sobre las versiones de cada paquete que están instaladas y garantizar que se utilicen las mismas versiones si otra persona clona su proyecto e instala sus dependencias. En el directorio vendor se ubican las dependencias del proyecto. La carpeta vendor no debe comprometerse con el control de versión; solo debe incluir los archivos composer.json y composer.lock.

      Al instalar un proyecto que ya contenga un archivo composer.json, ejecute composer install para descargar las dependencias del proyecto.

      Veamos rápidamente las restricciones de versiones. Si verifica los contenidos de su archivo composer.json, verá algo parecido a lo siguiente:

      Output

      { "require": { "cocur/slugify": "^4.0" } }

      Posiblemente observe el carácter especial ^ antes del número de versión en composer.json. A fin de proporcionar flexibilidad y a su vez mantener la estabilidad de su proyecto, Composer admite diferentes restricciones y formatos para definir la versión requerida del paquete. El operador del símbolo de intercalación (^) utilizado por el archivo de generación automática composer.json es el operador recomendado para una máxima interoperabilidad, seguido del control de versión semántico. En este caso, define la versión 4.0 como la versión de compatibilidad mínima y permite actualizaciones a cualquier versión futura inferior a la 5.0.

      En general, no tendrá que alterar las restricciones de versiones de su archivo composer.json. Sin embargo, en algunas situaciones posiblemente deba editar las restricciones manualmente; por ejemplo, cuando se lance una nueva versión importante de su biblioteca requerida y desee actualizarla, o cuando la biblioteca que desee utilizar no siga el control de versión semántico.

      Aquí se muestran algunos ejemplos para que comprenda mejor el funcionamiento de las restricciones de versiones de Composer:

      Restricción Significado Versiones de ejemplos permitidas
      ^1.0 >= 1.0 < 2.0 1.0, 1.2.3, 1.9.9
      ^1.1.0 >= 1.1.0 < 2.0 1.1.0, 1.5.6, 1.9.9
      ~1.0 >= 1.0 < 2.0.0 1.0, 1.4.1, 1.9.9
      ~1.0.0 >= 1.0.0 < 1.1 1.0.0, 1.0.4, 1.0.9
      1.2.1 1.2.1 1.2.1
      1.* >= 1.0 < 2.0 1.0.0, 1.4.5, 1.9.9
      1.2. * >= 1.2 < 1.3 1.2.0, 1.2.3, 1.2.9

      Para acceder a una perspectiva más detallada de las restricciones de versiones de Composer, consulte la documentación oficial.

      A continuación, veamos la forma de cargar las dependencias automáticamente con Composer.

      Paso 4: Incluir la secuencia de comandos de carga automática

      Dado que PHP por sí mismo no carga automáticamente las clases, Composer proporciona una secuencia de comandos de carga automática que puede incluir en su proyecto para que la carga automática funcione en su proyecto. Composer genera este archivo de manera automática al añadir su primera dependencia.

      Lo único que debe hacer es incluir el archivo vendor/autoload.php en sus secuencias de comandos de PHP antes de cualquier instancia de clase.

      Probemos esto en nuestra aplicación de demostración. Abra un archivo nuevo llamado test.php en su editor de texto:

      Añada el siguiente código que agrega el archivo vendor/autoload.php, carga la dependencia cocur/slugify y la utiliza para crear un slug:

      test.php

      <?php
      require __DIR__ . '/vendor/autoload.php';
      
      use CocurSlugifySlugify;
      
      $slugify = new Slugify();
      
      echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');
      

      Guarde el archivo y cierre el editor.

      Ahora ejecute la secuencia de comandos:

      El resultado de esto es hello-world-this-is-a-long-sentence-and-i-need-to-make-a-slug-from-it.

      Las dependencias necesitan actualizaciones cuando se lanzan nuevas versiones. Veamos la forma de manejar eso.

      Paso 5: Actualizar dependencias del proyecto

      Cuando desee actualizar las dependencias de proyecto a versiones más recientes, ejecute el comando update:

      Con esto, se buscarán versiones más recientes de las bibliotecas que necesitó en su proyecto. Si se encuentra una versión más reciente y es compatible con la restricción de versión definida en el archivo composer.json, Composer sustituirá la versión anterior instalada. El archivo composer.lock se actualizará para reflejar estos cambios.

      También puede actualizar una o más bibliotecas determinadas especificándolas de la siguiente manera:

      • composer update vendor/package vendor2/package2

      Después de actualizar sus dependencias, asegúrese de verificar sus archivos composer.json y composer.lock en su sistema de control de versiones para que otros también puedan instalar estas versiones más recientes.

      Conclusión

      Composer es una herramienta poderosa que puede facilitar mucho el trabajo de gestionar dependencias en proyectos PHP. Ofrece una manera confiable de descubrir, instalar y actualizar los paquetes PHP de los que depende un proyecto. En esta guía, vimos cómo instalar Composer, incluir nuevas dependencias en un proyecto y actualizar estas dependencias una vez que haya nuevas versiones disponibles.



      Source link

      Como Instalar e Utilizar o Composer no Ubuntu 20.04


      Introdução

      O Composer é uma ferramenta popular de gerenciamento de dependências para o PHP, criado principalmente para facilitar a instalação e a atualização das dependências do projeto. Ele verificará de quais outros pacotes um projeto específico depende e os instalará para você, usando as versões apropriadas de acordo com os requisitos do projeto. O Composer também é comumente utilizado para inicializar novos projetos baseados em frameworks PHP populares, como o Symfony e o Laravel.

      Neste tutorial, você instalará e começará a utilizar o Composer em um sistema Ubuntu 20.04.

      Pré-requisitos

      Para seguir este guia, você precisará de acesso a um servidor Ubuntu 20.04 como um usuário sudo não-root e um firewall habilitado em seu servidor. Para configurar isto, siga nosso guia Configuração do servidor inicial para o Ubuntu 20.04

      Passo 1 — Instalando o PHP e as Dependências Adicionais

      Além das dependências que já devem estar incluídas em seu sistema Ubuntu 20.04, como o git e o curl, o Composer exige o php-cli para executar scripts PHP na linha de comando e o unzip para extrair arquivos zipados. Vamos instalar essas dependências agora.

      Primeiro, atualize o cache do gerenciador de pacotes executando:

      Em seguida, execute o seguinte comando para instalar os pacotes necessários:

      • sudo apt install php-cli unzip

      Você será solicitado a confirmar a instalação digitando Y e, depois, ENTER.

      Assim que os pré-requisitos estiverem instalados, você pode seguir para a instalação do Composer.

      Passo 2 — Baixando e Instalando o Composer

      O Composer fornece um script installer escrito em PHP. Vamos baixá-lo, verificar se ele não está corrompido e, em seguida, o usaremos para instalar o Composer.

      Certifique-se de estar em seu diretório home. Em seguida, baixe o instalador usando o curl:

      • cd ~
      • curl -sS https://getcomposer.org/installer -o composer-setup.php

      Em seguida, vamos verificar se o instalador baixado corresponde ao hash SHA-384 para o instalador mais recente encontrado na página Composer Public Keys / Signatures. Para facilitar o passo de verificação, você pode utilizar o seguinte comando para obter programaticamente o hash mais recente da página do Composer e armazená-lo em uma variável de shell:

      • HASH=`curl -sS https://composer.github.io/installer.sig`

      Se você quiser verificar o valor obtido, execute:

      Output

      e0012edf3e80b6978849f5eff0d4b4e4c79ff1609dd1e613307e16318854d24ae64f26d17af3ef0bf7cfb710ca74755a

      Agora, execute o código PHP a seguir, conforme fornecido na página de download do Composer, para verificar se o script de instalação está seguro para ser executado:

      • php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

      Você verá o seguinte resultado:

      Output

      Installer verified
      

      Se a saída diz Installer corrupt,você precisará baixar o script de instalação novamente e verificar se você está usando o hash correto. Em seguida, repita o processo de verificação. Quando você tiver um instalador verificado, você pode continuar.

      Para instalar o composer globalmente, use o seguinte comando que baixará e instalará o Composer como um comando disponível em todo o sistema chamado composer, sob /usr/local/bin:

      • sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

      Você verá um resultado parecido com este:

      Output

      All settings correct for using Composer Downloading... Composer (version 1.10.5) successfully installed to: /usr/local/bin/composer Use it: php /usr/local/bin/composer

      Para testar a sua instalação, execute:

      Output

      ______ / ____/___ ____ ___ ____ ____ ________ _____ / / / __ / __ `__ / __ / __ / ___/ _ / ___/ / /___/ /_/ / / / / / / /_/ / /_/ (__ ) __/ / ____/____/_/ /_/ /_/ .___/____/____/___/_/ /_/ Composer version 1.10.5 2020-04-10 11:44:22 Usage: command [options] [arguments] Options: -h, --help Display this help message -q, --quiet Do not output any message -V, --version Display this application version --ansi Force ANSI output --no-ansi Disable ANSI output -n, --no-interaction Do not ask any interactive question --profile Display timing and memory usage information --no-plugins Whether to disable plugins. -d, --working-dir=WORKING-DIR If specified, use the given directory as working directory. --no-cache Prevent use of the cache -v|vv|vvv, --verbose Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug ...

      Isso verifica que o Composer foi instalado com sucesso em seu sistema e está disponível em todo o sistema.

      Nota: se você preferir ter executáveis separados do Composer para cada projeto hospedado neste servidor, você pode instalá-lo localmente, em uma base por projeto. Este método também é útil quando seu usuário de sistema não possui permissão para instalar software disponível em todo o sistema.

      Para fazer isso, use o comando php composer-setup.php. Isso irá gerar um arquivo composer.phar em seu diretório atual, que pode ser executado com php composer.phar.

      Agora vamos dar uma olhada em como utilizar o Composer para gerenciar as dependências.

      Passo 3 — Usando o Composer em um Projeto PHP

      Os projetos PHP geralmente dependem de bibliotecas externas, e o gerenciamento dessas dependências e suas versões pode ser complicado. O Composer resolve esse problema mantendo o controle de versões e dependências do projeto, enquanto também facilita o processo de descoberta, instalação e atualização de pacotes que são necessários por um projeto.

      Para utilizar o Composer em seu projeto, você precisará de um arquivo composer.json. O arquivo composer.json informa ao Composer quais dependências ele precisa baixar para seu projeto e quais versões de cada pacote tem permissão para serem instaladas. Isso é muito importante para manter seu projeto consistente e evitar instalar versões instáveis que podem causar problemas de compatibilidade retroativa.

      Você não precisa criar este arquivo manualmente – é comum ocorrerem erros de sintaxe quando fizer isso. O Composer oferece uma maneira interativa de criar um novo arquivo composer.json com base na entrada do usuário, o que é uma boa escolha se você planeja compartilhar seu projeto mais tarde como um pacote público no Packagist. O Composer também gera automaticamente um arquivo básico composer.json quando você executa um comando composer require para incluir uma dependência em um projeto recém-criado.

      O processo de utilizar o Composer para instalar um pacote como uma dependência em um projeto envolve os passos a seguir:

      • Identifique o tipo de biblioteca que o aplicativo precisa.
      • Pesquise uma biblioteca de código aberto adequada no Packagist.org, o repositório oficial de pacotes para o Composer.
      • Escolha o pacote de dependência.
      • Execute composer require para incluir a dependência no arquivo composer.json e instalar o pacote.

      Vamos testar isso com uma aplicação de demonstração.

      O objetivo desta aplicação é transformar uma determinada sentença em uma string de URL amigável – um slug. Isso é comumente usado para converter os títulos de página para caminhos de URL (Assim como a parte final da URL para este tutorial).

      Vamos começar criando um diretório para o nosso projeto. Vamos chamá-lo de slugify:

      • cd ~
      • mkdir slugify
      • cd slugify

      Embora não seja necessário, você pode executar agora um comando composer init para criar um arquivo composer.json detalhado para seu projeto. Como o único objetivo do nosso projeto é demonstrar como instalar dependências com o Composer, usaremos um arquivo composer.json mais simples que será gerado automaticamente quando exigirmos nosso primeiro pacote.

      Agora é hora de procurar no Packagist.org por um pacote que pode nos ajudar a gerar slugs. Se você procurar pelo termo “slug” no Packagist, receberá um resultado parecido com este:

      Packagist Search Results for the term

      Você verá dois números no lado direito de cada pacote na lista. O número no topo representa quantas vezes o pacote foi instalado através do Composer, e o número em baixo mostra quantas vezes um pacote foi estrelado no GitHub. De um modo geral, os pacotes com mais instalações e mais estrelas tendem a ser mais estáveis, pois mais pessoas os utilizam. Também é importante verificar a descrição do pacote para relevância para garantir que ele é o que você precisa.

      Precisamos de um conversor string-to-slug A partir dos resultados da pesquisa, o pacote cocur/slugify, que aparece como o primeiro resultado naquela página, parece ser um bom candidato, com uma quantidade razoável de instalações e estrelas.

      Os pacotes no Packagist têm um nome de vendor e um nome de package. Cada pacote tem um identificador único (um namespace) no mesmo formato que o GitHub utiliza para seus repositórios: vendor/package. A biblioteca que queremos instalar utiliza o namespace cocur/slugify. Você precisa de um namespace do pacote para exigi-lo em seu projeto.

      Agora que você sabe exatamente qual pacote deseja instalar, você pode executar o composer require para incluí-lo como uma dependência e gerar também o arquivo composer.json para seu projeto. Uma coisa importante é observar a exigência de pacotes. O Composer rastreia as dependências no nível da aplicação e do sistema. As dependências no nível do sistema são importantes para indicar de quais módulos PHP um pacote depende. No caso do pacote cocur/slugify, ele exige um módulo PHP que ainda não instalamos.

      Quando um pacote necessário depende de uma biblioteca de sistema que não está atualmente instalada em seu servidor, você receberá um erro informando qual requisito está faltando:

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been updated Loading composer repositories with package information Updating dependencies (including require-dev) Your requirements could not be resolved to an installable set of packages. Problem 1 - Installation request for cocur/slugify ^4.0 -> satisfiable by cocur/slugify[v4.0.0]. - cocur/slugify v4.0.0 requires ext-mbstring * -> the requested PHP extension mbstring is missing from your system. ...

      Para resolver o problema de dependência do sistema, podemos procurar pelo pacote que falta usando o apt search:

      Output

      Sorting... Done Full Text Search... Done php-mbstring/focal 2:7.4+75 all MBSTRING module for PHP [default] php-patchwork-utf8/focal 1.3.1-1 all UTF-8 strings handling for PHP php7.4-mbstring/focal 7.4.3-4ubuntu1 amd64 MBSTRING module for PHP

      Após localizar o nome do pacote correto, você pode utilizar o apt novamente para instalar a dependência de sistema:

      • sudo apt install php-mbstring

      Assim que a instalação terminar, você pode executar novamente o comando composer require:

      • composer require cocur/slugify

      Output

      Using version ^4.0 for cocur/slugify ./composer.json has been created Loading composer repositories with package information Updating dependencies (including require-dev) Package operations: 1 install, 0 updates, 0 removals - Installing cocur/slugify (v4.0.0): Downloading (100%) Writing lock file Generating autoload files

      Como você pode ver na saída, o Composer decidiu automaticamente qual versão do pacote utilizar. Se você verificar o diretório do seu projeto agora, ele irá conter dois arquivos novos: composer.json e composer.lock, e um diretório vendor:

      Output

      total 12 -rw-rw-r-- 1 sammy sammy 59 May 4 13:56 composer.json -rw-rw-r-- 1 sammy sammy 3229 May 4 13:56 composer.lock drwxrwxr-x 4 sammy sammy 4096 May 4 13:56 vendor

      O arquivo composer.lock é usado para armazenar informações sobre quais versões de cada pacote estão instaladas, e garantir que as mesmas versões sejam usadas se outra pessoa clonar seu projeto e instalar suas dependências. O diretório vendor é onde as dependências do projeto estão localizadas. Você não deve fazer commit da pasta vendor no controle de versão – você precisa apenas incluir os arquivos composer.json e composer.lock.

      Ao instalar um projeto que já contém um arquivo composer.json, execute o composer install para baixar as dependências do projeto.

      Vamos dar uma olhada rápida em restrições de versão. Se você verificar o conteúdo do seu arquivo composer.json, verá algo parecido com isto:

      Output

      { "require": { "cocur/slugify": "^4.0" } }

      Note que há o caractere especial ^ antes do número da versão no composer.json. O Composer suporta várias restrições diferentes e formatos para definir a versão necessária do pacote, para fornecer flexibilidade enquanto também mantém seu projeto estável. O operador circunflexo (^) utilizado pelo arquivo composer.json criado automaticamente é o operador recomendado para a interoperabilidade máxima, seguindo o versionamento semântico. Neste caso, ele define 4.0 como a versão mínima compatível e permite atualizações para qualquer versão futura abaixo de 5.0.

      De um modo geral, você não precisará alterar as restrições de versão em seu arquivo composer.json. No entanto, algumas situações podem exigir que você edite manualmente as restrições – por exemplo, quando uma nova versão principal da sua biblioteca requerida é liberada e você deseja atualizar, ou quando a biblioteca que você deseja usar não segue o versionamento semântico.

      Aqui estão alguns exemplos para lhe dar um melhor entendimento sobre como as restrições de versão do Composer funcionam:

      Restrição Significado Exemplo de Versões Permitidas
      ^1.0 >= 1.0 < 2.0 1.0, 1.2.3, 1.9.9
      ^1.1.0 >= 1.1.0 < 2.0 1.1.0, 1.5.6, 1.9.9
      ~1.0 >= 1.0 < 2.0.0 1.0, 1.4.1, 1.9.9
      ~1.0.0 >= 1.0.0 < 1.1 1.0.0, 1.0.4, 1.0.9
      1.2.1 1.2.1 1.2.1
      1.* >= 1.0 < 2.0 1.0.0, 1.4.5, 1.9.9
      1.2. * >= 1.2 < 1.3 1.2.0, 1.2.3, 1.2.9

      Para uma visualização mais detalhada das restrições de versão do Composer, consulte a documentação oficial.

      A seguir, vamos ver como carregar dependências automaticamente com o Composer.

      Passo 4 — Incluindo o Script Autoload

      Como o PHP por si só não carrega classes automaticamente, o Composer fornece um script autoload que você pode incluir em seu projeto para obter o carregamento automático para ele. Este arquivo é gerado automaticamente pelo Composer quando você adiciona sua primeira dependência.

      A única coisa que você precisa fazer é incluir o arquivo vendor/autoload.php em seus scripts PHP antes de qualquer instância de classe.

      Vamos testar isso em nossa aplicação de demonstração. Abra um novo arquivo chamado test.php em seu editor de texto:

      Adicione o código a seguir que vem no arquivo vendor/autoload.php, carrega a dependência cocur/slugify, e o utiliza para criar um slug:

      test.php

      <?php
      require __DIR__ . '/vendor/autoload.php';
      
      use CocurSlugifySlugify;
      
      $slugify = new Slugify();
      
      echo $slugify->slugify('Hello World, this is a long sentence and I need to make a slug from it!');
      

      Salve o arquivo e saia do seu editor.

      Agora, execute o script.

      Isso produz a saída hello-world-this-is-a-long-sentence-and-i-need-to-make-a-slug-from-it.

      As dependências precisam de atualizações quando novas versões são liberadas. Dessa forma, vamos ver como lidar com isso.

      Passo 5 — Atualizando as Dependências do Projeto

      Sempre que você quiser atualizar suas dependências do projeto para versões mais recentes, execute o comando update:

      Isso irá verificar por versões mais recentes das bibliotecas que você requer em seu projeto. Se uma versão mais recente for encontrada e ela for compatível com a restrição de versão definida no arquivo composer.json, o Composer substituirá a versão anterior instalada. O arquivo composer.lock será atualizado para refletir essas alterações.

      Você também pode atualizar uma ou mais bibliotecas específicas, especificando-as desta forma:

      • composer update vendor/package vendor2/package2

      Certifique-se de verificar em seus arquivos composer.json e composer.lock dentro do seu sistema de controle de versão após atualizar suas dependências de modo que outros também possam instalar essas versões mais recentes.

      Conclusão

      O Composer é uma ferramenta poderosa que facilita o trabalho de gerenciar as dependências em projetos PHP. Ele fornece uma maneira confiável de descobrir, instalar e atualizar pacotes PHP dos quais um projeto depende. Neste guia, vimos como instalar o Composer, como incluir novas dependências em um projeto, e como atualizar essas dependências assim que as novas versões estiverem disponíveis.



      Source link