NilPortugues\Laravel5\JSendSerializer\JSendSerializer

Complexity

Total Complexity

18

Size/Duplication

Total Lines	108
Duplicated Lines	14.81 %

Coupling/Cohesion

Components	0
Dependencies	2

Importance

Changes	6
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
C	serializeObject()	16	37	7
D	getRelationshipMethodsAsPropertyName()	0	45	10

<?php

/**
 * Author: Nil Portugués Calderó <contact@nilportugues.com>
 * Date: 8/16/15
 * Time: 4:43 AM.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace NilPortugues\Laravel5\JSendSerializer;

use ErrorException;
use Illuminate\Database\Eloquent\Model;
use NilPortugues\Api\JSend\JSendTransformer;
use NilPortugues\Serializer\DeepCopySerializer;
use ReflectionClass;
use ReflectionMethod;

/**
 * Class JSendSerializer.
 */
class JSendSerializer extends DeepCopySerializer
{
    /**
     * @param JSendTransformer $jSendTransformer
     */
    public function __construct(JSendTransformer $jSendTransformer)

Overwriting this method does not seem to be necessary. You may want to remove this method.

    {
        parent::__construct($jSendTransformer);
    }

    /**
     * Extract the data from an object.
     *
     * @param mixed $value
     *
     * @return array
     */
    protected function serializeObject($value)
    {
        if ($value instanceof \Illuminate\Database\Eloquent\Collection) {

This code seems to be duplicated across your project.

            $items = [];
            foreach ($value as &$v) {
                $items[] = $this->serializeObject($v);
            }

            return [self::MAP_TYPE => 'array', self::SCALAR_VALUE => $items];
        }

        if ($value instanceof \Illuminate\Contracts\Pagination\Paginator) {

This code seems to be duplicated across your project.

            $items = [];
            foreach ($value->items() as &$v) {

The expression $value->items() cannot be used as a reference.

                $items[] = $this->serializeObject($v);
            }

            return [self::MAP_TYPE => 'array', self::SCALAR_VALUE => $items];
        }
        
        if (is_subclass_of($value, Model::class, true)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Illuminate\Database\Eloquent\Model::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

            $stdClass = (object) $value->getAttributes();
            $data =  $this->serializeData($stdClass);
            $data[self::CLASS_IDENTIFIER_KEY] = get_class($value);

            $methods = $this->getRelationshipMethodsAsPropertyName($value, get_class($value), new ReflectionClass($value));

            if (!empty($methods)) {
                $data = array_merge($data, $methods);
            }

            return $data;
        }

        return parent::serializeObject($value);
    }

    /**
     * @param                 $value
     * @param string          $className
     * @param ReflectionClass $reflection
     *
     * @return array
     */
    protected function getRelationshipMethodsAsPropertyName($value, $className, ReflectionClass $reflection)
    {

        $methods = [];
        foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
            if (ltrim($method->class, "\\") === ltrim($className, "\\")) {

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

                // Eloquent relations do not include parameters, so we'll be filtering based on this criteria.
                if (0 == $reflectionMethod->getNumberOfParameters()) {
                    try {
                        $returned = $reflectionMethod->invoke($value);
                        //All operations (eg: boolean operations) are now filtered out.
                        if (is_object($returned)) {

                            // Only keep those methods as properties if these are returning Eloquent relations.
                            // But do not run the operation as it is an expensive operation.
                            if (false !== strpos(get_class($returned), 'Illuminate\Database\Eloquent\Relations')) {

                                $items = [];
                                foreach ($returned->getResults() as $model) {

                                    if (is_object($model)) {
                                        $stdClass = (object) $model->getAttributes();
                                        $data =  $this->serializeData($stdClass);
                                        $data[self::CLASS_IDENTIFIER_KEY] = get_class($model);

                                        $items[] = $data;
                                    }
                                }
                                if (!empty($items)) {
                                    $methods[$name] = [self::MAP_TYPE => 'array', self::SCALAR_VALUE => $items];
                                }

                            }
                        }
                    } catch (ErrorException $e) {}

This catchblock is empty and will swallow any caught exception.

                }
            }
        }

        return $methods;
    }
}