RelationshipPropertyExtractor::getRelationshipAsPropertyName() - Code Metrics - nilportugues/serializer-eloquent-driver - Measure and Improve Code Quality continuously with Scrutinizer

getRelationshipAsPropertyName() C
last analyzed 2017-03-24 15:17 UTC

↳ Parent: RelationshipPropertyExtractor

Complexity

Conditions	13
Paths	20

Size

Total Lines	57
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	57
rs	6.5962
cc	13
eloc	32
nc	20
nop	4

How to fix Long Method Complexity

<?php

namespace NilPortugues\Serializer\Drivers\Eloquent\Helper;

use ErrorException;
use Illuminate\Database\Eloquent\Model;
use NilPortugues\Serializer\Drivers\Eloquent\Driver;
use NilPortugues\Serializer\Serializer;
use ReflectionClass;
use ReflectionMethod;
use Traversable;

class RelationshipPropertyExtractor
{
    /**
     * @var array
     */
    private static $forbiddenFunction = [
        'forceDelete',
        'forceFill',
        'delete',
        'newQueryWithoutScopes',
        'newQuery',
        'bootIfNotBooted',
        'boot',
        'bootTraits',
        'clearBootedModels',
        'query',
        'onWriteConnection',
        'delete',
        'forceDelete',
        'performDeleteOnModel',
        'flushEventListeners',
        'push',
        'touchOwners',
        'touch',
        'updateTimestamps',
        'freshTimestamp',
        'freshTimestampString',
        'newQuery',
        'newQueryWithoutScopes',
        'newBaseQueryBuilder',
        'usesTimestamps',
        'reguard',
        'isUnguarded',
        'totallyGuarded',
        'syncOriginal',
        'getConnectionResolver',
        'unsetConnectionResolver',
        'getEventDispatcher',
        'unsetEventDispatcher',
        '__toString',
        '__wakeup',
    ];

    /**
     * @param $value
     * @param $className
     * @param ReflectionClass $reflection
     * @param Driver          $serializer
     *
     * @return array
     */
    public static function getRelationshipAsPropertyName(
        $value,
        $className,
        ReflectionClass $reflection,
        Driver $serializer
    ) {
        $methods = [];
        foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
            if (ltrim($method->class, '\\') !== ltrim($className, '\\')) {
                continue;
            }

            $name = $method->name;
            $reflectionMethod = $reflection->getMethod($name);

            if (!self::isAllowedEloquentModelFunction($name) || $reflectionMethod->getNumberOfParameters() > 0) {
                continue;
            }

            if (in_array($name, $value->getHidden(), true)) {
                continue;
            }

            try {
                $returned = $reflectionMethod->invoke($value);

                if (!(\is_object($returned) && self::isAnEloquentRelation($returned))) {
                    continue;
                }

                $relationData = $returned->getResults();

                if ($relationData instanceof Traversable) {
                    //Something traversable with Models
                    $items = [];

                    foreach ($relationData as $model) {
                        if ($model instanceof Model) {
                            $items[] = self::getModelData($serializer, $model);
                        }
                    }

                    $methods[$name] = [
                        Serializer::MAP_TYPE => 'array',
                        Serializer::SCALAR_VALUE => $items,
                    ];
                } elseif ($relationData instanceof Model) {
                    //Single element returned.
                    $methods[$name] = self::getModelData($serializer, $relationData);
                }

            } catch (ErrorException $e) {
            }
        }

        return $methods;
    }

    /**
     * @param $name
     *
     * @return bool
     */
    protected static function isAllowedEloquentModelFunction($name)
    {
        return false === in_array($name, self::$forbiddenFunction, true);
    }

    /**
     * @param $returned
     *
     * @return bool
     */
    protected static function isAnEloquentRelation($returned)
    {
        return false !== strpos(get_class($returned), 'Illuminate\Database\Eloquent\Relations');
    }

    /**
     * @param Driver $serializer
     * @param Model  $model
     *
     * @return array
     */
    protected static function getModelData(Driver $serializer, Model $model)
    {
        $stdClass = (object) $model->attributesToArray();
        $data = $serializer->serialize($stdClass);
        $data[Serializer::CLASS_IDENTIFIER_KEY] = get_class($model);

        return $data;
    }
}


1			<?php
2
3			namespace NilPortugues\Serializer\Drivers\Eloquent\Helper;
4
5			use ErrorException;
6			use Illuminate\Database\Eloquent\Model;
7			use NilPortugues\Serializer\Drivers\Eloquent\Driver;
8			use NilPortugues\Serializer\Serializer;
9			use ReflectionClass;
10			use ReflectionMethod;
11			use Traversable;
12
13			class RelationshipPropertyExtractor
14			{
15			/**
16			* @var array
17			*/
18			private static $forbiddenFunction = [
19			'forceDelete',
20			'forceFill',
21			'delete',
22			'newQueryWithoutScopes',
23			'newQuery',
24			'bootIfNotBooted',
25			'boot',
26			'bootTraits',
27			'clearBootedModels',
28			'query',
29			'onWriteConnection',
30			'delete',
31			'forceDelete',
32			'performDeleteOnModel',
33			'flushEventListeners',
34			'push',
35			'touchOwners',
36			'touch',
37			'updateTimestamps',
38			'freshTimestamp',
39			'freshTimestampString',
40			'newQuery',
41			'newQueryWithoutScopes',
42			'newBaseQueryBuilder',
43			'usesTimestamps',
44			'reguard',
45			'isUnguarded',
46			'totallyGuarded',
47			'syncOriginal',
48			'getConnectionResolver',
49			'unsetConnectionResolver',
50			'getEventDispatcher',
51			'unsetEventDispatcher',
52			'__toString',
53			'__wakeup',
54			];
55
56			/**
57			* @param $value
58			* @param $className
59			* @param ReflectionClass $reflection
60			* @param Driver $serializer
61			*
62			* @return array
63			*/
64			public static function getRelationshipAsPropertyName(
65			$value,
66			$className,
67			ReflectionClass $reflection,
68			Driver $serializer
69			) {
70			$methods = [];
71			foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
72			if (ltrim($method->class, '\\') !== ltrim($className, '\\')) {
73			continue;
74			}
75
76			$name = $method->name;
77			$reflectionMethod = $reflection->getMethod($name);
78
79			if (!self::isAllowedEloquentModelFunction($name) \|\| $reflectionMethod->getNumberOfParameters() > 0) {
80			continue;
81			}
82
83			if (in_array($name, $value->getHidden(), true)) {
84			continue;
85			}
86
87			try {
88			$returned = $reflectionMethod->invoke($value);
89
90			if (!(\is_object($returned) && self::isAnEloquentRelation($returned))) {
91			continue;
92			}
93
94			$relationData = $returned->getResults();
95
96			if ($relationData instanceof Traversable) {
97			//Something traversable with Models
98			$items = [];
99
100			foreach ($relationData as $model) {
101			if ($model instanceof Model) {
102			$items[] = self::getModelData($serializer, $model);
103			}
104			}
105
106			$methods[$name] = [
107			Serializer::MAP_TYPE => 'array',
108			Serializer::SCALAR_VALUE => $items,
109			];
110			} elseif ($relationData instanceof Model) {
111			//Single element returned.
112			$methods[$name] = self::getModelData($serializer, $relationData);
113			}
114
115			} catch (ErrorException $e) {
116			}
117			}
118
119			return $methods;
120			}
121
122			/**
123			* @param $name
124			*
125			* @return bool
126			*/
127			protected static function isAllowedEloquentModelFunction($name)
128			{
129			return false === in_array($name, self::$forbiddenFunction, true);
130			}
131
132			/**
133			* @param $returned
134			*
135			* @return bool
136			*/
137			protected static function isAnEloquentRelation($returned)
138			{
139			return false !== strpos(get_class($returned), 'Illuminate\Database\Eloquent\Relations');
140			}
141
142			/**
143			* @param Driver $serializer
144			* @param Model $model
145			*
146			* @return array
147			*/
148			protected static function getModelData(Driver $serializer, Model $model)
149			{
150			$stdClass = (object) $model->attributesToArray();
151			$data = $serializer->serialize($stdClass);
152			$data[Serializer::CLASS_IDENTIFIER_KEY] = get_class($model);
153
154			return $data;
155			}
156			}
157

nilportugues / serializer-eloquent-driver

getRelationshipAsPropertyName() C last analyzed 2017-03-24 15:17 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

getRelationshipAsPropertyName() C
last analyzed 2017-03-24 15:17 UTC