FindEditableObjects::checkForValidMethods() - Code Metrics - Inspection of "PATCH: fixing template link issues" - sunnysideup/silverstripe-site-wide-search - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ab49c9...f82b12 )

by Nicolaas

created 2023-12-07 21:18 UTC

FindEditableObjects::checkForValidMethods() F

↳ Parent: FindEditableObjects

Complexity

Conditions	25
Paths	134

Size

Total Lines	79
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	25
eloc	42
c	1
b	0
f	0
nc	134
nop	3
dl	0
loc	79
rs	3.8833

How to fix Long Method Complexity

<?php

namespace Sunnysideup\SiteWideSearch\Helpers;

use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\UnsavedRelationList;
use Sunnysideup\CmsEditLinkField\Api\CMSEditLinkAPI;

class FindEditableObjects
{
    use Extensible;
    use Configurable;
    use Injectable;

    /**
     * @var string
     */
    private const CACHE_NAME = 'FindEditableObjectsCache';

    protected $additionalCacheName = '';
    protected $relationTypesCovered = [];

    protected $excludedClasses = [];

    /**
     * format is as follows:
     * ```php
     *      [
     *          'valid_methods_edit' => [
     *              ClassNameA => false, // tested and does not have any available methods
     *              ClassNameB => MethodName1, // tested found method MethodName1 that can be used.
     *              ClassNameC => MethodName2, // tested found method MethodName2 that can be used.
     *              ClassNameD => false, // tested and does not have any available methods
     *          ],
     *          'valid_methods_view' => [
     *              ClassNameA => false, // tested and does not have any available methods
     *              ClassNameB => MethodName1, // tested found method MethodName1 that can be used.
     *              ClassNameC => MethodName2, // tested found method MethodName2 that can be used.
     *              ClassNameD => false, // tested and does not have any available methods
     *          ],
     *          'valid_methods_view_links' => [
     *              [ClassNameX_IDY] => 'MyLinkView',
     *              [ClassNameX_IDZ] => 'MyLinkView',
     *          ],
     *          'valid_methods_edit_links' => [
     *              [ClassNameX_IDY] => 'MyLinkEdit',
     *              [ClassNameX_IDZ] => 'MyLinkEdit',
     *          ],
     *          'rels' =>
     *              'ClassNameY' => [
     *                  'MethodA' => RelationClassNameB,
     *                  'MethodC' => RelationClassNameD,
     *              ],
     *          ],
     *          'validMethods' => [
     *              'valid_methods_edit' => [
     *                  'A',
     *                  'B',
     *              ]
     *              'valid_methods_view' => [
     *                  'A',
     *                  'B',
     *              ]
     *          ]
     *     ]
     * ```
     * we use false to be able to use empty to work out if it has been tested before.
     *
     * @var array
     */
    protected $cache = [
        'valid_methods_edit',
        'valid_methods_view',
        'valid_methods_image',
        'valid_methods_view_links',
        'valid_methods_edit_links',
        'valid_methods_image_links',
        'rels',
        'validMethods' => [
            'valid_methods_edit' => [],
            'valid_methods_view' => [],
            'valid_methods_image' => [],
        ],
    ];

    private static $max_relation_depth = 3;

    private static $valid_methods_edit = [
        'CMSEditLink',
        'getCMSEditLink',
    ];

    private static $valid_methods_view = [
        'getLink',
        'Link',
    ];

    private static $valid_methods_image = [
        'StripThumbnail',
        'CMSThumbnail',
        'getCMSThumbnail',
    ];

    public function getFileCache()
    {
        return Injector::inst()->get(Cache::class);
    }

    public function initCache(string $additionalCacheName): self
    {
        $this->additionalCacheName = $additionalCacheName;
        $this->cache = $this->getFileCache()->getCacheValues(self::CACHE_NAME . '_' . $this->additionalCacheName);

        return $this;
    }

    public function saveCache(): self
    {
        $this->getFileCache()->setCacheValues(self::CACHE_NAME . '_' . $this->additionalCacheName, $this->cache);

        return $this;
    }

    public function setExcludedClasses(array $excludedClasses): self
    {
        $this->excludedClasses = $excludedClasses;

        return $this;
    }

    /**
     * returns an link to an object that can be edited in the CMS.
     *
     * @param mixed $dataObject
     */
    public function getCMSEditLink($dataObject): string
    {
        return $this->getLinkInner($dataObject, 'valid_methods_edit');
    }

    /**
     * returns a link to an object that can be viewed.
     *
     * @param mixed $dataObject
     */
    public function getLink($dataObject): string
    {
        return $this->getLinkInner($dataObject, 'valid_methods_view');
    }

    /**
     * returns link to a thumbnail.
     *
     * @param mixed $dataObject
     */
    public function getCMSThumbnail($dataObject): string
    {
        return $this->getLinkInner($dataObject, 'valid_methods_image');
    }

    /**
     * returns an link to an object that can be viewed.
     *
     * @param mixed $dataObject
     */
    protected function getLinkInner($dataObject, string $type): string
    {
        $typeKey = $type . '_links';
        $key = $dataObject->ClassName . $dataObject->ID;
        $result = $this->cache[$typeKey][$key] ?? false;
        if (false === $result) {
            $this->relationTypesCovered = [];
            $result = $this->checkForValidMethods($dataObject, $type);
            $this->cache[$typeKey][$key] = $result;
        }

        return $result;
    }

    protected function checkForValidMethods($dataObject, string $type, ?int $relationDepth = 0): string
    {
        //too many iterations!
        if ($relationDepth > (int) $this->Config()->get('max_relation_depth')) {
            return '';
        }

        $validMethods = $this->getValidMethods($type);

        $this->relationTypesCovered[$dataObject->ClassName] = false;

        // quick return
        if (isset($this->cache[$type][$dataObject->ClassName]) && false !== $this->cache[$type][$dataObject->ClassName]) {
            $validMethod = $this->cache[$type][$dataObject->ClassName];
            if ($dataObject->hasMethod($validMethod)) {
                return (string) $dataObject->{$validMethod}();
            }
            // last resort - is there a variable with this name?
            return (string) $dataObject->{$validMethod};
        }

        if ($this->classCanBeIncluded($dataObject->ClassName)) {
            if (empty($this->cache[$type][$dataObject->ClassName]) || false !== $this->cache[$type][$dataObject->ClassName]) {
                foreach ($validMethods as $validMethod) {
                    $outcome = null;
                    if ($dataObject->hasMethod($validMethod)) {
                        $outcome = $dataObject->{$validMethod}();
                    } elseif (!empty($dataObject->{$validMethod})) {
                        $outcome = $dataObject->{$validMethod};
                    }

                    if ($outcome) {
                        $this->cache[$type][$dataObject->ClassName] = $validMethod;

                        return (string) $outcome;
                    }
                }
            }

            if ('valid_methods_edit' === $type) {
                if (class_exists(CMSEditLinkAPI::class)) {
                    $link = CMSEditLinkAPI::find_edit_link_for_object($dataObject);
                    if ($link) {
                        return (string) $link;
                    }
                }
            }
        }

        // there is no match for this one, but we can search relations ...
        $this->cache[$type][$dataObject->ClassName] = true;
        ++$relationDepth;
        foreach ($this->getRelations($dataObject) as $relationName => $relType) {
            $outcome = null;
            //TODO: no support for link through relations yet!
            if (is_array($relType)) {
                continue;
            }

            if (!isset($this->relationTypesCovered[$relType])) {
                $rels = $dataObject->{$relationName}();
                if ($rels) {
                    if ($rels instanceof DataList) {
                        if(!$rels instanceof UnsavedRelationList) {
                            $rels = $rels->first();
                        }
                    }
                    if ($rels && $rels instanceof DataObject && $rels->exists()) {
                        $outcome = $this->checkForValidMethods($rels, $type, $relationDepth);
                    }
                }
            }

            if ($outcome) {
                return $outcome;
            }
        }

        return '';
    }

    protected function getRelations($dataObject): array
    {
        if (!isset($this->cache['rels'][$dataObject->ClassName])) {
            $this->cache['rels'][$dataObject->ClassName] = array_merge(
                Config::inst()->get($dataObject->ClassName, 'belongs_to'),
                Config::inst()->get($dataObject->ClassName, 'has_one'),
                Config::inst()->get($dataObject->ClassName, 'has_many'),
                Config::inst()->get($dataObject->ClassName, 'belongs_many_many'),
                Config::inst()->get($dataObject->ClassName, 'many_many')
            );
            foreach ($this->cache['rels'][$dataObject->ClassName] as $key => $value) {
                if (!(is_string($value) && class_exists($value) && $this->classCanBeIncluded($value))) {
                    unset($this->cache['rels'][$dataObject->ClassName][$key]);
                }
            }
        }

        return $this->cache['rels'][$dataObject->ClassName];
    }

    protected function getValidMethods(string $type): array
    {
        if (!isset($this->cache['validMethods'][$type])) {
            $this->cache['validMethods'][$type] = $this->Config()->get($type);
        }

        return $this->cache['validMethods'][$type];
    }

    /**
     * it either is NOT in the excluded list or it is in the included list.
     *
     * @param string $dataObjectClassName
     * @return boolean
     */
    protected function classCanBeIncluded(string $dataObjectClassName): bool
    {
        if(count($this->excludedClasses)) {
            if(!class_exists($dataObjectClassName)) {
                return false;
            }
            return !in_array($dataObjectClassName, $this->excludedClasses, true);
        }
        user_error('Please set excludedClasses', E_USER_NOTICE);
        return false;
    }
}


1			<?php
2
3			namespace Sunnysideup\SiteWideSearch\Helpers;
4
5			use SilverStripe\Core\Config\Config;
6			use SilverStripe\Core\Config\Configurable;
7			use SilverStripe\Core\Extensible;
8			use SilverStripe\Core\Injector\Injectable;
9			use SilverStripe\Core\Injector\Injector;
10			use SilverStripe\ORM\DataList;
11			use SilverStripe\ORM\DataObject;
12			use SilverStripe\ORM\UnsavedRelationList;
13			use Sunnysideup\CmsEditLinkField\Api\CMSEditLinkAPI;
14
15			class FindEditableObjects
16			{
17			use Extensible;
18			use Configurable;
19			use Injectable;
20
21			/**
22			* @var string
23			*/
24			private const CACHE_NAME = 'FindEditableObjectsCache';
25
26			protected $additionalCacheName = '';
27			protected $relationTypesCovered = [];
28
29			protected $excludedClasses = [];
30
31			/**
32			* format is as follows:
33			* ```php
34			* [
35			* 'valid_methods_edit' => [
36			* ClassNameA => false, // tested and does not have any available methods
37			* ClassNameB => MethodName1, // tested found method MethodName1 that can be used.
38			* ClassNameC => MethodName2, // tested found method MethodName2 that can be used.
39			* ClassNameD => false, // tested and does not have any available methods
40			* ],
41			* 'valid_methods_view' => [
42			* ClassNameA => false, // tested and does not have any available methods
43			* ClassNameB => MethodName1, // tested found method MethodName1 that can be used.
44			* ClassNameC => MethodName2, // tested found method MethodName2 that can be used.
45			* ClassNameD => false, // tested and does not have any available methods
46			* ],
47			* 'valid_methods_view_links' => [
48			* [ClassNameX_IDY] => 'MyLinkView',
49			* [ClassNameX_IDZ] => 'MyLinkView',
50			* ],
51			* 'valid_methods_edit_links' => [
52			* [ClassNameX_IDY] => 'MyLinkEdit',
53			* [ClassNameX_IDZ] => 'MyLinkEdit',
54			* ],
55			* 'rels' =>
56			* 'ClassNameY' => [
57			* 'MethodA' => RelationClassNameB,
58			* 'MethodC' => RelationClassNameD,
59			* ],
60			* ],
61			* 'validMethods' => [
62			* 'valid_methods_edit' => [
63			* 'A',
64			* 'B',
65			* ]
66			* 'valid_methods_view' => [
67			* 'A',
68			* 'B',
69			* ]
70			* ]
71			* ]
72			* ```
73			* we use false to be able to use empty to work out if it has been tested before.
74			*
75			* @var array
76			*/
77			protected $cache = [
78			'valid_methods_edit',
79			'valid_methods_view',
80			'valid_methods_image',
81			'valid_methods_view_links',
82			'valid_methods_edit_links',
83			'valid_methods_image_links',
84			'rels',
85			'validMethods' => [
86			'valid_methods_edit' => [],
87			'valid_methods_view' => [],
88			'valid_methods_image' => [],
89			],
90			];
91
92			private static $max_relation_depth = 3;
93
94			private static $valid_methods_edit = [
95			'CMSEditLink',
96			'getCMSEditLink',
97			];
98
99			private static $valid_methods_view = [
100			'getLink',
101			'Link',
102			];
103
104			private static $valid_methods_image = [
105			'StripThumbnail',
106			'CMSThumbnail',
107			'getCMSThumbnail',
108			];
109
110			public function getFileCache()
111			{
112			return Injector::inst()->get(Cache::class);
113			}
114
115			public function initCache(string $additionalCacheName): self
116			{
117			$this->additionalCacheName = $additionalCacheName;
118			$this->cache = $this->getFileCache()->getCacheValues(self::CACHE_NAME . '_' . $this->additionalCacheName);
119
120			return $this;
121			}
122
123			public function saveCache(): self
124			{
125			$this->getFileCache()->setCacheValues(self::CACHE_NAME . '_' . $this->additionalCacheName, $this->cache);
126
127			return $this;
128			}
129
130			public function setExcludedClasses(array $excludedClasses): self
131			{
132			$this->excludedClasses = $excludedClasses;
133
134			return $this;
135			}
136
137			/**
138			* returns an link to an object that can be edited in the CMS.
139			*
140			* @param mixed $dataObject
141			*/
142			public function getCMSEditLink($dataObject): string
143			{
144			return $this->getLinkInner($dataObject, 'valid_methods_edit');
145			}
146
147			/**
148			* returns a link to an object that can be viewed.
149			*
150			* @param mixed $dataObject
151			*/
152			public function getLink($dataObject): string
153			{
154			return $this->getLinkInner($dataObject, 'valid_methods_view');
155			}
156
157			/**
158			* returns link to a thumbnail.
159			*
160			* @param mixed $dataObject
161			*/
162			public function getCMSThumbnail($dataObject): string
163			{
164			return $this->getLinkInner($dataObject, 'valid_methods_image');
165			}
166
167			/**
168			* returns an link to an object that can be viewed.
169			*
170			* @param mixed $dataObject
171			*/
172			protected function getLinkInner($dataObject, string $type): string
173			{
174			$typeKey = $type . '_links';
175			$key = $dataObject->ClassName . $dataObject->ID;
176			$result = $this->cache[$typeKey][$key] ?? false;
177			if (false === $result) {
178			$this->relationTypesCovered = [];
179			$result = $this->checkForValidMethods($dataObject, $type);
180			$this->cache[$typeKey][$key] = $result;
181			}
182
183			return $result;
184			}
185
186			protected function checkForValidMethods($dataObject, string $type, ?int $relationDepth = 0): string
187			{
188			//too many iterations!
189			if ($relationDepth > (int) $this->Config()->get('max_relation_depth')) {
190			return '';
191			}
192
193			$validMethods = $this->getValidMethods($type);
194
195			$this->relationTypesCovered[$dataObject->ClassName] = false;
196
197			// quick return
198			if (isset($this->cache[$type][$dataObject->ClassName]) && false !== $this->cache[$type][$dataObject->ClassName]) {
199			$validMethod = $this->cache[$type][$dataObject->ClassName];
200			if ($dataObject->hasMethod($validMethod)) {
201			return (string) $dataObject->{$validMethod}();
202			}
203			// last resort - is there a variable with this name?
204			return (string) $dataObject->{$validMethod};
205			}
206
207			if ($this->classCanBeIncluded($dataObject->ClassName)) {
208			if (empty($this->cache[$type][$dataObject->ClassName]) \|\| false !== $this->cache[$type][$dataObject->ClassName]) {
209			foreach ($validMethods as $validMethod) {
210			$outcome = null;
211			if ($dataObject->hasMethod($validMethod)) {
212			$outcome = $dataObject->{$validMethod}();
213			} elseif (!empty($dataObject->{$validMethod})) {
214			$outcome = $dataObject->{$validMethod};
215			}
216
217			if ($outcome) {
218			$this->cache[$type][$dataObject->ClassName] = $validMethod;
219
220			return (string) $outcome;
221			}
222			}
223			}
224
225			if ('valid_methods_edit' === $type) {
226			if (class_exists(CMSEditLinkAPI::class)) {
227			$link = CMSEditLinkAPI::find_edit_link_for_object($dataObject);
228			if ($link) {
229			return (string) $link;
230			}
231			}
232			}
233			}
234
235			// there is no match for this one, but we can search relations ...
236			$this->cache[$type][$dataObject->ClassName] = true;
237			++$relationDepth;
238			foreach ($this->getRelations($dataObject) as $relationName => $relType) {
239			$outcome = null;
240			//TODO: no support for link through relations yet!
241			if (is_array($relType)) {
242			continue;
243			}
244
245			if (!isset($this->relationTypesCovered[$relType])) {
246			$rels = $dataObject->{$relationName}();
247			if ($rels) {
248			if ($rels instanceof DataList) {
249			if(!$rels instanceof UnsavedRelationList) {
250			$rels = $rels->first();
251			}
252			}
253			if ($rels && $rels instanceof DataObject && $rels->exists()) {
254			$outcome = $this->checkForValidMethods($rels, $type, $relationDepth);
255			}
256			}
257			}
258
259			if ($outcome) {
260			return $outcome;
261			}
262			}
263
264			return '';
265			}
266
267			protected function getRelations($dataObject): array
268			{
269			if (!isset($this->cache['rels'][$dataObject->ClassName])) {
270			$this->cache['rels'][$dataObject->ClassName] = array_merge(
271			Config::inst()->get($dataObject->ClassName, 'belongs_to'),
272			Config::inst()->get($dataObject->ClassName, 'has_one'),
273			Config::inst()->get($dataObject->ClassName, 'has_many'),
274			Config::inst()->get($dataObject->ClassName, 'belongs_many_many'),
275			Config::inst()->get($dataObject->ClassName, 'many_many')
276			);
277			foreach ($this->cache['rels'][$dataObject->ClassName] as $key => $value) {
278			if (!(is_string($value) && class_exists($value) && $this->classCanBeIncluded($value))) {
279			unset($this->cache['rels'][$dataObject->ClassName][$key]);
280			}
281			}
282			}
283
284			return $this->cache['rels'][$dataObject->ClassName];
285			}
286
287			protected function getValidMethods(string $type): array
288			{
289			if (!isset($this->cache['validMethods'][$type])) {
290			$this->cache['validMethods'][$type] = $this->Config()->get($type);
291			}
292
293			return $this->cache['validMethods'][$type];
294			}
295
296			/**
297			* it either is NOT in the excluded list or it is in the included list.
298			*
299			* @param string $dataObjectClassName
300			* @return boolean
301			*/
302			protected function classCanBeIncluded(string $dataObjectClassName): bool
303			{
304			if(count($this->excludedClasses)) {
305			if(!class_exists($dataObjectClassName)) {
306			return false;
307			}
308			return !in_array($dataObjectClassName, $this->excludedClasses, true);
309			}
310			user_error('Please set excludedClasses', E_USER_NOTICE);
311			return false;
312			}
313			}
314

sunnysideup / silverstripe-site-wide-search

Push — master ( ab49c9...f82b12 )

FindEditableObjects::checkForValidMethods() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like