Pipeline::serialize() - Code Metrics - Inspection of "Serialization refactor including (BC) breaking cha..." - rexlabsio/smokescreen-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e86b6e...1708fa )

by Jodie

created 2018-07-05 06:03 UTC

Pipeline::serialize() B

↳ Parent: Pipeline

Complexity

Conditions	8
Paths	8

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	8.0155

Importance

Changes

Metric	Value
dl	0
loc	26
ccs	15
cts	16
cp	0.9375
rs	8.4444
c	0
b	0
f	0
cc	8
nc	8
nop	2
crap	8.0155

<?php

namespace Rexlabs\Smokescreen\Transformer;

use Rexlabs\Smokescreen\Exception\IncludeException;
use Rexlabs\Smokescreen\Exception\InvalidTransformerException;
use Rexlabs\Smokescreen\Exception\UnhandledResourceType;
use Rexlabs\Smokescreen\Helpers\ArrayHelper;
use Rexlabs\Smokescreen\Relations\RelationLoaderInterface;
use Rexlabs\Smokescreen\Resource\Collection;
use Rexlabs\Smokescreen\Resource\Item;
use Rexlabs\Smokescreen\Resource\ResourceInterface;
use Rexlabs\Smokescreen\Serializer\SerializerInterface;

class Pipeline
{
    /** @var SerializerInterface */
    protected $serializer;

    /** @var TransformerResolverInterface|null */
    protected $transformerResolver;

    /** @var RelationLoaderInterface|null */
    protected $relationLoader;

    public function __construct()
    {
    }

    public function setTransformerResolver(TransformerResolverInterface $transformerResolver)
    {
        $this->transformerResolver = $transformerResolver;
    }

    public function setSerializer(SerializerInterface $serializer)
    {
        $this->serializer = $serializer;
    }

    public function setRelationLoader(RelationLoaderInterface $relationLoader)
    {
        $this->relationLoader = $relationLoader;
    }

    /**
     * @param Scope $scope
     *
     * @throws IncludeException
     *
     * @return array|null
     */
    public function transform(Scope $scope)
    {
        $resource = $scope->resource();
        
        // When we encounter a null resource, we just return null because
        // there's nothing else we can do with it.
        if ($resource === null) {
            return null;
        }
        
        // If the resource is not a ResourceInterface instance we allow it to be
        // something array-like.
        if (!($resource instanceof ResourceInterface)) {
            if (\is_array($resource)) {
                return $resource;
            }
            if (\is_object($resource) && method_exists($resource, 'toArray')) {
                return $resource->toArray();
            }

            throw new UnhandledResourceType('Unable to serialize resource of type ' . \gettype($resource));
        }

        // Try to resolve a transformer for a resource that does not have one
        // assigned.
        if (!$resource->hasTransformer()) {
            $transformer = $this->resolveTransformerForResource($resource);
            $resource->setTransformer($transformer);
        }

        // Call the relationship loader for any relations
        $this->loadRelations($resource, $scope->resolvedRelationshipKeys());

        // We can only transform the resource data if we have some data to
        // transform ...
        if (($data = $resource->getData()) !== null) {
            // Build the data by recursively transforming each resource.
            if ($resource instanceof Collection) {
                $data = [];
                foreach ($resource as $itemData) {
                    $data[] = $this->transformData($scope, $itemData);
                }
            } elseif ($resource instanceof Item) {
                $data = $this->transformData($scope, $data);
            }
        }

        // Serialize the transformed data
        return $this->serialize($resource, $data);
    }

    /**
     * Serialize the data
     * @param ResourceInterface $resource
     * @param                   $data
     *
     * @return array|mixed
     */
    protected function serialize(ResourceInterface $resource, $data)
    {
        // Get the serializer from the resource, or use the default.
        $serializer = $resource->getSerializer() ?? $this->getSerializer();
        
        if ($serializer instanceof SerializerInterface) {
            if ($resource instanceof Collection) {
                if ($data === null) {
                    return $serializer->nullCollection();
                }
                $data = $serializer->collection($resource->getResourceKey(), $data);
                if ($resource->hasPaginator()) {
                    $data = array_merge($data, $serializer->paginator($resource->getPaginator()));
                }
            } elseif ($resource instanceof Item) {
                if ($data === null) {
                    return $serializer->nullItem();
                }
                $data = $serializer->item($resource->getResourceKey(), $data);
            }
        } elseif (\is_callable($serializer)) {
            // Serialize via a callable/closure
            $data = $serializer($resource->getResourceKey(), $data);
        }
       
        return $data;
    }

    /**
     * Apply transformation to the item data.
     *
     * @param Scope $scope
     * @param mixed $data
     *
     * @throws IncludeException
     *
     * @return array
     */
    protected function transformData(Scope $scope, $data): array
    {
        $transformer = $scope->transformer();

        // Handle when no transformer is present
        if (empty($transformer)) {
            // No transformation
            return (array) $data;
        }

        // Handle when transformer is a callable
        if (\is_callable($transformer)) {
            // Simply run callable on the data and return the result
            return (array) $transformer($data);
        }

        // Ensure we're working with a real transformer from this point forward.
        if (!($transformer instanceof TransformerInterface)) {
            throw new InvalidTransformerException('Expected a valid transformer');
        }

        // Transform the data, and filter any sparse field-set for the scope.
        $transformedData = $scope->filterData($transformer->getTransformedData($data));

        // Add includes to the payload.
        $includeMap = $scope->includeMap();
        foreach ($scope->resolvedIncludeKeys() as $includeKey) {
            $child = $this->executeTransformerInclude($scope, $includeKey, $includeMap[$includeKey], $data);

            // Create a new child scope.
            $childScope = new Scope($child, $scope->includes()->splice($includeKey), $scope);

            // If working with a ResourceInterface, use it's own key (if present).
            $childKey = $child instanceof ResourceInterface && $child->getResourceKey() ?
                $child->getResourceKey() : $includeKey;

            ArrayHelper::mutate(
                $transformedData,
                $childKey,
                $this->transform($childScope)
            );
        }

        return $transformedData;
    }

    /**
     * Execute the transformer.
     *
     * @param Scope  $scope
     * @param string $includeKey
     * @param array  $includeDefinition
     * @param mixed  $data
     *
     * @throws IncludeException
     *
     * @return ResourceInterface
     */
    protected function executeTransformerInclude(Scope $scope, $includeKey, $includeDefinition, $data)
    {
        // Transformer explicitly provided an include method
        $transformer = $scope->transformer();
        $method = $includeDefinition['method'];
        if (method_exists($transformer, $method)) {
            return $transformer->$method($data, $scope);
        }

        // Otherwise try handle the include automatically
        return $this->autoWireInclude($includeKey, $includeDefinition, $data);
    }

    /**
     * Resolve the transformer to be used for a resource.
     * Returns an interface, callable or null when a transformer cannot be resolved.
     *
     * @param $resource
     *
     * @return TransformerInterface|mixed|null
     */
    protected function resolveTransformerForResource($resource)
    {
        $transformer = null;

        if ($this->transformerResolver !== null) {
            $transformer = $this->transformerResolver->resolve($resource);
        }

        return $transformer;
    }

    /**
     * Fire the relation loader (if defined) for this resource.
     *
     * @param ResourceInterface $resource
     * @param array             $relationshipKeys
     */
    protected function loadRelations(ResourceInterface $resource, array $relationshipKeys)
    {
        if ($this->relationLoader !== null && !empty($relationshipKeys)) {
            $this->relationLoader->load($resource, $relationshipKeys);
        }
    }

    /**
     * @param string $includeKey
     * @param array  $includeDefinition
     * @param        $item
     *
     * @throws \Rexlabs\Smokescreen\Exception\InvalidTransformerException
     * @throws \Rexlabs\Smokescreen\Exception\IncludeException
     *
     * @return Collection|Item|ResourceInterface
     */
    protected function autoWireInclude($includeKey, $includeDefinition, $item)
    {
        // Get the included data
        $data = null;
        if (\is_array($item) || $item instanceof \ArrayAccess) {
            $data = $item[$includeKey] ?? null;
        } elseif (\is_object($item)) {
            $data = $item->$includeKey ?? null;
        } else {
            throw new IncludeException("Cannot auto-wire include for $includeKey: Cannot get include data");
        }

        if (!empty($includeDefinition['resource_type']) && $includeDefinition['resource_type'] === 'collection') {
            return new Collection($data);
        }

        // Assume unless declared, that the resource is an item.
        return new Item($data);
    }

    protected function getSerializer()
    {
        return $this->serializer;
    }
}


1		<?php
2
3		namespace Rexlabs\Smokescreen\Transformer;
4
5		use Rexlabs\Smokescreen\Exception\IncludeException;
6		use Rexlabs\Smokescreen\Exception\InvalidTransformerException;
7		use Rexlabs\Smokescreen\Exception\UnhandledResourceType;
8		use Rexlabs\Smokescreen\Helpers\ArrayHelper;
9		use Rexlabs\Smokescreen\Relations\RelationLoaderInterface;
10		use Rexlabs\Smokescreen\Resource\Collection;
11		use Rexlabs\Smokescreen\Resource\Item;
12		use Rexlabs\Smokescreen\Resource\ResourceInterface;
13		use Rexlabs\Smokescreen\Serializer\SerializerInterface;
14
15		class Pipeline
16		{
17		/** @var SerializerInterface */
18		protected $serializer;
19
20		/** @var TransformerResolverInterface\|null */
21		protected $transformerResolver;
22
23		/** @var RelationLoaderInterface\|null */
24		protected $relationLoader;
25
26	16	public function __construct()
27		{
28	16	}
29
30	2	public function setTransformerResolver(TransformerResolverInterface $transformerResolver)
31		{
32	2	$this->transformerResolver = $transformerResolver;
33	2	}
34
35	16	public function setSerializer(SerializerInterface $serializer)
36		{
37	16	$this->serializer = $serializer;
38	16	}
39
40	1	public function setRelationLoader(RelationLoaderInterface $relationLoader)
41		{
42	1	$this->relationLoader = $relationLoader;
43	1	}
44
45		/**
46		* @param Scope $scope
47		*
48		* @throws IncludeException
49		*
50		* @return array\|null
51		*/
52	16	public function transform(Scope $scope)
53		{
54	16	$resource = $scope->resource();
55
56		// When we encounter a null resource, we just return null because
57		// there's nothing else we can do with it.
58	16	if ($resource === null) {
59		return null;
60		}
61
62		// If the resource is not a ResourceInterface instance we allow it to be
63		// something array-like.
64	16	if (!($resource instanceof ResourceInterface)) {
65	3	if (\is_array($resource)) {
66	1	return $resource;
67		}
68	2	if (\is_object($resource) && method_exists($resource, 'toArray')) {
69	1	return $resource->toArray();
70		}
71
72	1	throw new UnhandledResourceType('Unable to serialize resource of type ' . \gettype($resource));
73		}
74
75		// Try to resolve a transformer for a resource that does not have one
76		// assigned.
77	14	if (!$resource->hasTransformer()) {
78	10	$transformer = $this->resolveTransformerForResource($resource);
79	10	$resource->setTransformer($transformer);
80		}
81
82		// Call the relationship loader for any relations
83	14	$this->loadRelations($resource, $scope->resolvedRelationshipKeys());
84
85		// We can only transform the resource data if we have some data to
86		// transform ...
87	14	if (($data = $resource->getData()) !== null) {
88		// Build the data by recursively transforming each resource.
89	14	if ($resource instanceof Collection) {
90	5	$data = [];
91	5	foreach ($resource as $itemData) {
92	5	$data[] = $this->transformData($scope, $itemData);
93		}
94	12	} elseif ($resource instanceof Item) {
95	12	$data = $this->transformData($scope, $data);
96		}
97		}
98
99		// Serialize the transformed data
100	14	return $this->serialize($resource, $data);
101		}
102
103		/**
104		* Serialize the data
105		* @param ResourceInterface $resource
106		* @param $data
107		*
108		* @return array\|mixed
109		*/
110	14	protected function serialize(ResourceInterface $resource, $data)
111		{
112		// Get the serializer from the resource, or use the default.
113	14	$serializer = $resource->getSerializer() ?? $this->getSerializer();
114
115	14	if ($serializer instanceof SerializerInterface) {
116	11	if ($resource instanceof Collection) {
117	3	if ($data === null) {
118		return $serializer->nullCollection();
119		}
120	3	$data = $serializer->collection($resource->getResourceKey(), $data);
121	3	if ($resource->hasPaginator()) {
122	3	$data = array_merge($data, $serializer->paginator($resource->getPaginator()));
123		}
124	11	} elseif ($resource instanceof Item) {
125	11	if ($data === null) {
126	1	return $serializer->nullItem();
127		}
128	11	$data = $serializer->item($resource->getResourceKey(), $data);
129		}
130	3	} elseif (\is_callable($serializer)) {
131		// Serialize via a callable/closure
132	2	$data = $serializer($resource->getResourceKey(), $data);
133		}
134
135	14	return $data;
136		}
137
138		/**
139		* Apply transformation to the item data.
140		*
141		* @param Scope $scope
142		* @param mixed $data
143		*
144		* @throws IncludeException
145		*
146		* @return array
147		*/
148	14	protected function transformData(Scope $scope, $data): array
149		{
150	14	$transformer = $scope->transformer();
151
152		// Handle when no transformer is present
153	14	if (empty($transformer)) {
154		// No transformation
155	7	return (array) $data;
156		}
157
158		// Handle when transformer is a callable
159	8	if (\is_callable($transformer)) {
160		// Simply run callable on the data and return the result
161	3	return (array) $transformer($data);
162		}
163
164		// Ensure we're working with a real transformer from this point forward.
165	7	if (!($transformer instanceof TransformerInterface)) {
166		throw new InvalidTransformerException('Expected a valid transformer');
167		}
168
169		// Transform the data, and filter any sparse field-set for the scope.
170	7	$transformedData = $scope->filterData($transformer->getTransformedData($data));
171
172		// Add includes to the payload.
173	7	$includeMap = $scope->includeMap();
174	7	foreach ($scope->resolvedIncludeKeys() as $includeKey) {
175	6	$child = $this->executeTransformerInclude($scope, $includeKey, $includeMap[$includeKey], $data);
176
177		// Create a new child scope.
178	6	$childScope = new Scope($child, $scope->includes()->splice($includeKey), $scope);
179
180		// If working with a ResourceInterface, use it's own key (if present).
181	6	$childKey = $child instanceof ResourceInterface && $child->getResourceKey() ?
182	6	$child->getResourceKey() : $includeKey;
183
184	6	ArrayHelper::mutate(
185		$transformedData,
186	6	$childKey,
187	6	$this->transform($childScope)
188		);
189		}
190
191	7	return $transformedData;
192		}
193
194		/**
195		* Execute the transformer.
196		*
197		* @param Scope $scope
198		* @param string $includeKey
199		* @param array $includeDefinition
200		* @param mixed $data
201		*
202		* @throws IncludeException
203		*
204		* @return ResourceInterface
205		*/
206	6	protected function executeTransformerInclude(Scope $scope, $includeKey, $includeDefinition, $data)
207		{
208		// Transformer explicitly provided an include method
209	6	$transformer = $scope->transformer();
210	6	$method = $includeDefinition['method'];
211	6	if (method_exists($transformer, $method)) {
212	3	return $transformer->$method($data, $scope);
213		}
214
215		// Otherwise try handle the include automatically
216	3	return $this->autoWireInclude($includeKey, $includeDefinition, $data);
217		}
218
219		/**
220		* Resolve the transformer to be used for a resource.
221		* Returns an interface, callable or null when a transformer cannot be resolved.
222		*
223		* @param $resource
224		*
225		* @return TransformerInterface\|mixed\|null
226		*/
227	10	protected function resolveTransformerForResource($resource)
228		{
229	10	$transformer = null;
230
231	10	if ($this->transformerResolver !== null) {
232	2	$transformer = $this->transformerResolver->resolve($resource);
233		}
234
235	10	return $transformer;
236		}
237
238		/**
239		* Fire the relation loader (if defined) for this resource.
240		*
241		* @param ResourceInterface $resource
242		* @param array $relationshipKeys
243		*/
244	14	protected function loadRelations(ResourceInterface $resource, array $relationshipKeys)
245		{
246	14	if ($this->relationLoader !== null && !empty($relationshipKeys)) {
247	1	$this->relationLoader->load($resource, $relationshipKeys);
248		}
249	14	}
250
251		/**
252		* @param string $includeKey
253		* @param array $includeDefinition
254		* @param $item
255		*
256		* @throws \Rexlabs\Smokescreen\Exception\InvalidTransformerException
257		* @throws \Rexlabs\Smokescreen\Exception\IncludeException
258		*
259		* @return Collection\|Item\|ResourceInterface
260		*/
261	3	protected function autoWireInclude($includeKey, $includeDefinition, $item)
262		{
263		// Get the included data
264	3	$data = null;
265	3	if (\is_array($item) \|\| $item instanceof \ArrayAccess) {
266	2	$data = $item[$includeKey] ?? null;
267	1	} elseif (\is_object($item)) {
268	1	$data = $item->$includeKey ?? null;
269		} else {
270		throw new IncludeException("Cannot auto-wire include for $includeKey: Cannot get include data");
271		}
272
273	3	if (!empty($includeDefinition['resource_type']) && $includeDefinition['resource_type'] === 'collection') {
274	1	return new Collection($data);
275		}
276
277		// Assume unless declared, that the resource is an item.
278	3	return new Item($data);
279		}
280
281	11	protected function getSerializer()
282		{
283	11	return $this->serializer;
284		}
285		}
286

rexlabsio / smokescreen-php

Push — master ( e86b6e...1708fa )

Pipeline::serialize() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like