CheckCommand::execute() - Code Metrics - Inspection of "CheckCommand performs 3 batches of checks" - alexdebril/feed-io - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — issue/270 ( cf7824...00d313 )

by Alex

created 2020-03-27 17:10 UTC

CheckCommand::execute() A

↳ Parent: CheckCommand

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	13
ccs	0
cts	11
cp	0
rs	9.8333
c	0
b	0
f	0
cc	2
nc	2
nop	2
crap	6

<?php declare(strict_types=1);
/*
 * 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\Command;

use FeedIo\Command\Check\CheckerAbstract;
use FeedIo\Command\Check\CountChecker;
use FeedIo\Command\Check\HistoryChecker;
use FeedIo\Factory;
use FeedIo\Feed;
use FeedIo\Feed\ItemInterface;
use FeedIo\FeedInterface;
use FeedIo\FeedIo;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Formatter\OutputFormatterStyle;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class CheckCommand extends Command
{

    const UPDATE_PROBLEM = "<warn>Issues found on readSince. Please consider filtering this feed using its public ids</warn>";

    protected function configure()
    {
        $this->setName('check')
            ->setDescription('checks if a feed gets correctly updated')
            ->addArgument(
                'url',
                InputArgument::REQUIRED,
                'Please provide the feed\' URL'
            )
        ;
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->configureOutput($output);
        $url = $input->getArgument('url');

        if( ! $this->runChecks($output, $url) ) {
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $output->writeln("<error>This feed cannot be properly used by feed-io. Please read the above error message and if you think it's a mistake, feel free to submit an issue on Github</error>");
            return 1;
        }

        $output->writeln("<success>This feed can be consumed by feed-io</success>");
        return 0;
    }

    protected function runChecks(OutputInterface $output, string $url): bool
    {
        $feedIo = Factory::create()->getFeedIo();
        $feed = $feedIo->read($url)->getFeed();

        $output->writeln("<info>first access to {$feed->getTitle()}</info>");

        $count = count($feed);
        if ($count == 0) {
            $output->writeln("<error>empty feed</error>");
            return false;
        }

        $output->writeln("<info>found {$count} items</info>");

        $firstHitResult = $this->checkFirstHit($output, $feed);

        $updateStatus = true;
        if ($this->checkSecondHit($output, $feedIo, $url, $firstHitResult)) {
            $output->writeln("<info>readSince works fine</info>");
        } else {
            $updateStatus = false;
            $output->writeln(self::UPDATE_PROBLEM);
        }

        if ($this->checkHitInTheFuture($feedIo, $url)) {
            $output->writeln("<info>a call in the future is empty as expected</info>");
        } else {
            $updateStatus = false;
            $output->writeln(self::UPDATE_PROBLEM);
        }

        return $updateStatus;
    }

    private function checkFirstHit(OutputInterface $output, FeedInterface $feed): array
    {
        $lastModifiedDates = [];
        $publicIds = [];
        /** @var \FeedIo\Feed\ItemInterface $item */
        foreach ($feed as $i => $item) {
            $lastModifiedDates[] = $item->getLastModified();
            $publicIds[] = $item->getPublicId();
        }

        if (! $this->checkPublicIds($publicIds)) {
            $output->writeln("<warn>duplicated publicIds found</warn>");
        }

        sort($lastModifiedDates);
        $first = current($lastModifiedDates);
        $last = end($lastModifiedDates);

        $normalDateFlow = true;
        if ($last > $first) {
            $output->writeln("<info>first item was published on {$first->format(\DateTime::ATOM)}</info>");
            $output->writeln("<info>last item was published on {$last->format(\DateTime::ATOM)}</info>");
        } else {
            $output->writeln("<warn>All items have the same date</warn>");
            $normalDateFlow = false;
        }

        return [
            'lastModifiedDates' => $lastModifiedDates,
            'normalDateFlow' => $normalDateFlow,
            'publicIds' => $publicIds,
        ];
    }

    private function checkSecondHit(OutputInterface $output, FeedIo $feedIo, string $url, array $firstResult): bool
    {
        $count = count($firstResult['lastModifiedDates']);
        $last = end($firstResult['lastModifiedDates']);
        if ($firstResult['normalDateFlow']) {
            $pick = intval($count / 2);
            $lastModified = $firstResult['lastModifiedDates'][$pick];
        } else {
            $lastModified = $last->sub(new \DateInterval('P1D'));
        }

        $secondFeed = $feedIo->readSince($url, $lastModified)->getFeed();

        $count = count($secondFeed);
        if ($count == 0) {
            $output->writeln("<error>The feed is empty on second call, it should have a partial result</error>");
            return false;
        }

        $output->writeln("<info>found {$count} items on second call</info>");
        /** @var \FeedIo\Feed\ItemInterface $item */
        foreach ($secondFeed as $item) {
            if(! in_array($item->getPublicId(), $firstResult['publicIds'])) {
                $output->writeln("<warn>Unknown public ID detected, you should retry to see if it was just a new item published during the check process</warn>");
            }
        }

        return true;
    }

    private function checkHitInTheFuture( FeedIo $feedIo, string $url): bool
    {
        $feed = $feedIo->readSince($url, new \DateTime("+1 week"))->getFeed();

        return count($feed) == 0;
    }

    private function checkPublicIds(array $publicIds): bool
    {
        $deduplicated = array_unique($publicIds);
        return count($deduplicated) == count($publicIds);
    }

    private function configureOutput(OutputInterface $output): void
    {
        $output->getFormatter()->setStyle(
            'warn',
            new OutputFormatterStyle('black', 'magenta', ['bold'])
        );

        $output->getFormatter()->setStyle(
            'success',
            new OutputFormatterStyle('black', 'green', ['bold'])
        );
    }
}


1			<?php declare(strict_types=1);
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\Command;
12
13			use FeedIo\Command\Check\CheckerAbstract;
14			use FeedIo\Command\Check\CountChecker;
15			use FeedIo\Command\Check\HistoryChecker;
16			use FeedIo\Factory;
17			use FeedIo\Feed;
18			use FeedIo\Feed\ItemInterface;
19			use FeedIo\FeedInterface;
20			use FeedIo\FeedIo;
21			use Symfony\Component\Console\Command\Command;
22			use Symfony\Component\Console\Formatter\OutputFormatterStyle;
23			use Symfony\Component\Console\Input\InputArgument;
24			use Symfony\Component\Console\Input\InputInterface;
25			use Symfony\Component\Console\Input\InputOption;
26			use Symfony\Component\Console\Output\OutputInterface;
27
28			class CheckCommand extends Command
29			{
30
31			const UPDATE_PROBLEM = "<warn>Issues found on readSince. Please consider filtering this feed using its public ids</warn>";
32
33			protected function configure()
34			{
35			$this->setName('check')
36			->setDescription('checks if a feed gets correctly updated')
37			->addArgument(
38			'url',
39			InputArgument::REQUIRED,
40			'Please provide the feed\' URL'
41			)
42			;
43			}
44
45			protected function execute(InputInterface $input, OutputInterface $output)
46			{
47			$this->configureOutput($output);
48			$url = $input->getArgument('url');
49
50			if( ! $this->runChecks($output, $url) ) {
			0 ignored issues – show Bug introduced 2020-03-27 17:12 UTC by Report Bug Copy Issue Report It seems like `$url` defined by `$input->getArgument('url')` on line `48` can also be of type `array<integer,string>` or `null`; however, `FeedIo\Command\CheckCommand::runChecks()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
51			$output->writeln("<error>This feed cannot be properly used by feed-io. Please read the above error message and if you think it's a mistake, feel free to submit an issue on Github</error>");
52			return 1;
53			}
54
55			$output->writeln("<success>This feed can be consumed by feed-io</success>");
56			return 0;
57			}
58
59			protected function runChecks(OutputInterface $output, string $url): bool
60			{
61			$feedIo = Factory::create()->getFeedIo();
62			$feed = $feedIo->read($url)->getFeed();
63
64			$output->writeln("<info>first access to {$feed->getTitle()}</info>");
65
66			$count = count($feed);
67			if ($count == 0) {
68			$output->writeln("<error>empty feed</error>");
69			return false;
70			}
71
72			$output->writeln("<info>found {$count} items</info>");
73
74			$firstHitResult = $this->checkFirstHit($output, $feed);
75
76			$updateStatus = true;
77			if ($this->checkSecondHit($output, $feedIo, $url, $firstHitResult)) {
78			$output->writeln("<info>readSince works fine</info>");
79			} else {
80			$updateStatus = false;
81			$output->writeln(self::UPDATE_PROBLEM);
82			}
83
84			if ($this->checkHitInTheFuture($feedIo, $url)) {
85			$output->writeln("<info>a call in the future is empty as expected</info>");
86			} else {
87			$updateStatus = false;
88			$output->writeln(self::UPDATE_PROBLEM);
89			}
90
91			return $updateStatus;
92			}
93
94			private function checkFirstHit(OutputInterface $output, FeedInterface $feed): array
95			{
96			$lastModifiedDates = [];
97			$publicIds = [];
98			/** @var \FeedIo\Feed\ItemInterface $item */
99			foreach ($feed as $i => $item) {
100			$lastModifiedDates[] = $item->getLastModified();
101			$publicIds[] = $item->getPublicId();
102			}
103
104			if (! $this->checkPublicIds($publicIds)) {
105			$output->writeln("<warn>duplicated publicIds found</warn>");
106			}
107
108			sort($lastModifiedDates);
109			$first = current($lastModifiedDates);
110			$last = end($lastModifiedDates);
111
112			$normalDateFlow = true;
113			if ($last > $first) {
114			$output->writeln("<info>first item was published on {$first->format(\DateTime::ATOM)}</info>");
115			$output->writeln("<info>last item was published on {$last->format(\DateTime::ATOM)}</info>");
116			} else {
117			$output->writeln("<warn>All items have the same date</warn>");
118			$normalDateFlow = false;
119			}
120
121			return [
122			'lastModifiedDates' => $lastModifiedDates,
123			'normalDateFlow' => $normalDateFlow,
124			'publicIds' => $publicIds,
125			];
126			}
127
128			private function checkSecondHit(OutputInterface $output, FeedIo $feedIo, string $url, array $firstResult): bool
129			{
130			$count = count($firstResult['lastModifiedDates']);
131			$last = end($firstResult['lastModifiedDates']);
132			if ($firstResult['normalDateFlow']) {
133			$pick = intval($count / 2);
134			$lastModified = $firstResult['lastModifiedDates'][$pick];
135			} else {
136			$lastModified = $last->sub(new \DateInterval('P1D'));
137			}
138
139			$secondFeed = $feedIo->readSince($url, $lastModified)->getFeed();
140
141			$count = count($secondFeed);
142			if ($count == 0) {
143			$output->writeln("<error>The feed is empty on second call, it should have a partial result</error>");
144			return false;
145			}
146
147			$output->writeln("<info>found {$count} items on second call</info>");
148			/** @var \FeedIo\Feed\ItemInterface $item */
149			foreach ($secondFeed as $item) {
150			if(! in_array($item->getPublicId(), $firstResult['publicIds'])) {
151			$output->writeln("<warn>Unknown public ID detected, you should retry to see if it was just a new item published during the check process</warn>");
152			}
153			}
154
155			return true;
156			}
157
158			private function checkHitInTheFuture( FeedIo $feedIo, string $url): bool
159			{
160			$feed = $feedIo->readSince($url, new \DateTime("+1 week"))->getFeed();
161
162			return count($feed) == 0;
163			}
164
165			private function checkPublicIds(array $publicIds): bool
166			{
167			$deduplicated = array_unique($publicIds);
168			return count($deduplicated) == count($publicIds);
169			}
170
171			private function configureOutput(OutputInterface $output): void
172			{
173			$output->getFormatter()->setStyle(
174			'warn',
175			new OutputFormatterStyle('black', 'magenta', ['bold'])
176			);
177
178			$output->getFormatter()->setStyle(
179			'success',
180			new OutputFormatterStyle('black', 'green', ['bold'])
181			);
182			}
183			}
184

alexdebril / feed-io

Push — issue/270 ( cf7824...00d313 )

CheckCommand::execute() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like