FeedIo::toRss() - Code Metrics - Inspection of "Handle empty response" - alexdebril/feed-io - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — issue/109 ( 45613d )

by Alex

created 2017-07-20 11:43 UTC

FeedIo::toRss() A

↳ Parent: FeedIo

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php
/*
 * This file is part of the feed-io package.
 *
 * (c) Alexandre Debril <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FeedIo;

use FeedIo\Filter\ModifiedSince;
use FeedIo\Reader;
use FeedIo\Reader\FixerSet;
use FeedIo\Reader\FixerAbstract;
use FeedIo\Rule\DateTimeBuilder;
use FeedIo\Adapter\ClientInterface;
use FeedIo\Standard\Loader;
use Psr\Log\LoggerInterface;

/**
 * This class acts as a facade. It provides methods to access feed-io main features
 *
 * <code>
 *   // $client is a \FeedIo\Adapter\ClientInterface instance, $logger a \Psr\Log\LoggerInterface
 *   $feedIo = new FeedIo($client, $logger);
 *
 *   // read a feed. Output is a Result instance
 *   $result = $feedIo->read('http://somefeed.org/feed.rss');
 *
 *   // use the feed
 *   $feed = $result->getFeed();
 *   echo $feed->getTitle();
 *
 *   // and its items
 *   foreach ( $feed as $item ) {
 *       echo $item->getTitle();
 *       echo $item->getDescription();
 *   }
 *
 * </code>
 *
 * <code>
 *   // build the feed to publish
 *   $feed = new \FeedIo\Feed;
 *   $feed->setTitle('title');
 *   // ...
 *
 *   // add items to it
 *   $item = new \FeedIo\Feed\Item
 *   $item->setTitle('my great post');
 *
 *   // want to publish a media ? no problem
 *   $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);
 *
 *   // add the item to the feed (almost there)
 *   $feed->add($item);
 *
 *   // format it in atom
 *   $feedIo->toAtom($feed);
 * </code>
 *
 */
class FeedIo
{

    /**
     * @var \FeedIo\Reader
     */
    protected $reader;

    /**
     * @var \FeedIo\Rule\DateTimeBuilder
     */
    protected $dateTimeBuilder;

    /**
     * @var \Psr\Log\LoggerInterface
     */
    protected $logger;

    /**
     * @var array
     */
    protected $standards;

    /**
     * @var \FeedIo\Reader\FixerSet
     */
    protected $fixerSet;

    /**
     * @param \FeedIo\Adapter\ClientInterface $client
     * @param \Psr\Log\LoggerInterface        $logger
     */
    public function __construct(ClientInterface $client, LoggerInterface $logger)
    {
        $this->logger = $logger;
        $this->dateTimeBuilder = new DateTimeBuilder($logger);
        $this->setReader(new Reader($client, $logger));
        $this->loadCommonStandards();
        $this->loadFixerSet();
    }

    /**
     * Loads main standards (RSS, RDF, Atom) in current object's attributes
     *
     * @return $this
     */
    protected function loadCommonStandards()
    {
        $standards = $this->getCommonStandards();
        foreach ($standards as $name => $standard) {
            $this->addStandard($name, $standard);
        }

        return $this;
    }

    /**
     * adds a filter to the reader
     *
     * @param \FeedIo\FilterInterface $filter
     * @return $this
     */
    public function addFilter(FilterInterface $filter)
    {
        $this->getReader()->addFilter($filter);

        return $this;
    }

    /**
     * Returns main standards
     *
     * @return array
     */
    public function getCommonStandards()
    {
        $loader = new Loader();

        return $loader->getCommonStandards($this->getDateTimeBuilder());
    }

    /**
     * @param  string                   $name
     * @param  \FeedIo\StandardAbstract $standard
     * @return $this
     */
    public function addStandard($name, StandardAbstract $standard)
    {
        $name = strtolower($name);
        $this->standards[$name] = $standard;
        $parser = $this->newParser($standard->getSyntaxFormat(), $standard);
        $this->reader->addParser($parser);

        return $this;
    }

    /**
     * @param string $format
     * @param StandardAbstract $standard
     * @return object
     */
    public function newParser($format, StandardAbstract $standard)
    {
        $reflection = new \ReflectionClass("FeedIo\\Parser\\{$format}Parser");

        if (! $reflection->isSubclassOf('FeedIo\ParserAbstract')) {
            throw new \InvalidArgumentException();
        }

        return $reflection->newInstanceArgs([$standard, $this->logger]);
    }

    /**
     * @return \FeedIo\Reader\FixerSet
     */
    public function getFixerSet()
    {
        return $this->fixerSet;
    }

    /**
     * @return $this
     */
    protected function loadFixerSet()
    {
        $this->fixerSet = new FixerSet();
        $fixers = $this->getBaseFixers();

        foreach ($fixers as $fixer) {
            $this->addFixer($fixer);
        }

        return $this;
    }

    /**
     * @param  FixerAbstract $fixer
     * @return $this
     */
    public function addFixer(FixerAbstract $fixer)
    {
        $fixer->setLogger($this->logger);
        $this->fixerSet->add($fixer);

        return $this;
    }

    /**
     * @return array
     */
    public function getBaseFixers()
    {
        return array(
            new Reader\Fixer\LastModified(),
            new Reader\Fixer\PublicId(),

        );
    }

    /**
     * @param array $formats
     * @return $this
     */
    public function addDateFormats(array $formats)
    {
        foreach ($formats as $format) {
            $this->getDateTimeBuilder()->addDateFormat($format);
        }

        return $this;
    }

    /**
     * @return \FeedIo\Rule\DateTimeBuilder
     */
    public function getDateTimeBuilder()
    {
        return $this->dateTimeBuilder;
    }

    /**
     * @return \FeedIo\Reader
     */
    public function getReader()
    {
        return $this->reader;
    }

    /**
     * @param \FeedIo\Reader
     * @return $this
     */
    public function setReader(Reader $reader)
    {
        $this->reader = $reader;

        return $this;
    }

    /**
     * @param $url
     * @param  FeedInterface         $feed
     * @param  \DateTime             $modifiedSince
     * @return \FeedIo\Reader\Result
     */
    public function read($url, FeedInterface $feed = null, \DateTime $modifiedSince = null)
    {
        if (is_null($feed)) {
            $feed = new Feed();
        }

        if ($modifiedSince instanceof \DateTime) {
            $this->addFilter(new ModifiedSince($modifiedSince));
        }

        $this->logAction($feed, "read access : $url into a feed instance");
        $result = $this->reader->read($url, $feed, $modifiedSince);

        $this->fixerSet->correct($result->getFeed());

        return $result;
    }

    /**
     * @param $url
     * @param  \DateTime             $modifiedSince
     * @return \FeedIo\Reader\Result
     */
    public function readSince($url, \DateTime $modifiedSince)
    {
        return $this->read($url, new Feed(), $modifiedSince);
    }

    /**
     * @return $this
     */
    public function resetFilters()
    {
        $this->getReader()->resetFilters();

        return $this;
    }

    /**
     * @param  FeedInterface $feed
     * @param  string        $standard Standard's name
     * @return string
     */
    public function format(FeedInterface $feed, $standard)
    {
        $this->logAction($feed, "formatting a feed in $standard format");

        $formatter = $this->getStandard($standard)->getFormatter();

        return $formatter->toString($feed);
    }

    /**
     * @param  \FeedIo\FeedInterface $feed
     * @return string
     */
    public function toRss(FeedInterface $feed)
    {
        return $this->format($feed, 'rss');
    }

    /**
     * @param  \FeedIo\FeedInterface $feed
     * @return string
     */
    public function toAtom(FeedInterface $feed)
    {
        return $this->format($feed, 'atom');
    }

    /**
     * @param  \FeedIo\FeedInterface $feed
     * @return string
     */
    public function toJson(FeedInterface $feed)
    {
        return $this->format($feed, 'json');
    }


    /**
     * @param  string                   $name
     * @return \FeedIo\StandardAbstract
     * @throws \OutOfBoundsException
     */
    public function getStandard($name)
    {
        $name = strtolower($name);
        if (array_key_exists($name, $this->standards)) {
            return $this->standards[$name];
        }

        throw new \OutOfBoundsException("no standard found for $name");
    }

    /**
     * @param  \FeedIo\FeedInterface $feed
     * @param  string                $message
     * @return $this
     */
    protected function logAction(FeedInterface $feed, $message)
    {
        $class = get_class($feed);
        $this->logger->debug("$message (feed class : $class)");

        return $this;
    }
}


1		<?php
2		/*
3		* This file is part of the feed-io package.
4		*
5		* (c) Alexandre Debril <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10
11		namespace FeedIo;
12
13		use FeedIo\Filter\ModifiedSince;
14		use FeedIo\Reader;
15		use FeedIo\Reader\FixerSet;
16		use FeedIo\Reader\FixerAbstract;
17		use FeedIo\Rule\DateTimeBuilder;
18		use FeedIo\Adapter\ClientInterface;
19		use FeedIo\Standard\Loader;
20		use Psr\Log\LoggerInterface;
21
22		/**
23		* This class acts as a facade. It provides methods to access feed-io main features
24		*
25		* <code>
26		* // $client is a \FeedIo\Adapter\ClientInterface instance, $logger a \Psr\Log\LoggerInterface
27		* $feedIo = new FeedIo($client, $logger);
28		*
29		* // read a feed. Output is a Result instance
30		* $result = $feedIo->read('http://somefeed.org/feed.rss');
31		*
32		* // use the feed
33		* $feed = $result->getFeed();
34		* echo $feed->getTitle();
35		*
36		* // and its items
37		* foreach ( $feed as $item ) {
38		* echo $item->getTitle();
39		* echo $item->getDescription();
40		* }
41		*
42		* </code>
43		*
44		* <code>
45		* // build the feed to publish
46		* $feed = new \FeedIo\Feed;
47		* $feed->setTitle('title');
48		* // ...
49		*
50		* // add items to it
51		* $item = new \FeedIo\Feed\Item
52		* $item->setTitle('my great post');
53		*
54		* // want to publish a media ? no problem
55		* $media = new \FeedIo\Feed\Item\Media
56		* $media->setUrl('http://yourdomain.tld/medias/some-podcast.mp3');
57		* $media->setType('audio/mpeg');
58		*
59		* // add it to the item
60		* $item->addMedia($media);
61		*
62		* // add the item to the feed (almost there)
63		* $feed->add($item);
64		*
65		* // format it in atom
66		* $feedIo->toAtom($feed);
67		* </code>
68		*
69		*/
70		class FeedIo
71		{
72
73		/**
74		* @var \FeedIo\Reader
75		*/
76		protected $reader;
77
78		/**
79		* @var \FeedIo\Rule\DateTimeBuilder
80		*/
81		protected $dateTimeBuilder;
82
83		/**
84		* @var \Psr\Log\LoggerInterface
85		*/
86		protected $logger;
87
88		/**
89		* @var array
90		*/
91		protected $standards;
92
93		/**
94		* @var \FeedIo\Reader\FixerSet
95		*/
96		protected $fixerSet;
97
98		/**
99		* @param \FeedIo\Adapter\ClientInterface $client
100		* @param \Psr\Log\LoggerInterface $logger
101		*/
102	11	public function __construct(ClientInterface $client, LoggerInterface $logger)
103		{
104	11	$this->logger = $logger;
105	11	$this->dateTimeBuilder = new DateTimeBuilder($logger);
106	11	$this->setReader(new Reader($client, $logger));
107	11	$this->loadCommonStandards();
108	11	$this->loadFixerSet();
109	11	}
110
111		/**
112		* Loads main standards (RSS, RDF, Atom) in current object's attributes
113		*
114		* @return $this
115		*/
116	11	protected function loadCommonStandards()
117		{
118	11	$standards = $this->getCommonStandards();
119	11	foreach ($standards as $name => $standard) {
120	11	$this->addStandard($name, $standard);
121	11	}
122
123	11	return $this;
124		}
125
126		/**
127		* adds a filter to the reader
128		*
129		* @param \FeedIo\FilterInterface $filter
130		* @return $this
131		*/
132	2	public function addFilter(FilterInterface $filter)
133		{
134	2	$this->getReader()->addFilter($filter);
135
136	2	return $this;
137		}
138
139		/**
140		* Returns main standards
141		*
142		* @return array
143		*/
144	11	public function getCommonStandards()
145		{
146	11	$loader = new Loader();
147
148	11	return $loader->getCommonStandards($this->getDateTimeBuilder());
149		}
150
151		/**
152		* @param string $name
153		* @param \FeedIo\StandardAbstract $standard
154		* @return $this
155		*/
156	11	public function addStandard($name, StandardAbstract $standard)
157		{
158	11	$name = strtolower($name);
159	11	$this->standards[$name] = $standard;
160	11	$parser = $this->newParser($standard->getSyntaxFormat(), $standard);
161	11	$this->reader->addParser($parser);
162
163	11	return $this;
164		}
165
166		/**
167		* @param string $format
168		* @param StandardAbstract $standard
169		* @return object
170		*/
171	10	public function newParser($format, StandardAbstract $standard)
172		{
173	10	$reflection = new \ReflectionClass("FeedIo\\Parser\\{$format}Parser");
174
175	10	if (! $reflection->isSubclassOf('FeedIo\ParserAbstract')) {
176		throw new \InvalidArgumentException();
177		}
178
179	10	return $reflection->newInstanceArgs([$standard, $this->logger]);
180		}
181
182		/**
183		* @return \FeedIo\Reader\FixerSet
184		*/
185	1	public function getFixerSet()
186		{
187	1	return $this->fixerSet;
188		}
189
190		/**
191		* @return $this
192		*/
193	10	protected function loadFixerSet()
194		{
195	10	$this->fixerSet = new FixerSet();
196	10	$fixers = $this->getBaseFixers();
197
198	10	foreach ($fixers as $fixer) {
199	10	$this->addFixer($fixer);
200	10	}
201
202	10	return $this;
203		}
204
205		/**
206		* @param FixerAbstract $fixer
207		* @return $this
208		*/
209	10	public function addFixer(FixerAbstract $fixer)
210		{
211	10	$fixer->setLogger($this->logger);
212	10	$this->fixerSet->add($fixer);
213
214	10	return $this;
215		}
216
217		/**
218		* @return array
219		*/
220	10	public function getBaseFixers()
221		{
222		return array(
223	10	new Reader\Fixer\LastModified(),
224	10	new Reader\Fixer\PublicId(),
225
226	10	);
227		}
228
229		/**
230		* @param array $formats
231		* @return $this
232		*/
233	1	public function addDateFormats(array $formats)
234		{
235	1	foreach ($formats as $format) {
236	1	$this->getDateTimeBuilder()->addDateFormat($format);
237	1	}
238
239	1	return $this;
240		}
241
242		/**
243		* @return \FeedIo\Rule\DateTimeBuilder
244		*/
245	11	public function getDateTimeBuilder()
246		{
247	11	return $this->dateTimeBuilder;
248		}
249
250		/**
251		* @return \FeedIo\Reader
252		*/
253	4	public function getReader()
254		{
255	4	return $this->reader;
256		}
257
258		/**
259		* @param \FeedIo\Reader
260		* @return $this
261		*/
262	11	public function setReader(Reader $reader)
263		{
264	11	$this->reader = $reader;
265
266	11	return $this;
267		}
268
269		/**
270		* @param $url
271		* @param FeedInterface $feed
272		* @param \DateTime $modifiedSince
273		* @return \FeedIo\Reader\Result
274		*/
275	2	public function read($url, FeedInterface $feed = null, \DateTime $modifiedSince = null)
276		{
277	2	if (is_null($feed)) {
278	1	$feed = new Feed();
279	1	}
280
281	2	if ($modifiedSince instanceof \DateTime) {
282	1	$this->addFilter(new ModifiedSince($modifiedSince));
283	1	}
284
285	2	$this->logAction($feed, "read access : $url into a feed instance");
286	2	$result = $this->reader->read($url, $feed, $modifiedSince);
287
288	2	$this->fixerSet->correct($result->getFeed());
289
290	2	return $result;
291		}
292
293		/**
294		* @param $url
295		* @param \DateTime $modifiedSince
296		* @return \FeedIo\Reader\Result
297		*/
298	1	public function readSince($url, \DateTime $modifiedSince)
299		{
300	1	return $this->read($url, new Feed(), $modifiedSince);
301		}
302
303		/**
304		* @return $this
305		*/
306	1	public function resetFilters()
307		{
308	1	$this->getReader()->resetFilters();
309
310	1	return $this;
311		}
312
313		/**
314		* @param FeedInterface $feed
315		* @param string $standard Standard's name
316		* @return string
317		*/
318	1	public function format(FeedInterface $feed, $standard)
319		{
320	1	$this->logAction($feed, "formatting a feed in $standard format");
321
322	1	$formatter = $this->getStandard($standard)->getFormatter();
323
324	1	return $formatter->toString($feed);
325		}
326
327		/**
328		* @param \FeedIo\FeedInterface $feed
329		* @return string
330		*/
331	1	public function toRss(FeedInterface $feed)
332		{
333	1	return $this->format($feed, 'rss');
334		}
335
336		/**
337		* @param \FeedIo\FeedInterface $feed
338		* @return string
339		*/
340	1	public function toAtom(FeedInterface $feed)
341		{
342	1	return $this->format($feed, 'atom');
343		}
344
345		/**
346		* @param \FeedIo\FeedInterface $feed
347		* @return string
348		*/
349	1	public function toJson(FeedInterface $feed)
350		{
351	1	return $this->format($feed, 'json');
352		}
353
354
355		/**
356		* @param string $name
357		* @return \FeedIo\StandardAbstract
358		* @throws \OutOfBoundsException
359		*/
360	2	public function getStandard($name)
361		{
362	2	$name = strtolower($name);
363	2	if (array_key_exists($name, $this->standards)) {
364	1	return $this->standards[$name];
365		}
366
367	1	throw new \OutOfBoundsException("no standard found for $name");
368		}
369
370		/**
371		* @param \FeedIo\FeedInterface $feed
372		* @param string $message
373		* @return $this
374		*/
375	2	protected function logAction(FeedInterface $feed, $message)
376		{
377	2	$class = get_class($feed);
378	2	$this->logger->debug("$message (feed class : $class)");
379
380	2	return $this;
381		}
382		}
383

alexdebril / feed-io

Push — issue/109 ( 45613d )

FeedIo::toRss() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like