LocationMatcher - 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

LocationMatcher B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	230
Duplicated Lines	33.04 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

40%

Importance

Changes

Metric	Value
wmc	36
lcom	1
cbo	14
dl	76
loc	230
ccs	26
cts	65
cp	0.4
rs	8.8
c	0
b	0
f	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getConditionsFromKey()	0	7	3
A	match()	0	4	1
C	matchLocation()	8	29	8
D	getQueryCriterion()	14	36	9
A	findLocationsByContentIds()	13	13	3
A	findLocationsByContentRemoteIds()	13	13	3
A	findLocationsByLocationIds()	0	10	2
A	findLocationsByLocationRemoteIds()	0	11	2
A	findLocationsByParentLocationIds()	17	17	3
A	findLocationsByParentLocationRemoteIds()	11	11	2

How to fix Duplicated Code

<?php

namespace Kaliop\eZMigrationBundle\Core\Matcher;

use eZ\Publish\API\Repository\Values\Content\Query;
use Kaliop\eZMigrationBundle\API\Collection\LocationCollection;
use eZ\Publish\API\Repository\Values\Content\LocationQuery;
use eZ\Publish\API\Repository\Values\Content\Location;

class LocationMatcher extends QueryBasedMatcher
{
    use FlexibleKeyMatcherTrait;

    const MATCH_DEPTH = 'depth';
    const MATCH_IS_MAIN_LOCATION = 'is_main_location';
    const MATCH_PRIORITY = 'priority';

    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',
        // location-only
        self::MATCH_DEPTH, self::MATCH_IS_MAIN_LOCATION, self::MATCH_PRIORITY,
    );
    protected $returns = 'Location';

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

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

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

            $condition = reset($conditions);
            if (is_int($condition) || ctype_digit($condition)) {
                return $this->repository->getLocationService()->loadLocation($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->getLocationService()->loadLocationByRemoteId($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) {

            $query = new LocationQuery();
            $query->limit = self::INT_MAX_16BIT;
            if (isset($query->performCount)) $query->performCount = false;
            $query->filter = $this->getQueryCriterion($key, $values);
            $results = $this->repository->getSearchService()->findLocations($query);

            $locations = [];
            foreach ($results->searchHits as $result) {
                $locations[$result->valueObject->id] = $result->valueObject;
            }

            return new LocationCollection($locations);
        }
    }

    /**
     * When matching by key, we accept location 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_LOCATION_ID => $key);
        }
        return array(self::MATCH_LOCATION_REMOTE_ID => $key);
    }

    protected function getQueryCriterion($key, $values)
    {
        if (!is_array($values)) {
            $values = array($values);
        }

        switch ($key) {
            case self::MATCH_DEPTH:

                $match = reset($values);
                $operator = key($values);
                if (!isset(self::$operatorsMap[$operator])) {
                    throw new \Exception("Can not use '$operator' as comparison operator for depth");
                }
                return new Query\Criterion\Location\Depth(self::$operatorsMap[$operator], $match);
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());
}

            case self::MATCH_IS_MAIN_LOCATION:
            case 'is_main':

                /// @todo error/warning if there is more than 1 value...
                $value = reset($values);
                if ($value) {
                    return new Query\Criterion\Location\IsMainLocation(Query\Criterion\Location\IsMainLocation::MAIN);
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());
}
                } else {
                    return new Query\Criterion\Location\IsMainLocation(Query\Criterion\Location\IsMainLocation::NOT_MAIN);
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());
}
                }

            case self::MATCH_PRIORITY:

                $match = reset($values);
                $operator = key($values);
                if (!isset(self::$operatorsMap[$operator])) {
                    throw new \Exception("Can not use '$operator' as comparison operator for depth");
                }
                return new Query\Criterion\Location\Priority(self::$operatorsMap[$operator], $match);
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());
}
        }

        return parent::getQueryCriterion($key, $values);
    }

    /**
     * Returns all locations of a set of objects
     *
     * @param int[] $contentIds
     * @return Location[]
     * @deprecated
     */
    protected function findLocationsByContentIds(array $contentIds)

    {
        $locations = [];

        foreach ($contentIds as $contentId) {
            $content = $this->repository->getContentService()->loadContent($contentId);
            foreach($this->repository->getLocationService()->loadLocations($content->contentInfo) as $location) {
                $locations[$location->id] = $location;
            }
        }

        return $locations;
    }

    /**
     * Returns all locations of a set of objects
     *
     * @param int[] $remoteContentIds
     * @return Location[]
     * @deprecated
     */
    protected function findLocationsByContentRemoteIds(array $remoteContentIds)

    {
        $locations = [];

        foreach ($remoteContentIds as $remoteContentId) {
            $content = $this->repository->getContentService()->loadContentByRemoteId($remoteContentId);
            foreach($this->repository->getLocationService()->loadLocations($content->contentInfo) as $location) {
                $locations[$location->id] = $location;
            }
        }

        return $locations;
    }

    /**
     * @param int[] $locationIds
     * @return Location[]
     * @deprecated
     */
    protected function findLocationsByLocationIds(array $locationIds)
    {
        $locations = [];

        foreach ($locationIds as $locationId) {
            $locations[$locationId] = $this->repository->getLocationService()->loadLocation($locationId);
        }

        return $locations;
    }

    /**
     * @param int[] $locationRemoteIds
     * @return Location[]
     * @deprecated
     */
    protected function findLocationsByLocationRemoteIds($locationRemoteIds)
    {
        $locations = [];

        foreach ($locationRemoteIds as $locationRemoteId) {
            $location = $this->repository->getLocationService()->loadLocationByRemoteId($locationRemoteId);
            $locations[$location->id] = $location;
        }

        return $locations;
    }

    /**
     * @param int[] $parentLocationIds
     * @return Location[]
     * @deprecated
     */
    protected function findLocationsByParentLocationIds($parentLocationIds)

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

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

        $locations = [];

        foreach ($results->searchHits as $result) {
            $locations[$result->valueObject->id] = $result->valueObject;
        }

        return $locations;
    }

    /**
     * @param int[] $parentLocationRemoteIds
     * @return Location[]
     * @deprecated
     */
    protected function findLocationsByParentLocationRemoteIds($parentLocationRemoteIds)

    {
        $locationIds = [];

        foreach ($parentLocationRemoteIds as $parentLocationRemoteId) {
            $location = $this->repository->getLocationService()->loadLocationByRemoteId($parentLocationRemoteId);
            $locationIds[$location->id] = $location->id;
        }

        return $this->findLocationsByParentLocationIds($locationIds);

    }
}


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

kaliop-uk / ezmigrationbundle

Pull Request — master (#135)

LocationMatcher B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

10 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like