FieldHandlerManager - Code Metrics - Inspection of "fixes for tags and for array refs" - kaliop-uk/ezmigrationbundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 084095...b57657 )

by Gaetano

created 2018-05-14 15:28 UTC

FieldHandlerManager A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

Importance

Changes

Metric	Value
wmc	24
lcom	1
cbo	4
dl	0
loc	168
ccs	0
cts	72
cp	0
rs	10
c	0
b	0
f	0

10 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	addFieldHandler()	12	3
A	managesField()	5	2
A	doPreResolveStringReferences()	14	3
A	hashToFieldValue()	14	3
A	fieldValueToHash()	12	3
A	managesFieldDefinition()	9	2
A	hashToFieldSettings()	8	2
A	fieldSettingsToHash()	8	2
A	getFieldHandler()	9	3

<?php

namespace Kaliop\eZMigrationBundle\Core;

use Kaliop\eZMigrationBundle\API\FieldValueImporterInterface;
use Kaliop\eZMigrationBundle\API\FieldDefinitionConverterInterface;
use Kaliop\eZMigrationBundle\API\FieldValueConverterInterface;
use eZ\Publish\API\Repository\FieldTypeService;

class FieldHandlerManager
{
    /** @var FieldValueImporterInterface[][] */
    protected $fieldTypeMap;
    protected $fieldTypeService;

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

    /**
     * @param FieldValueImporterInterface $fieldHandler
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     * @throws \Exception
     */
    public function addFieldHandler($fieldHandler, $fieldTypeIdentifier, $contentTypeIdentifier = null)
    {
        // This is purely BC; at some point we will typehint to FieldValueImporterInterface
        if (!$fieldHandler instanceof FieldValueImporterInterface) {
            throw new \Exception("Can not register object of class '" . get_class($fieldHandler) . "' as field handler because it does not support the desired interface");
        }

        if ($contentTypeIdentifier == null) {

            $contentTypeIdentifier = '*';
        }
        $this->fieldTypeMap[$contentTypeIdentifier][$fieldTypeIdentifier] = $fieldHandler;
    }

    /**
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     * @return bool
     */
    public function managesField($fieldTypeIdentifier, $contentTypeIdentifier)
    {
        return (isset($this->fieldTypeMap[$contentTypeIdentifier][$fieldTypeIdentifier]) ||
            isset($this->fieldTypeMap['*'][$fieldTypeIdentifier]));
    }

    /**
     * Returns true when a fieldHandler allows string refs to be pre-resolved for the field value it gets as hash.
     * "pre-resolved" means: resolved before the field-handler-specific propcessing kicks in
     *
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     */
    public function doPreResolveStringReferences($fieldTypeIdentifier, $contentTypeIdentifier)
    {
        if (!$this->managesField($fieldTypeIdentifier, $contentTypeIdentifier)) {
            return true;
        }

        $fieldHandler = $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier);
        // BC: not alwys defined
        if (is_callable(array($fieldHandler, 'doPreResolveStringReferences'))) {
            return $fieldHandler->doPreResolveStringReferences();

        }

        return true;
    }

    /**
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     * @param mixed $hashValue
     * @param array $context
     * @return mixed
     */
    public function hashToFieldValue($fieldTypeIdentifier, $contentTypeIdentifier, $hashValue, array $context = array())
    {
        if ($this->managesField($fieldTypeIdentifier, $contentTypeIdentifier)) {
            $fieldHandler = $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier);
            // BC
            if (!$fieldHandler instanceof FieldValueImporterInterface) {
                return $fieldHandler->createValue($hashValue, $context);
            }
            return $fieldHandler->hashToFieldValue($hashValue, $context);
        }

        $fieldType = $this->fieldTypeService->getFieldType($fieldTypeIdentifier);
        return $fieldType->fromHash($hashValue);
    }

    /**
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     * @param \eZ\Publish\SPI\FieldType\Value $value
     * @param array $context
     * @return mixed
     */
    public function fieldValueToHash($fieldTypeIdentifier, $contentTypeIdentifier, $value, array $context = array())
    {
        if ($this->managesField($fieldTypeIdentifier, $contentTypeIdentifier)) {
            $fieldHandler = $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier);
            if ($fieldHandler instanceof FieldValueConverterInterface) {
                return $fieldHandler->fieldValueToHash($value, $context);
            }
        }

        $fieldType = $this->fieldTypeService->getFieldType($fieldTypeIdentifier);
        return $fieldType->toHash($value);
    }

    /**
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     * @return bool
     */
    public function managesFieldDefinition($fieldTypeIdentifier, $contentTypeIdentifier)
    {
        if (!$this->managesField($fieldTypeIdentifier, $contentTypeIdentifier)) {
            return false;
        }

        $fieldHandler = $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier);
        return ($fieldHandler instanceof FieldDefinitionConverterInterface);
    }

    /**
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     * @param mixed $fieldSettingsHash
     * @param array $context
     * @return mixed
     */
    public function hashToFieldSettings($fieldTypeIdentifier, $contentTypeIdentifier, $fieldSettingsHash, array $context = array())
    {
        if ($this->managesFieldDefinition($fieldTypeIdentifier, $contentTypeIdentifier)) {
            return $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier)->hashToFieldSettings($fieldSettingsHash, $context);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }

        return $fieldSettingsHash;
    }

    /**
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     * @param mixed $fieldSettings
     * @param array $context
     * @return mixed
     */
    public function fieldSettingsToHash($fieldTypeIdentifier, $contentTypeIdentifier, $fieldSettings, array $context = array())
    {
        if ($this->managesFieldDefinition($fieldTypeIdentifier, $contentTypeIdentifier)) {
            return $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier)->fieldSettingsToHash($fieldSettings, $context);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }

        return $fieldSettings;
    }

    /**
     * @param string $fieldTypeIdentifier
     * @param string $contentTypeIdentifier
     * @return FieldValueImporterInterface
     * @throws \Exception
     */
    protected function getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier) {
        if (isset($this->fieldTypeMap[$contentTypeIdentifier][$fieldTypeIdentifier])) {
            return $this->fieldTypeMap[$contentTypeIdentifier][$fieldTypeIdentifier];
        } else if (isset($this->fieldTypeMap['*'][$fieldTypeIdentifier])) {
            return $this->fieldTypeMap['*'][$fieldTypeIdentifier];
        }

        throw new \Exception("No complex field handler registered for field '$fieldTypeIdentifier' in content type '$contentTypeIdentifier'");
    }
}


1			<?php
2
3			namespace Kaliop\eZMigrationBundle\Core;
4
5			use Kaliop\eZMigrationBundle\API\FieldValueImporterInterface;
6			use Kaliop\eZMigrationBundle\API\FieldDefinitionConverterInterface;
7			use Kaliop\eZMigrationBundle\API\FieldValueConverterInterface;
8			use eZ\Publish\API\Repository\FieldTypeService;
9
10			class FieldHandlerManager
11			{
12			/** @var FieldValueImporterInterface[][] */
13			protected $fieldTypeMap;
14			protected $fieldTypeService;
15
16			public function __construct(FieldTypeService $fieldTypeService)
17			{
18			$this->fieldTypeService = $fieldTypeService;
19			}
20
21			/**
22			* @param FieldValueImporterInterface $fieldHandler
23			* @param string $fieldTypeIdentifier
24			* @param string $contentTypeIdentifier
25			* @throws \Exception
26			*/
27			public function addFieldHandler($fieldHandler, $fieldTypeIdentifier, $contentTypeIdentifier = null)
28			{
29			// This is purely BC; at some point we will typehint to FieldValueImporterInterface
30			if (!$fieldHandler instanceof FieldValueImporterInterface) {
31			throw new \Exception("Can not register object of class '" . get_class($fieldHandler) . "' as field handler because it does not support the desired interface");
32			}
33
34			if ($contentTypeIdentifier == null) {
			0 ignored issues – show Bug introduced 2016-10-06 08:36 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `$contentTypeIdentifier` of type `string\|null` against `null`; this is ambiguous if the string can be empty. Consider using a strict comparison `===` instead. Loading history...
35			$contentTypeIdentifier = '*';
36			}
37			$this->fieldTypeMap[$contentTypeIdentifier][$fieldTypeIdentifier] = $fieldHandler;
38			}
39
40			/**
41			* @param string $fieldTypeIdentifier
42			* @param string $contentTypeIdentifier
43			* @return bool
44			*/
45			public function managesField($fieldTypeIdentifier, $contentTypeIdentifier)
46			{
47			return (isset($this->fieldTypeMap[$contentTypeIdentifier][$fieldTypeIdentifier]) \|\|
48			isset($this->fieldTypeMap['*'][$fieldTypeIdentifier]));
49			}
50
51			/**
52			* Returns true when a fieldHandler allows string refs to be pre-resolved for the field value it gets as hash.
53			* "pre-resolved" means: resolved before the field-handler-specific propcessing kicks in
54			*
55			* @param string $fieldTypeIdentifier
56			* @param string $contentTypeIdentifier
57			*/
58			public function doPreResolveStringReferences($fieldTypeIdentifier, $contentTypeIdentifier)
59			{
60			if (!$this->managesField($fieldTypeIdentifier, $contentTypeIdentifier)) {
61			return true;
62			}
63
64			$fieldHandler = $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier);
65			// BC: not alwys defined
66			if (is_callable(array($fieldHandler, 'doPreResolveStringReferences'))) {
67			return $fieldHandler->doPreResolveStringReferences();
			0 ignored issues – show Bug introduced 2018-05-14 15:36 UTC by Report Bug Copy Issue Report The method `doPreResolveStringReferences()` does not seem to exist on `object<Kaliop\eZMigratio...ValueImporterInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
68			}
69
70			return true;
71			}
72
73			/**
74			* @param string $fieldTypeIdentifier
75			* @param string $contentTypeIdentifier
76			* @param mixed $hashValue
77			* @param array $context
78			* @return mixed
79			*/
80			public function hashToFieldValue($fieldTypeIdentifier, $contentTypeIdentifier, $hashValue, array $context = array())
81			{
82			if ($this->managesField($fieldTypeIdentifier, $contentTypeIdentifier)) {
83			$fieldHandler = $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier);
84			// BC
85			if (!$fieldHandler instanceof FieldValueImporterInterface) {
86			return $fieldHandler->createValue($hashValue, $context);
87			}
88			return $fieldHandler->hashToFieldValue($hashValue, $context);
89			}
90
91			$fieldType = $this->fieldTypeService->getFieldType($fieldTypeIdentifier);
92			return $fieldType->fromHash($hashValue);
93			}
94
95			/**
96			* @param string $fieldTypeIdentifier
97			* @param string $contentTypeIdentifier
98			* @param \eZ\Publish\SPI\FieldType\Value $value
99			* @param array $context
100			* @return mixed
101			*/
102			public function fieldValueToHash($fieldTypeIdentifier, $contentTypeIdentifier, $value, array $context = array())
103			{
104			if ($this->managesField($fieldTypeIdentifier, $contentTypeIdentifier)) {
105			$fieldHandler = $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier);
106			if ($fieldHandler instanceof FieldValueConverterInterface) {
107			return $fieldHandler->fieldValueToHash($value, $context);
108			}
109			}
110
111			$fieldType = $this->fieldTypeService->getFieldType($fieldTypeIdentifier);
112			return $fieldType->toHash($value);
113			}
114
115			/**
116			* @param string $fieldTypeIdentifier
117			* @param string $contentTypeIdentifier
118			* @return bool
119			*/
120			public function managesFieldDefinition($fieldTypeIdentifier, $contentTypeIdentifier)
121			{
122			if (!$this->managesField($fieldTypeIdentifier, $contentTypeIdentifier)) {
123			return false;
124			}
125
126			$fieldHandler = $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier);
127			return ($fieldHandler instanceof FieldDefinitionConverterInterface);
128			}
129
130			/**
131			* @param string $fieldTypeIdentifier
132			* @param string $contentTypeIdentifier
133			* @param mixed $fieldSettingsHash
134			* @param array $context
135			* @return mixed
136			*/
137			public function hashToFieldSettings($fieldTypeIdentifier, $contentTypeIdentifier, $fieldSettingsHash, array $context = array())
138			{
139			if ($this->managesFieldDefinition($fieldTypeIdentifier, $contentTypeIdentifier)) {
140			return $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier)->hashToFieldSettings($fieldSettingsHash, $context);
			0 ignored issues – show Bug introduced 2017-10-01 12:33 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Kaliop\eZMigrationBundle...dValueImporterInterface` as the method `hashToFieldSettings()` does only exist in the following implementations of said interface: `Kaliop\eZMigrationBundle...ldHandler\EzDateAndTime`, `Kaliop\eZMigrationBundle...FieldHandler\EzRelation`, `Kaliop\eZMigrationBundle...ieldHandler\EzSelection`, `Kaliop\eZMigrationBundle...\FieldHandler\EzXmlText`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
141			}
142
143			return $fieldSettingsHash;
144			}
145
146			/**
147			* @param string $fieldTypeIdentifier
148			* @param string $contentTypeIdentifier
149			* @param mixed $fieldSettings
150			* @param array $context
151			* @return mixed
152			*/
153			public function fieldSettingsToHash($fieldTypeIdentifier, $contentTypeIdentifier, $fieldSettings, array $context = array())
154			{
155			if ($this->managesFieldDefinition($fieldTypeIdentifier, $contentTypeIdentifier)) {
156			return $this->getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier)->fieldSettingsToHash($fieldSettings, $context);
			0 ignored issues – show Bug introduced 2017-10-01 12:33 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Kaliop\eZMigrationBundle...dValueImporterInterface` as the method `fieldSettingsToHash()` does only exist in the following implementations of said interface: `Kaliop\eZMigrationBundle...ldHandler\EzDateAndTime`, `Kaliop\eZMigrationBundle...FieldHandler\EzRelation`, `Kaliop\eZMigrationBundle...ieldHandler\EzSelection`, `Kaliop\eZMigrationBundle...\FieldHandler\EzXmlText`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
157			}
158
159			return $fieldSettings;
160			}
161
162			/**
163			* @param string $fieldTypeIdentifier
164			* @param string $contentTypeIdentifier
165			* @return FieldValueImporterInterface
166			* @throws \Exception
167			*/
168			protected function getFieldHandler($fieldTypeIdentifier, $contentTypeIdentifier) {
169			if (isset($this->fieldTypeMap[$contentTypeIdentifier][$fieldTypeIdentifier])) {
170			return $this->fieldTypeMap[$contentTypeIdentifier][$fieldTypeIdentifier];
171			} else if (isset($this->fieldTypeMap['*'][$fieldTypeIdentifier])) {
172			return $this->fieldTypeMap['*'][$fieldTypeIdentifier];
173			}
174
175			throw new \Exception("No complex field handler registered for field '$fieldTypeIdentifier' in content type '$contentTypeIdentifier'");
176			}
177			}
178

kaliop-uk / ezmigrationbundle

Push — master ( 084095...b57657 )

FieldHandlerManager A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

10 Methods

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like