ContentMatcher::matchContent() - Code Metrics - Inspection of "WIP - Use eZ repository services directly as Searc..." - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#135)

by Alex

created 2017-10-18 02:21 UTC

ContentMatcher::matchContent() D

↳ Parent: ContentMatcher

Complexity

Conditions	22
Paths	124

Size

Total Lines	80
Code Lines	48

Duplication

Lines	30
Ratio	37.5 %

Code Coverage

Tests	27
CRAP Score	38.6148

Importance

Changes

Metric	Value
dl	30
loc	80
ccs	27
cts	40
cp	0.675
rs	4.6803
c	0
b	0
f	0
cc	22
eloc	48
nc	124
nop	1
crap	38.6148

How to fix Long Method Complexity

<?php

namespace Kaliop\eZMigrationBundle\Core\Matcher;

use eZ\Publish\API\Repository\Values\Content\Content;
use eZ\Publish\API\Repository\Values\Content\Query;
use Kaliop\eZMigrationBundle\API\Collection\ContentCollection;

class ContentMatcher extends QueryBasedMatcher
{
    use FlexibleKeyMatcherTrait;

    const MATCH_RELATES_TO = 'relates_to';
    const MATCH_RELATED_FROM = 'related_from';

    protected $allowedConditions = array(
        self::MATCH_AND, self::MATCH_OR, self::MATCH_NOT,
        self::MATCH_CONTENT_ID, self::MATCH_LOCATION_ID, self::MATCH_CONTENT_REMOTE_ID, self::MATCH_LOCATION_REMOTE_ID,
        self::MATCH_ATTRIBUTE, self::MATCH_CONTENT_TYPE_ID, self::MATCH_CONTENT_TYPE_IDENTIFIER, self::MATCH_GROUP,
        self::MATCH_CREATION_DATE, self::MATCH_MODIFICATION_DATE, self::MATCH_OBJECT_STATE, self::MATCH_OWNER,
        self::MATCH_PARENT_LOCATION_ID, self::MATCH_PARENT_LOCATION_REMOTE_ID, self::MATCH_SECTION, self::MATCH_SUBTREE,
        self::MATCH_VISIBILITY,
        // aliases
        'content_type', 'content_type_id', 'content_type_identifier',
        // content-only
        self::MATCH_RELATES_TO, self::MATCH_RELATED_FROM
    );
    protected $returns = 'Content';

    /**
     * @param array $conditions key: condition, value: int / string / int[] / string[]
     * @return ContentCollection
     */
    public function match(array $conditions)
    {
        return $this->matchContent($conditions);
    }

    /**
     * @param array $conditions key: condition, value: int / string / int[] / string[]
     * @return ContentCollection
     */
    public function matchContent(array $conditions)
    {
        $this->validateConditions($conditions);

        if (count($conditions) === 1) {

            $condition = reset($conditions);
            if (is_int($condition) || ctype_digit($condition)) {
                return $this->repository->getContentService()->loadContent($condition);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            } elseif (is_string($condition)) {
                return $this->repository->getContentService()->loadContentByRemoteId($condition);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            }
        }

        foreach ($conditions as $key => $values) {

            switch($key) {

                case self::MATCH_RELATES_TO:

                    $contentService = $this->repository->getContentService();
                    $contents = array();
                    // allow to specify the objects to relate to using different ways
                    $relatedContents = $this->match($values);
                    foreach($relatedContents as $relatedContent) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                        foreach($contentService->loadReverseRelations($relatedContent->contentInfo) as $relatingContent) {
                            $contents[$relatingContent->contentInfo->id] = $relatingContent;

                        }
                    }
                    break;

                case self::MATCH_RELATED_FROM:

                    $contentService = $this->repository->getContentService();
                    $contents = array();
                    // allow to specify the objects we relate to using different ways
                    $relatingContents = $this->match($values);
                    foreach($relatingContents as $relatingContent) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                        foreach($contentService->loadRelations($relatingContent->contentInfo) as $relatedContent) {
                            $contents[$relatedContent->contentInfo->id] = $relatedContent;

                        }
                    }
                    break;

                default:
switch ($expr) {
    default:
        doSomething(); //right
        break;
}


switch ($expr) {
    default:

        doSomething(); //wrong
        break;
}

                    // BC support
                    if ($key == 'content_type') {
                        if (is_int($values[0]) || ctype_digit($values[0])) {
                            $key = self::MATCH_CONTENT_TYPE_ID;
                        } else {
                            $key = self::MATCH_CONTENT_TYPE_IDENTIFIER;
                        }
                    }

                    $query = new Query();
                    $query->limit = self::INT_MAX_16BIT;
                    if (isset($query->performCount)) $query->performCount = false;
                    $query->filter = $this->getQueryCriterion($key, $values);
                    switch ($key) {
                        case 'content_type_id':
                        case self::MATCH_CONTENT_TYPE_ID:
                        case 'content_type_identifier':
                        case self::MATCH_CONTENT_TYPE_IDENTIFIER:
                            // sort objects by depth, lower to higher, so that deleting them has less chances of failure
                            // NB: we only do this in eZP versions that allow depth sorting on content queries
                            if (class_exists('eZ\Publish\API\Repository\Values\Content\Query\SortClause\LocationDepth')) {
                                $query->sortClauses = array(new Query\SortClause\LocationDepth(Query::SORT_DESC));

                            }
                    }
                    $results = $this->repository->getSearchService()->findContent($query);

                    $contents = [];
                    foreach ($results->searchHits as $result) {
                        // make sure we return every object only once
                        $contents[$result->valueObject->contentInfo->id] = $result->valueObject;
                    }
            }

            return new ContentCollection($contents);

        }
    }

    /**
     * When matching by key, we accept content Id and remote Id only
     * @param int|string $key
     * @return array
     */
    protected function getConditionsFromKey($key)
    {
        if (is_int($key) || ctype_digit($key)) {
            return array(self::MATCH_CONTENT_ID => $key);
        }
        return array(self::MATCH_CONTENT_REMOTE_ID => $key);
    }

    /**
     * @param int[] $contentIds
     * @return Content[]
     * @deprecated
     */
    protected function findContentsByContentIds(array $contentIds)

    {
        $contents = [];

        foreach ($contentIds as $contentId) {
            // return unique contents
            $content = $this->repository->getContentService()->loadContent($contentId);
            $contents[$content->contentInfo->id] = $content;
        }

        return $contents;
    }

    /**
     * @param string[] $remoteContentIds
     * @return Content[]
     * @deprecated
     */
    protected function findContentsByContentRemoteIds(array $remoteContentIds)

    {
        $contents = [];

        foreach ($remoteContentIds as $remoteContentId) {
            // return unique contents
            $content = $this->repository->getContentService()->loadContentByRemoteId($remoteContentId);
            $contents[$content->contentInfo->id] = $content;
        }

        return $contents;
    }

    /**
     * @param int[] $locationIds
     * @return Content[]
     * @deprecated
     */
    protected function findContentsByLocationIds(array $locationIds)

    {
        $contentIds = [];

        foreach ($locationIds as $locationId) {
            $location = $this->repository->getLocationService()->loadLocation($locationId);
            // return unique ids
            $contentIds[$location->contentId] = $location->contentId;
        }

        return $this->findContentsByContentIds($contentIds);

    }

    /**
     * @param string[] $remoteLocationIds
     * @return Content[]
     * @deprecated
     */
    protected function findContentsByLocationRemoteIds($remoteLocationIds)

    {
        $contentIds = [];

        foreach ($remoteLocationIds as $remoteLocationId) {
            $location = $this->repository->getLocationService()->loadLocationByRemoteId($remoteLocationId);
            // return unique ids
            $contentIds[$location->contentId] = $location->contentId;
        }

        return $this->findContentsByContentIds($contentIds);

    }

    /**
     * @param int[] $parentLocationIds
     * @return Content[]
     * @deprecated
     */
    protected function findContentsByParentLocationIds($parentLocationIds)

    {
        $query = new Query();
        $query->limit = self::INT_MAX_16BIT;
        if (isset($query->performCount)) $query->performCount = false;
        $query->filter = new Query\Criterion\ParentLocationId($parentLocationIds);
        $results = $this->repository->getSearchService()->findContent($query);

        $contents = [];
        foreach ($results->searchHits as $result) {
            // make sure we return every object only once
            $contents[$result->valueObject->contentInfo->id] = $result->valueObject;
        }

        return $contents;
    }

    /**
     * @param string[] $remoteParentLocationIds
     * @return Content[]
     * @deprecated
     */
    protected function findContentsByParentLocationRemoteIds($remoteParentLocationIds)

    {
        $locationIds = [];

        foreach ($remoteParentLocationIds as $remoteParentLocationId) {
            $location = $this->repository->getLocationService()->loadLocationByRemoteId($remoteParentLocationId);
            // unique locations
            $locationIds[$location->id] = $location->id;
        }

        return $this->findContentsByParentLocationIds($locationIds);

    }

    /**
     * @param string[] $contentTypeIdentifiers
     * @return Content[]
     * @deprecated
     */
    protected function findContentsByContentTypeIdentifiers(array $contentTypeIdentifiers)

    {
        $query = new Query();
        $query->limit = self::INT_MAX_16BIT;
        if (isset($query->performCount)) $query->performCount = false;
        $query->filter = new Query\Criterion\ContentTypeIdentifier($contentTypeIdentifiers);
        // sort objects by depth, lower to higher, so that deleting them has less chances of failure
        // NB: we only do this in eZP versions that allow depth sorting on content queries
        if (class_exists('eZ\Publish\API\Repository\Values\Content\Query\SortClause\LocationDepth')) {
            $query->sortClauses = array(new Query\SortClause\LocationDepth(Query::SORT_DESC));

        }

        $results = $this->repository->getSearchService()->findContent($query);

        $contents = [];
        foreach ($results->searchHits as $result) {
            // make sure we return every object only once
            $contents[$result->valueObject->contentInfo->id] = $result->valueObject;
        }

        return $contents;
    }

    /**
     * @param int[] $contentTypeIds
     * @return Content[]
     * @deprecated
     */
    protected function findContentsByContentTypeIds(array $contentTypeIds)

    {
        $query = new Query();
        $query->limit = self::INT_MAX_16BIT;
        if (isset($query->performCount)) $query->performCount = false;
        $query->filter = new Query\Criterion\ContentTypeId($contentTypeIds);
        // sort objects by depth, lower to higher, so that deleting them has less chances of failure
        // NB: we only do this in eZP versions that allow depth sorting on content queries
        if (class_exists('eZ\Publish\API\Repository\Values\Content\Query\SortClause\LocationDepth')) {
            $query->sortClauses = array(new Query\SortClause\LocationDepth(Query::SORT_DESC));

        }
        $results = $this->repository->getSearchService()->findContent($query);

        $contents = [];
        foreach ($results->searchHits as $result) {
            // make sure we return every object only once
            $contents[$result->valueObject->contentInfo->id] = $result->valueObject;
        }

        return $contents;
    }

}


1		<?php
2
3		namespace Kaliop\eZMigrationBundle\Core\Matcher;
4
5		use eZ\Publish\API\Repository\Values\Content\Content;
6		use eZ\Publish\API\Repository\Values\Content\Query;
7		use Kaliop\eZMigrationBundle\API\Collection\ContentCollection;
8
9		class ContentMatcher extends QueryBasedMatcher
10		{
11		use FlexibleKeyMatcherTrait;
12
13		const MATCH_RELATES_TO = 'relates_to';
14		const MATCH_RELATED_FROM = 'related_from';
15
16		protected $allowedConditions = array(
17		self::MATCH_AND, self::MATCH_OR, self::MATCH_NOT,
18		self::MATCH_CONTENT_ID, self::MATCH_LOCATION_ID, self::MATCH_CONTENT_REMOTE_ID, self::MATCH_LOCATION_REMOTE_ID,
19		self::MATCH_ATTRIBUTE, self::MATCH_CONTENT_TYPE_ID, self::MATCH_CONTENT_TYPE_IDENTIFIER, self::MATCH_GROUP,
20		self::MATCH_CREATION_DATE, self::MATCH_MODIFICATION_DATE, self::MATCH_OBJECT_STATE, self::MATCH_OWNER,
21		self::MATCH_PARENT_LOCATION_ID, self::MATCH_PARENT_LOCATION_REMOTE_ID, self::MATCH_SECTION, self::MATCH_SUBTREE,
22		self::MATCH_VISIBILITY,
23		// aliases
24		'content_type', 'content_type_id', 'content_type_identifier',
25		// content-only
26		self::MATCH_RELATES_TO, self::MATCH_RELATED_FROM
27		);
28		protected $returns = 'Content';
29
30		/**
31		* @param array $conditions key: condition, value: int / string / int[] / string[]
32		* @return ContentCollection
33	3	*/
34		public function match(array $conditions)
35	3	{
36		return $this->matchContent($conditions);
37		}
38
39		/**
40		* @param array $conditions key: condition, value: int / string / int[] / string[]

kaliop-uk / ezmigrationbundle

Pull Request — master (#135)

ContentMatcher::matchContent() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like