AbstractParser::__construct() - Code Metrics - Bouss/boussimmo - Measure and Improve Code Quality continuously with Scrutinizer

AbstractParser::__construct() A
last analyzed 2021-08-02 18:31 UTC

↳ Parent: AbstractParser
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	0
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	0
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	4
ccs	2
cts	2
cp	1
crap	1
rs	10
<?php

namespace App\Parser;

use App\DataProvider\ProviderProvider;
use App\DTO\Property;
use App\DTO\PropertyAd;
use App\Enum\PropertyFilter;
use App\Exception\ParseException;
use App\Util\NumericUtil;
use DateTime;
use Exception;
use Psr\Log\LoggerInterface;
use Symfony\Component\DomCrawler\Crawler;
use function array_filter;
use function Symfony\Component\String\u;

abstract class AbstractParser implements ParserInterface
{
    // Redefined in the child classes
    protected const PROVIDER = null;

    protected const SELECTOR_AD_WRAPPER    = null;
    protected const SELECTOR_PRICE         = null;
    protected const SELECTOR_AREA          = null;
    protected const SELECTOR_ROOMS_COUNT   = null;
    protected const SELECTOR_LOCATION      = null;
    protected const SELECTOR_BUILDING_NAME = null;
    protected const SELECTOR_TITLE         = null;
    protected const SELECTOR_DESCRIPTION   = null;
    protected const SELECTOR_PHOTO         = 'img:first-child';
    protected const SELECTOR_URL           = 'a:first-child';

    private const NEW_BUILD_KEYWORDS = ['neuf', 'livraison', 'programme', 'neuve', 'nouveau', 'nouvelle', 'remise'];

    public function __construct(
        private ProviderProvider $providerProvider,
        protected LoggerInterface $logger
    ) {}

    /**
     * {@inheritDoc}
     */
    public function parse(string $html, array $filters = [], array $params = []): array
    {
        $properties = [];

        // Iterate over all DOM elements wrapping a property ad
        ($this->createCrawler($html))->filter(static::SELECTOR_AD_WRAPPER)->each(function (Crawler $node) use (&$properties, $params) {
        ($this->createCrawler($html))->filter(/** @scrutinizer ignore-type */ static::SELECTOR_AD_WRAPPER)->each(function (Crawler $node) use (&$properties, $params) {
            try {
                $properties[] = $this->parseOne($node, $params['date']);
            } catch (Exception $e) {
                $this->logger->warning('Error while parsing a property: ' . $e->getMessage(), $params);
            }
        });

        if (empty($properties)) {
            throw new ParseException('No property parsed');
        }

        // Filter the properties
        return array_filter($properties, static fn(Property $ad) => isset($filters[PropertyFilter::NEW_BUILD]) ? $ad->isNewBuild() : true);
    }

    /**
     * Enable to modify the DOM before parsing
     *
     * @param string $html
     *
     * @return Crawler
     */
    protected function createCrawler(string $html): Crawler
    {
        return new Crawler($html);
    }

    protected function parsePrice(Crawler $crawler): ?float
    {
        if (null === static::SELECTOR_PRICE) {

            return NumericUtil::parsePrice($crawler->html());
        }

        try {
            $priceStr = trim($crawler->filter(static::SELECTOR_PRICE)->text());
        } catch (Exception) {
            return null;
        }

        return NumericUtil::parsePrice($priceStr);
    }

    protected function parseArea(Crawler $crawler): ?float
    {
        if (null === static::SELECTOR_AREA) {

            return NumericUtil::parseArea($crawler->html());
        }

        try {
            $areaStr = trim($crawler->filter(static::SELECTOR_AREA)->text());
        } catch (Exception) {
            return null;
        }

        return NumericUtil::parseArea($areaStr);
    }

    protected function parseRoomsCount(Crawler $crawler): ?int
    {
        if (null === static::SELECTOR_ROOMS_COUNT) {

            return NumericUtil::parseRoomsCount($crawler->html());
        }

        try {
            $roomsCountStr = trim($crawler->filter(static::SELECTOR_ROOMS_COUNT)->text());
        } catch (Exception) {
            return null;
        }

        return NumericUtil::parseRoomsCount($roomsCountStr);
    }

    protected function parseLocation(Crawler $crawler): ?string
    {
        if (null === static::SELECTOR_LOCATION) {

            return null;
        }

        try {
            return trim($crawler->filter(static::SELECTOR_LOCATION)->text());
        } catch (Exception) {
            return null;
        }
    }

    protected function parseBuildingName(Crawler $crawler): ?string
    {
        if (null === static::SELECTOR_BUILDING_NAME) {

            return null;
        }

        try {
            return trim($crawler->filter(static::SELECTOR_BUILDING_NAME)->text());
        } catch (Exception) {
            return null;
        }
    }

    protected function parseTitle(Crawler $crawler): ?string
    {
        if (null === static::SELECTOR_TITLE) {

            return null;
        }

        try {
            return trim($crawler->filter(static::SELECTOR_TITLE)->text());
        } catch (Exception) {
            return null;
        }
    }

    protected function parseDescription(Crawler $crawler): ?string
    {
        if (null === static::SELECTOR_DESCRIPTION) {

            return null;
        }

        try {
            return trim($crawler->filter(static::SELECTOR_DESCRIPTION)->text());
        } catch (Exception) {
            return null;
        }
    }

    /**
     * @throws ParseException
     */
    protected function parsePhoto(Crawler $crawler): ?string
    {
        try {
            return $crawler->filter(static::SELECTOR_PHOTO)->attr('src');
        } catch (Exception $e) {
            throw new ParseException('Error while parsing the photo: ' . $e->getMessage());
        }
    }

    /**
     * @throws ParseException
     */
    protected function parseUrl(Crawler $crawler): string
    {
        try {
            return $crawler->filter(static::SELECTOR_URL)->attr('href');

        } catch (Exception $e) {
            throw new ParseException('Error while parsing the URL: ' . $e->getMessage());
        }
    }

    /**
     * @throws ParseException
     */
    private function parseOne(Crawler $crawler, DateTime $publishedAt): Property
    {
        $propertyAd = (new PropertyAd)
            ->setProvider(static::PROVIDER)
            ->setProvider(/** @scrutinizer ignore-type */ static::PROVIDER)
            ->setTitle($this->parseTitle($crawler))
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            ->setDescription($this->parseDescription($crawler))
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            ->setPhoto($this->parsePhoto($crawler))
            ->setPhoto(/** @scrutinizer ignore-type */ $this->parsePhoto($crawler))
            ->setUrl($this->parseUrl($crawler))
            ->setPublishedAt($publishedAt);

        $property = (new Property)
            ->setPrice($this->parsePrice($crawler))
            ->setArea($this->parseArea($crawler))
            ->setRoomsCount($this->parseRoomsCount($crawler))
            ->setLocation($this->parseLocation($crawler))
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            ->setBuildingName($this->parseBuildingName($crawler))
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            ->setAd($propertyAd);

        if ((null !== $provider = $this->providerProvider->find(static::PROVIDER)) && $provider->isNewBuildOnly()) {
        if ((null !== $provider = $this->providerProvider->find(/** @scrutinizer ignore-type */ static::PROVIDER)) && $provider->isNewBuildOnly()) {
            $property->setNewBuild(true);
        } else {
            $property->setNewBuild(u($propertyAd->getTitle() . $propertyAd->getDescription())->containsAny(self::NEW_BUILD_KEYWORDS));
        }

        return $property;
    }
}

Bouss / boussimmo

AbstractParser::__construct() A last analyzed 2021-08-02 18:31 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AbstractParser::__construct() A
last analyzed 2021-08-02 18:31 UTC
