Descargar feed io - descargar código fuente feed io

alimentación-io

feed-io es una biblioteca PHP creada para consumir y servir noticias. Cuenta con:

Soporte de lectura y escritura JSONFeed / Atom / RSS
Alimenta el descubrimiento automático a través de encabezados HTML
una interfaz de línea de comandos para descubrir y leer feeds
PSR-7 Generación de respuestas con encabezados de caché precisos
Soporte de encabezados HTTP al leer feeds para ahorrar tráfico de red
Detección del formato (RSS / Atom) al leer feeds
Soporte de gabinete para manejar medios externos como contenido de audio
Soporte de logotipo de feed (RSS + Atom)
Registro compatible con PSR
Filtrado de contenido para buscar solo los elementos más nuevos
Detección y conversión de fecha y hora
Una interfaz de cliente HTTP genérica
Se integra con todos los clientes HTTP compatibles con PSR-18.

Esta biblioteca es altamente extensible y está diseñada para adaptarse a muchas situaciones, por lo que si no encuentra una solución a través de la documentación, no dude en preguntar en las discusiones.

Instalación

Utilice Composer para agregar feed-io a los requisitos de su proyecto:

    composer require debril/feed-io

Requisitos

alimentación-io	PHP
4.x	7.1+
5.0	8.0+
6.0	8.1+

feed-io 4 requiere PHP 7.1+, feed-io 5 requiere PHP 8.0+. Todas las versiones se basan en psr/log y cualquier cliente HTTP compatible con PSR-18. Para continuar usándolo, es posible que necesites php-http/guzzle7-adapter . sugiere monolog para iniciar sesión. Monolog no es la única biblioteca adecuada para manejar los registros de feed-io; en su lugar, puede utilizar cualquier biblioteca compatible con PSR/Log.

Uso

CLI

Supongamos que instaló feed-io usando Composer, puede usar su cliente de línea de comandos para leer feeds desde su terminal:

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

lectura

feed-io está diseñado para leer feeds en Internet y publicar los suyos propios. Su clase principal es 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 necesita obtener solo los elementos nuevos desde la última vez que consumió el feed, use el método getItemsSince() del resultado:

 // 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 ();
}

También puedes combinar varios filtros para excluir elementos según tus necesidades:

 // 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 ();
}

Para ahorrar ancho de banda, feed-io estima la próxima vez que será relevante leer el feed y obtener nuevos elementos del mismo.

 $ 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 calcula el tiempo de la próxima actualización detectando primero si el feed estuvo activo en los últimos 7 días y si no lo consideramos como dormido. La próxima fecha de actualización para un feed somnoliento se establece al día siguiente a la misma hora. Si el feed no tiene sueño, utilizamos el intervalo promedio y el intervalo mediano sumando esos intervalos a la última fecha de modificación del feed y comparando el resultado con la hora actual. Si el resultado es en el futuro, se devuelve como la próxima hora de actualización. Si ninguno de ellos está en el futuro, consideramos que el feed se actualizará bastante pronto, por lo que la próxima actualización será una hora más tarde desde el momento del cálculo.

Tenga en cuenta: los retrasos fijos para los feeds con sueño y cerrados para actualizar se pueden configurar a través de Result::getNextUpdate() ; consulte Resultado para obtener más detalles.

Descubrimiento de feeds

Una página web puede hacer referencia a uno o más feeds en sus encabezados, feed-io proporciona una manera de descubrirlos:

 // 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 }" ;
}

O puedes usar la línea de comando de feed-io:

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

Obtendrá todos los feeds descubiertos en el resultado.

formatear un objeto en una secuencia XML

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

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

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

Agregar una hoja de estilo

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

crear un feed que incluya medios

 // 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 );

Crear una respuesta PSR-7 válida con un feed

Puede convertir una FeedIoFeedInstance directamente en una respuesta válida de PSR-7 usando 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 ' );

Construyendo una instancia de FeedIo

Para crear una nueva instancia de FeedIo solo necesitas inyectar dos dependencias:

un cliente HTTP que implementa FeedIoAdapterClientInterface. Puede ser un contenedor para una biblioteca externa como FeedIoAdapterGuzzleClient
un registrador PSR-3 que implementa 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 );

Otro ejemplo con Monolog configurado para escribir en la salida estándar:

 // 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 );

Inyectar un registrador personalizado

Puede inyectar cualquier Logger que desee siempre que implemente PsrLogLoggerInterface . Monolog lo hace, pero no es la única biblioteca: 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 );

Inyectar un cliente HTTP personalizado

Desde la versión 6.0 existe un adaptador HTTP genérico que envuelve cualquier cliente HTTP compatible con 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 );

Configurar feed-io usando Factory

La fábrica quedó obsoleta en feed-io 5.2 y se eliminó en 6.0. Cree una instancia de la fachada directamente y pase el cliente HTTP y la interfaz de registrador deseados.

Cómo lidiar con zonas horarias faltantes

A veces es necesario consumir feeds en los que falta la zona horaria en las fechas. En algunos casos de uso, es posible que necesites especificar la zona horaria del feed para obtener un valor preciso, por lo que feed-io ofrece una solución alternativa para ello:

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