download feed io - download de código-fonte feed io

feed-io

feed-io é uma biblioteca PHP construída para consumir e servir feeds de notícias. Possui:

Suporte para leitura e gravação JSONFeed / Atom / RSS
Alimenta a descoberta automática por meio de cabeçalhos HTML
uma interface de linha de comando para descobrir e ler feeds
Geração de resposta PSR-7 com cabeçalhos de cache precisos
Suporte a cabeçalhos HTTP ao ler feeds para economizar tráfego de rede
Detecção do formato (RSS/Atom) na leitura de feeds
Suporte de gabinete para lidar com mídias externas, como conteúdo de áudio
Suporte para logotipo de feed (RSS + Atom)
Registro compatível com PSR
Filtragem de conteúdo para buscar apenas os itens mais recentes
Detecção e conversão de DateTime
Uma interface de cliente HTTP genérica
Integra-se com todos os clientes HTTP compatíveis com PSR-18.

Esta biblioteca é altamente extensível e foi projetada para se adaptar a diversas situações, então se você não encontrar uma solução através da documentação fique à vontade para perguntar nas discussões.

Instalação

Use o Composer para adicionar feed-io aos requisitos do seu projeto:

    composer require debril/feed-io

Requisitos

feed-io	PHP
4.x	7.1+
5,0	8,0+
6,0	8.1+

feed-io 4 requer PHP 7.1+, feed-io 5 requer PHP 8.0+. Todas as versões dependem de psr/log e de qualquer cliente HTTP compatível com PSR-18. Para continuar usando você pode precisar de php-http/guzzle7-adapter . sugere monolog para registro. Monolog não é a única biblioteca adequada para lidar com logs do feed-io; em vez disso, você pode usar qualquer biblioteca compatível com PSR/Log.

Uso

CLI

Suponhamos que você instalou o feed-io usando o Composer, você pode usar seu cliente de linha de comando para ler feeds do seu terminal:

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

leitura

feed-io foi projetado para ler feeds na Internet e publicar os seus próprios. Sua classe principal é 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 ();
}

Se você precisar obter apenas os novos itens desde a última vez que consumiu o feed, use o método getItemsSince() do 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 ();
}

Você também pode misturar vários filtros para excluir itens de acordo com sua necessidade:

 // 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 economizar largura de banda, o feed-io estima a próxima vez que será relevante ler o feed e obter novos itens dele.

 $ 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 o horário da próxima atualização detectando primeiro se o feed esteve ativo nos últimos 7 dias e, caso contrário, consideramos-o como sonolento. A próxima data de atualização de um feed sonolento é definida para o dia seguinte, no mesmo horário. Se o feed não estiver inativo, usamos o intervalo médio e o intervalo mediano adicionando esses intervalos à data da última modificação do feed e comparando o resultado com a hora atual. Se o resultado estiver no futuro, ele será retornado como o horário da próxima atualização. Se nenhum deles estiver no futuro, consideramos que o feed será atualizado em breve, portanto o próximo horário de atualização será uma hora depois do momento do cálculo.

Observação: os atrasos fixos para feeds suspensos e fechados para serem atualizados podem ser definidos por meio de Result::getNextUpdate() , consulte Resultado para obter mais detalhes.

Descoberta de feeds

Uma página da web pode se referir a um ou mais feeds em seus cabeçalhos. O feed-io fornece uma maneira de descobri-los:

 // 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 você pode usar a linha de comando do feed-io:

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

Você obterá todos os feeds descobertos na saída.

formatando um objeto em um fluxo XML

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

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

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

Adicionando uma folha de estilo

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

construindo um feed incluindo 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 );

Criando uma resposta PSR-7 válida com um feed

Você pode transformar um FeedIoFeedInstance diretamente em uma resposta válida do 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 ' );

Construindo uma instância FeedIo

Para criar uma nova instância FeedIo você só precisa injetar duas dependências:

um cliente HTTP implementando FeedIoAdapterClientInterface. Pode ser um wrapper para uma biblioteca externa como FeedIoAdapterGuzzleClient
um registrador PSR-3 implementando 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 );

Outro exemplo com o Monolog configurado para escrever na saída padrão:

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

Injetar um Logger personalizado

Você pode injetar qualquer Logger que desejar, desde que implemente PsrLogLoggerInterface . Monolog sim, mas não é a ú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 );

Injetar um cliente HTTP personalizado

Desde a versão 6.0, existe um adaptador HTTP genérico que envolve qualquer cliente HTTP compatível com 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 );

Configure o feed-io usando o Factory

A fábrica foi descontinuada no feed-io 5.2 e removida no 6.0. Instancie a fachada diretamente e passe o cliente HTTP desejado e a interface do logger.

Lidando com fusos horários ausentes

Às vezes você tem que consumir feeds nos quais o fuso horário está faltando nas datas. Em alguns casos de uso, pode ser necessário especificar o fuso horário do feed para obter um valor preciso, então o feed-io oferece uma solução alternativa para isso:

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