FeedIo::resetFilters() - Code Metrics - Inspection of "createFromFormat() expects fromat to be a string" - alexdebril/feed-io - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — release/3.0 (#204)

unknown

created 2019-03-10 10:47 UTC

FeedIo::resetFilters() A

↳ Parent: FeedIo

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?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			public function __construct(ClientInterface $client, LoggerInterface $logger)
103			{
104			$this->logger = $logger;
105			$this->dateTimeBuilder = new DateTimeBuilder($logger);
106			$this->setReader(new Reader($client, $logger));
107			$this->loadCommonStandards();
108			$this->loadFixerSet();
109			}
110
111			/**
112			* Loads main standards (RSS, RDF, Atom) in current object's attributes
113			*
114			* @return $this
115			*/
116			protected function loadCommonStandards()
117			{
118			$standards = $this->getCommonStandards();
119			foreach ($standards as $name => $standard) {
120			$this->addStandard($name, $standard);
121			}
122
123			return $this;
124			}
125
126			/**
127			* adds a filter to the reader
128			*
129			* @param \FeedIo\FilterInterface $filter
130			* @return $this
131			*/
132			public function addFilter(FilterInterface $filter)
133			{
134			$this->getReader()->addFilter($filter);
135
136			return $this;
137			}
138
139			/**
140			* Returns main standards
141			*
142			* @return array
143			*/
144			public function getCommonStandards()
145			{
146			$loader = new Loader();
147
148			return $loader->getCommonStandards($this->getDateTimeBuilder());
149			}
150
151			/**
152			* @param string $name
153			* @param \FeedIo\StandardAbstract $standard
154			* @return $this
155			*/
156			public function addStandard($name, StandardAbstract $standard)
157			{
158			$name = strtolower($name);
159			$this->standards[$name] = $standard;
160			$parser = $this->newParser($standard->getSyntaxFormat(), $standard);
161			$this->reader->addParser($parser);
162
163			return $this;
164			}
165
166			/**
167			* @param string $format
168			* @param StandardAbstract $standard
169			* @return object
170			*/
171			public function newParser($format, StandardAbstract $standard)
172			{
173			$reflection = new \ReflectionClass("FeedIo\\Parser\\{$format}Parser");
174
175			if (! $reflection->isSubclassOf('FeedIo\ParserAbstract')) {
176			throw new \InvalidArgumentException();
177			}
178
179			return $reflection->newInstanceArgs([$standard, $this->logger]);
180			}
181
182			/**
183			* @return \FeedIo\Reader\FixerSet
184			*/
185			public function getFixerSet()
186			{
187			return $this->fixerSet;
188			}
189
190			/**
191			* @return $this
192			*/
193			protected function loadFixerSet()
194			{
195			$this->fixerSet = new FixerSet();
196			$fixers = $this->getBaseFixers();
197
198			foreach ($fixers as $fixer) {
199			$this->addFixer($fixer);
200			}
201
202			return $this;
203			}
204
205			/**
206			* @param FixerAbstract $fixer
207			* @return $this
208			*/
209			public function addFixer(FixerAbstract $fixer)
210			{
211			$fixer->setLogger($this->logger);
212			$this->fixerSet->add($fixer);
213
214			return $this;
215			}
216
217			/**
218			* @return array
219			*/
220			public function getBaseFixers()
221			{
222			return array(
223			new Reader\Fixer\LastModified(),
224			new Reader\Fixer\PublicId(),
225
226			);
227			}
228
229			/**
230			* @param array $formats
231			* @return $this
232			*/
233			public function addDateFormats(array $formats)
234			{
235			foreach ($formats as $format) {
236			$this->getDateTimeBuilder()->addDateFormat($format);
237			}
238
239			return $this;
240			}
241
242			/**
243			* @return \FeedIo\Rule\DateTimeBuilder
244			*/
245			public function getDateTimeBuilder()
246			{
247			return $this->dateTimeBuilder;
248			}
249
250			/**
251			* @return \FeedIo\Reader
252			*/
253			public function getReader()
254			{
255			return $this->reader;
256			}
257
258			/**
259			* @param \FeedIo\Reader
260			* @return $this
261			*/
262			public function setReader(Reader $reader)
263			{
264			$this->reader = $reader;
265
266			return $this;
267			}
268
269			/**
270			* @param $url
271			* @param FeedInterface $feed
272			* @param \DateTime $modifiedSince
273			* @return \FeedIo\Reader\Result
274			*/
275			public function read($url, FeedInterface $feed = null, \DateTime $modifiedSince = null)
276			{
277			if (is_null($feed)) {
278			$feed = new Feed();
279			}
280
281			if ($modifiedSince instanceof \DateTime) {
282			$this->addFilter(new ModifiedSince($modifiedSince));
283			}
284
285			$this->logAction($feed, "read access : $url into a feed instance");
286			$result = $this->reader->read($url, $feed, $modifiedSince);
287
288			$this->fixerSet->correct($result->getFeed());
289
290			return $result;
291			}
292
293			/**
294			* @param $url
295			* @param \DateTime $modifiedSince
296			* @return \FeedIo\Reader\Result
297			*/
298			public function readSince($url, \DateTime $modifiedSince)
299			{
300			return $this->read($url, new Feed(), $modifiedSince);
301			}
302
303			/**
304			* @return $this
305			*/
306			public function resetFilters()
307			{
308			$this->getReader()->resetFilters();
309
310			return $this;
311			}
312
313			/**
314			* @param FeedInterface $feed
315			* @param string $standard Standard's name
316			* @return string
317			*/
318			public function format(FeedInterface $feed, $standard)
319			{
320			$this->logAction($feed, "formatting a feed in $standard format");
321
322			$formatter = $this->getStandard($standard)->getFormatter();
323
324			return $formatter->toString($feed);
325			}
326
327			/**
328			* @param \FeedIo\FeedInterface $feed
329			* @return string
330			*/
331			public function toRss(FeedInterface $feed)
332			{
333			return $this->format($feed, 'rss');
334			}
335
336			/**
337			* @param \FeedIo\FeedInterface $feed
338			* @return string
339			*/
340			public function toAtom(FeedInterface $feed)
341			{
342			return $this->format($feed, 'atom');
343			}
344
345			/**
346			* @param \FeedIo\FeedInterface $feed
347			* @return string
348			*/
349			public function toJson(FeedInterface $feed)
350			{
351			return $this->format($feed, 'json');
352			}
353
354
355			/**
356			* @param string $name
357			* @return \FeedIo\StandardAbstract
358			* @throws \OutOfBoundsException
359			*/
360			public function getStandard($name)
361			{
362			$name = strtolower($name);
363			if (array_key_exists($name, $this->standards)) {
364			return $this->standards[$name];
365			}
366
367			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			protected function logAction(FeedInterface $feed, $message)
376			{
377			$class = get_class($feed);
378			$this->logger->debug("$message (feed class : $class)");
379
380			return $this;
381			}
382			}
383

alexdebril / feed-io

Pull Request — release/3.0 (#204)

FeedIo::resetFilters() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like