feed io Télécharger - feed io Téléchargement du code source

flux-io

feed-io est une bibliothèque PHP conçue pour consommer et servir des flux d'actualités. Il comporte :

Prise en charge de la lecture et de l'écriture JSONFeed / Atom / RSS
Détection automatique des flux via les en-têtes HTML
une interface de ligne de commande pour découvrir et lire les flux
Génération de réponse PSR-7 avec des en-têtes de cache précis
Prise en charge des en-têtes HTTP lors de la lecture des flux afin d'économiser le trafic réseau
Détection du format (RSS/Atom) lors de la lecture des flux
Prise en charge du boîtier pour gérer les médias externes comme le contenu audio
Prise en charge du logo de flux (RSS + Atom)
Journalisation conforme PSR
Filtrage de contenu pour récupérer uniquement les éléments les plus récents
Détection et conversion DateTime
Une interface client HTTP générique
S'intègre à tous les clients HTTP compatibles PSR-18.

Cette bibliothèque est hautement extensible et est conçue pour s'adapter à de nombreuses situations, donc si vous ne trouvez pas de solution via la documentation, n'hésitez pas à la demander dans les discussions.

Installation

Utilisez Composer pour ajouter feed-io aux exigences de votre projet :

    composer require debril/feed-io

Exigences

flux-io	PHP
4.x	7.1+
5.0	8.0+
6.0	8.1+

feed-io 4 nécessite PHP 7.1+, feed-io 5 nécessite PHP 8.0+. Toutes les versions s'appuient sur psr/log et sur tout client HTTP compatible PSR-18. Pour continuer à utiliser, vous aurez peut-être besoin php-http/guzzle7-adapter . il suggère monolog pour la journalisation. Monolog n'est pas la seule bibliothèque adaptée pour gérer les journaux de feed-io, vous pouvez utiliser n'importe quelle bibliothèque compatible PSR/Log à la place.

Usage

CLI

Supposons que vous ayez installé feed-io à l'aide de Composer, vous pouvez utiliser son client en ligne de commande pour lire les flux depuis votre terminal :

./vendor/bin/feedio read http://php.net/feed.atom

en lisant

feed-io est conçu pour lire les flux sur Internet et pour publier les vôtres. Sa classe principale est FeedIo :

 // create a simple FeedIo instance, e.g. with the Symfony HTTP Client
$ client = new  FeedIo  Adapter  Http  Client ( new Symfony  Component  HttpClient  HttplugClient ());
$ feedIo =  FeedIo FeedIo ( $ client );

// read a feed
$ result = $ feedIo -> read ( $ url );

// get title
$ feedTitle = $ result -> getFeed ()-> getTitle ();

// iterate through items
foreach ( $ result -> getFeed () as $ item ) {
    echo $ item -> getTitle ();
}

Si vous avez besoin d'obtenir uniquement les nouveaux éléments depuis la dernière fois que vous avez consommé le flux, utilisez la méthode getItemsSince() du résultat :

 // read a feed and specify the `$modifiedSince` limit to fetch only items newer than this date
$ result = $ feedIo -> read ( $ url , $ feed , $ modifiedSince );

// iterate through new items
foreach ( $ result -> getItemsSince () as $ item ) {
    echo $ item -> getTitle ();
}

Vous pouvez également mélanger plusieurs filtres pour exclure des éléments selon vos besoins :

 // read a feed
$ result = $ feedIo -> read ( $ url , $ feed , $ modifiedSince );

// remove items older than `$modifiedSince`
$ since = new FeedIo  Filter  Since ( $ result -> getModifiedSince ());

// Your own filter
$ database = new Acme  Filter  Database ();

$ chain = new Chain ();
$ chain
    -> add ( $ since )
    -> add ( $ database );

// iterate through new items
foreach ( $ result -> getFilteredItems ( $ chain ) as $ item ) {
    echo $ item -> getTitle ();
}

Afin d'économiser de la bande passante, feed-io estime la prochaine fois qu'il sera pertinent de lire le flux et d'en extraire de nouveaux éléments.

 $ nextUpdate = $ result -> getNextUpdate ();
echo " computed next update: { $ nextUpdate -> format ( DATE_ATOM )}" ;

// you may need to access the statistics
$ updateStats = $ result -> getUpdateStats ();
echo " average interval in seconds: { $ updateStats -> getAverageInterval ()}" ;

feed-io calcule l'heure de la prochaine mise à jour en détectant d'abord si le flux était actif au cours des 7 derniers jours et sinon nous le considérons comme endormi. La prochaine date de mise à jour d'un flux endormi est fixée au lendemain à la même heure. Si le flux n'est pas endormi, nous utilisons l'intervalle moyen et l'intervalle médian en ajoutant ces intervalles à la date de dernière modification du flux et comparons le résultat à l'heure actuelle. Si le résultat est dans le futur, il est renvoyé comme prochaine heure de mise à jour. Si aucun d'entre eux n'est dans le futur, nous avons considéré que le flux sera mis à jour très bientôt, donc la prochaine mise à jour est une heure plus tard à partir du moment du calcul.

Veuillez noter : les délais fixes pour la mise à jour des flux endormis et fermés peuvent être définis via Result::getNextUpdate() , voir Result pour plus de détails.

Découverte des flux

Une page web peut faire référence à un ou plusieurs flux dans ses en-têtes, feed-io permet de les découvrir :

 // create a simple FeedIo instance, e.g. with the Symfony HTTP Client
$ client = new  FeedIo  Adapter  Http  Client ( new Symfony  Component  HttpClient  HttplugClient ());
$ feedIo =  FeedIo FeedIo ( $ client );

$ feeds = $ feedIo -> discover ( $ url );

foreach ( $ feeds as $ feed ) {
    echo " discovered feed : { $ feed }" ;
}

Ou vous pouvez utiliser la ligne de commande de feed-io :

./vendor/bin/feedio discover https://a-website.org

Vous obtiendrez tous les flux découverts dans la sortie.

formater un objet dans un flux XML

 // build the feed
$ feed = new FeedIo  Feed ;
$ feed -> setTitle ( ' ... ' );

// convert it into Atom
$ atomString = $ feedIo -> toAtom ( $ feed );

// or ...
$ atomString = $ feedIo -> format ( $ feed , ' atom ' );

Ajout d'une feuille de style

 $ feed = new FeedIo  Feed ;
$ feed -> setTitle ( ' ... ' );
$ styleSheet = new StyleSheet ( ' http://url-of-the-xsl-stylesheet.xsl ' );
$ feed -> setStyleSheet ( $ styleSheet );

construire un flux incluant les médias

 // build the feed
$ feed = new FeedIo  Feed ;
$ feed -> setTitle ( ' ... ' );

$ item = $ feed -> newItem ();

// add namespaces
$ feed -> setNS (
    ' itunes ' , //namespace
    ' http://www.itunes.com/dtds/podcast-1.0.dtd ' //dtd for the namespace
        );
$ feed -> set ( ' itunes,title ' , ' Sample Title ' ); //OR any other element defined in the namespace.
$ item -> addElement ( ' itunes:category ' , ' Education ' );

// build the media
$ media = new  FeedIo  Feed  Item  Media
$ media -> setUrl ( ' http://yourdomain.tld/medias/some-podcast.mp3 ' );
$ media -> setType ( ' audio/mpeg ' );

// add it to the item
$ item -> addMedia ( $ media );

$ feed -> add ( $ item );

Création d'une réponse PSR-7 valide avec un flux

Vous pouvez transformer un FeedIoFeedInstance directement en une réponse valide PSR-7 en utilisant FeedIoFeedIo::getPsrResponse() :

 $ feed = new  FeedIo  Feed ;

// feed the beast ...
$ item = new  FeedIo  Feed  Item ;
$ item -> set . . .
$ feed -> add ( $ item );

$ atomResponse = $ feedIo -> getPsrResponse ( $ feed , ' atom ' );

$ jsonResponse = $ feedIo -> getPsrResponse ( $ feed , ' json ' );

Créer une instance FeedIo

Pour créer une nouvelle instance FeedIo il vous suffit d'injecter deux dépendances :

un client HTTP implémentant FeedIoAdapterClientInterface. Il peut être un wrapper pour une bibliothèque externe comme FeedIoAdapterGuzzleClient
un enregistreur PSR-3 implémentant PsrLogLoggerInterface

 // first dependency : the HTTP client
// here we use Guzzle as a dependency for the client
$ guzzle = new GuzzleHttp  Client ();
// Guzzle is wrapped in this adapter which is a FeedIoAdapterClientInterface  implementation
$ client = new FeedIo  Adapter  Guzzle  Client ( $ guzzle );

// second dependency : a PSR-3 logger
$ logger = new Psr  Log  NullLogger ();

// now create FeedIo's instance
$ feedIo = new FeedIo  FeedIo ( $ client , $ logger );

Autre exemple avec Monolog configuré pour écrire sur la sortie standard :

 // create a simple FeedIo instance, e.g. with the Symfony HTTP Client
$ client = new  FeedIo  Adapter  Http  Client ( new Symfony  Component  HttpClient  HttplugClient ());
$ logger = new Monolog  Logger ( ' default ' , [ new Monolog  Handler  StreamHandler ( ' php://stdout ' )]);
$ feedIo =  FeedIo FeedIo ( $ client , $ logger );

Injecter un enregistreur personnalisé

Vous pouvez injecter n'importe quel Logger de votre choix à condition qu'il implémente PsrLogLoggerInterface . Monolog le fait, mais ce n'est pas la seule bibliothèque : https://packagist.org/providers/psr/log-implementation

 use FeedIo  FeedIo ;
use FeedIo  Adapter  Guzzle  Client ;
use GuzzleHttp  Client as GuzzleClient ;
use Custom  Logger ;

$ client = new Client ( new GuzzleClient ());
$ logger = new Logger ();

$ feedIo = new FeedIo ( $ client , $ logger );

Injecter un client HTTP personnalisé

Depuis la version 6.0, il existe un adaptateur HTTP générique qui encapsule tout client HTTP compatible PST-18.

 use CustomPsr18  Client as CustomClient ;

$ client = new Custom  Adapter  Http Client( new CustomClient ())
$ logger = new Psr  Log  NullLogger ();

$ feedIo = new FeedIo  FeedIo ( $ client , $ logger );

Configurer feed-io à l'aide de Factory

L'usine est obsolète dans feed-io 5.2 et a été supprimée dans 6.0. Instanciez la façade directement et transmettez le client HTTP et l'interface d'enregistrement souhaités.

Gérer les fuseaux horaires manquants

Parfois, vous devez consommer des flux dans lesquels le fuseau horaire est absent des dates. Dans certains cas d'utilisation, vous devrez peut-être spécifier le fuseau horaire du flux pour obtenir une valeur précise, donc feed-io propose une solution de contournement pour cela :

 $ feedIo -> getDateTimeBuilder ()-> setFeedTimezone ( new  DateTimeZone ( $ feedTimezone ));
$ result = $ feedIo -> read ( $ feedUrl );
$ feedIo -> getDateTimeBuilder ()-> resetFeedTimezone ();

N'oubliez pas de réinitialiser feedTimezone après avoir récupéré le résultat, sinon vous vous retrouverez avec tous les flux situés dans le même fuseau horaire.