TreeHouse\IoBundle\Source\Manager\CachedSourceManager

Complexity

Total Complexity

33

Size/Duplication

Total Lines	259
Duplicated Lines	100 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

60.98%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	4	4	1
A	getRepository()	4	4	1
A	persist()	4	4	1
A	remove()	4	4	1
A	detach()	4	4	1
A	flush()	4	4	1
A	clear()	6	6	1
A	findCachedById()	8	8	2
A	findCachedByFeed()	6	6	1
A	findCachedByScraper()	6	6	1
A	getFeedHash()	4	4	1
A	getScraperHash()	4	4	1
A	findById()	9	9	2
A	findSourceByFeed()	9	9	2
A	findSourceByScraper()	9	9	2
A	findSourceByFeedOrCreate()	9	9	2
A	findSourceByScraperOrCreate()	9	9	2
B	cache()	28	28	7
A	findCachedByOrigin()	14	14	3

<?php

namespace TreeHouse\IoBundle\Source\Manager;

use TreeHouse\IoBundle\Entity\Feed;
use TreeHouse\IoBundle\Entity\Scraper;
use TreeHouse\IoBundle\Model\SourceInterface;
use TreeHouse\IoBundle\Source\SourceManagerInterface;

/**
 * Wrapper around the main source manger implementation. This sourcemanager is used
 * during imports/scrapes and has one main purpose besides the regular implementation:
 * to cache sources and touch the visited timestamp of a source when it's searched.
 *
 * This is necessary because during imports/scrapes we want to keep track of sources
 * that we encounter, but not necessarily handle or modify.
 */
class CachedSourceManager implements SourceManagerInterface

This class seems to be duplicated in your project.

{
    /**
     * @var SourceManagerInterface
     */
    protected $sourceManager;

    /**
     * @var array
     */
    protected $sources = [];

    /**
     * @var array
     */
    protected $originSources = [];

    /**
     * @param SourceManagerInterface $sourceManager
     */
    public function __construct(SourceManagerInterface $sourceManager)
    {
        $this->sourceManager = $sourceManager;
    }

    /**
     * @inheritdoc
     */
    public function getRepository()
    {
        return $this->sourceManager->getRepository();
    }

    /**
     * @inheritdoc
     */
    public function findById($sourceId)
    {
        if (null === $source = $this->findCachedById($sourceId)) {
            $source = $this->sourceManager->findById($sourceId);
            $this->cache($source);
        }

        return $source;
    }

    /**
     * @inheritdoc
     */
    public function findSourceByFeed(Feed $feed, $originalId)
    {
        if (null === $source = $this->findCachedByFeed($feed, $originalId)) {
            $source = $this->sourceManager->findSourceByFeed($feed, $originalId);
            $this->cache($source);
        }

        return $source;
    }

    /**
     * @inheritdoc
     */
    public function findSourceByScraper(Scraper $scraper, $originalId)
    {
        if (null === $source = $this->findCachedByScraper($scraper, $originalId)) {
            $source = $this->sourceManager->findSourceByScraper($scraper, $originalId);
            $this->cache($source);
        }

        return $source;
    }

    /**
     * @inheritdoc
     */
    public function findSourceByFeedOrCreate(Feed $feed, $originalId, $originalUrl = null)
    {
        if (null === $source = $this->findCachedByFeed($feed, $originalId)) {
            $source = $this->sourceManager->findSourceByFeedOrCreate($feed, $originalId, $originalUrl);
            $this->cache($source);
        }

        return $source;
    }

    /**
     * @inheritdoc
     */
    public function findSourceByScraperOrCreate(Scraper $scraper, $originalId, $originalUrl)
    {
        if (null === $source = $this->findCachedByScraper($scraper, $originalId)) {
            $source = $this->sourceManager->findSourceByScraperOrCreate($scraper, $originalId, $originalUrl);
            $this->cache($source);
        }

        return $source;
    }

    /**
     * @inheritdoc
     */
    public function persist(SourceInterface $source)
    {
        $this->sourceManager->persist($source);
    }

    /**
     * @inheritdoc
     */
    public function remove(SourceInterface $source)
    {
        $this->sourceManager->remove($source);
    }

    /**
     * @inheritdoc
     */
    public function detach(SourceInterface $source)
    {
        $this->sourceManager->detach($source);
    }

    /**
     * @inheritdoc
     */
    public function flush(SourceInterface $source = null)
    {
        $this->sourceManager->flush($source);
    }

    /**
     * @inheritdoc
     */
    public function clear()
    {
        $this->sourceManager->clear();
        $this->sources = [];
        $this->originSources = [];
    }

    /**
     * Adds source to the internal cache.
     *
     * @param SourceInterface $source
     */
    protected function cache(SourceInterface $source = null)
    {
        if (null === $source) {
            return;
        }

        // mark as visited
        $source->setDatetimeLastVisited(new \DateTime());

        // cache by id
        if ($source->getId()) {
            $this->sources[$source->getId()] = $source;
        }

        $hash = null;
        if (null !== $feed = $source->getFeed()) {
            $hash = $this->getFeedHash($feed);
        } elseif (null !== $scraper = $source->getScraper()) {
            $hash = $this->getScraperHash($scraper);
        }

        // must have hash and original id
        if (!$hash || !$source->getOriginalId()) {

The expression $hash of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

            return;
        }

        $this->originSources[$hash][$source->getOriginalId()] = $source;
    }

    /**
     * @param int $sourceId
     *
     * @return SourceInterface|null
     */
    protected function findCachedById($sourceId)
    {
        if (!array_key_exists($sourceId, $this->sources)) {
            return null;
        }

        return $this->sources[$sourceId];
    }

    /**
     * @param string $hash
     * @param string $originalId
     *
     * @return SourceInterface|null
     */
    protected function findCachedByOrigin($hash, $originalId)
    {
        // create origin cache if necessary
        if (!isset($this->originSources[$hash])) {
            $this->originSources[$hash] = [];
        }

        // see if we have a cached mapping, return the cached entry
        if (!array_key_exists($originalId, $this->originSources[$hash])) {
            return null;
        }

        return $this->originSources[$hash][$originalId];
    }

    /**
     * @param Feed   $feed
     * @param string $originalId
     *
     * @return SourceInterface|null
     */
    protected function findCachedByFeed(Feed $feed, $originalId)
    {
        $hash = $this->getFeedHash($feed);

        return $this->findCachedByOrigin($hash, $originalId);
    }

    /**
     * @param Scraper $scraper
     * @param string  $originalId
     *
     * @return SourceInterface|null
     */
    protected function findCachedByScraper(Scraper $scraper, $originalId)
    {
        $hash = $this->getScraperHash($scraper);

        return $this->findCachedByOrigin($hash, $originalId);
    }

    /**
     * Returns a unique hash for a feed.
     *
     * @param Feed $feed
     *
     * @return string
     */
    protected function getFeedHash(Feed $feed)
    {
        return md5('feed' . $feed->getId());
    }

    /**
     * Returns a unique hash for a scraper.
     *
     * @param Scraper $scraper
     *
     * @return string
     */
    protected function getScraperHash(Scraper $scraper)
    {
        return md5('scraper' . $scraper->getId());
    }
}