SerializerBuilder::setPropertyUpdater() - Code Metrics - Inspection of "AccessType naming" - schmittjoh/serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#888)

by Robert

created 2018-03-11 11:57 UTC

SerializerBuilder::setPropertyUpdater() A

↳ Parent: SerializerBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	0
cts	3
cp	0
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	1
crap	2

<?php

/*
 * Copyright 2016 Johannes M. Schmitt <[email protected]>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace JMS\Serializer;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\CachedReader;
use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Cache\FilesystemCache;
use JMS\Serializer\Accessor\AccessorStrategyInterface;
use JMS\Serializer\Accessor\DefaultAccessorStrategy;
use JMS\Serializer\Accessor\ExpressionAccessorStrategy;
use JMS\Serializer\Accessor\Updater\ClassAccessorUpdater;
use JMS\Serializer\Builder\DefaultDriverFactory;
use JMS\Serializer\Builder\DriverFactoryInterface;
use JMS\Serializer\Construction\ObjectConstructorInterface;
use JMS\Serializer\Construction\UnserializeObjectConstructor;
use JMS\Serializer\ContextFactory\CallableDeserializationContextFactory;
use JMS\Serializer\ContextFactory\CallableSerializationContextFactory;
use JMS\Serializer\ContextFactory\DeserializationContextFactoryInterface;
use JMS\Serializer\ContextFactory\SerializationContextFactoryInterface;
use JMS\Serializer\EventDispatcher\EventDispatcher;
use JMS\Serializer\EventDispatcher\Subscriber\DoctrineProxySubscriber;
use JMS\Serializer\Exception\InvalidArgumentException;
use JMS\Serializer\Exception\RuntimeException;
use JMS\Serializer\Expression\ExpressionEvaluatorInterface;
use JMS\Serializer\Handler\ArrayCollectionHandler;
use JMS\Serializer\Handler\DateHandler;
use JMS\Serializer\Handler\HandlerRegistry;
use JMS\Serializer\Handler\PhpCollectionHandler;
use JMS\Serializer\Handler\PropelCollectionHandler;
use JMS\Serializer\Handler\StdClassHandler;
use JMS\Serializer\Metadata\ClassMetadataUpdaterInterface;
use JMS\Serializer\Naming\AdvancedNamingStrategyInterface;
use JMS\Serializer\Naming\CamelCaseNamingStrategy;
use JMS\Serializer\Naming\PropertyNamingStrategyInterface;
use JMS\Serializer\Naming\SerializedNameAnnotationStrategy;
use Metadata\Cache\FileCache;
use Metadata\MetadataFactory;
use PhpCollection\Map;

/**
 * Builder for serializer instances.
 *
 * This object makes serializer construction a breeze for projects that do not use
 * any special dependency injection container.
 *
 * @author Johannes M. Schmitt <[email protected]>
 */
class SerializerBuilder
{
    private $metadataDirs = array();
    private $handlerRegistry;
    private $handlersConfigured = false;
    private $eventDispatcher;
    private $listenersConfigured = false;
    private $objectConstructor;
    private $serializationVisitors;
    private $deserializationVisitors;
    private $visitorsAdded = false;
    private $propertyNamingStrategy;
    private $debug = false;
    private $cacheDir;
    private $annotationReader;
    private $includeInterfaceMetadata = false;
    private $driverFactory;
    private $serializationContextFactory;
    private $deserializationContextFactory;

    /**
     * @var ExpressionEvaluatorInterface
     */
    private $expressionEvaluator;

    /**
     * @var AccessorStrategyInterface
     */
    private $accessorStrategy;

    /**
     * @var ClassMetadataUpdaterInterface
     */
    private $propertyUpdater;

    public static function create()
    {
        return new static();
    }

    public function __construct()
    {
        $this->handlerRegistry = new HandlerRegistry();
        $this->eventDispatcher = new EventDispatcher();
        $this->driverFactory = new DefaultDriverFactory();
        $this->serializationVisitors = new Map();
        $this->deserializationVisitors = new Map();
        $this->propertyUpdater = new ClassAccessorUpdater();
    }

    public function setAccessorStrategy(AccessorStrategyInterface $accessorStrategy)
    {
        $this->accessorStrategy = $accessorStrategy;
    }

    protected function getAccessorStrategy()
    {
        if (!$this->accessorStrategy) {
            $this->accessorStrategy = new DefaultAccessorStrategy();

            if ($this->expressionEvaluator) {
                $this->accessorStrategy = new ExpressionAccessorStrategy($this->expressionEvaluator, $this->accessorStrategy);
            }
        }
        return $this->accessorStrategy;
    }

    public function setExpressionEvaluator(ExpressionEvaluatorInterface $expressionEvaluator)
    {
        $this->expressionEvaluator = $expressionEvaluator;

        return $this;
    }

    public function setAnnotationReader(Reader $reader)
    {
        $this->annotationReader = $reader;

        return $this;
    }

    /**
     * You must preserve default behavior of `ClassAccessorUpdater`.
     *
     * @param ClassMetadataUpdaterInterface $propertyUpdater
     *
     * @return $this
     */
    public function setPropertyUpdater(ClassMetadataUpdaterInterface $propertyUpdater)
    {
        $this->propertyUpdater = $propertyUpdater;

        return $this;
    }

    public function setDebug($bool)
    {
        $this->debug = (boolean)$bool;

        return $this;
    }

    public function setCacheDir($dir)
    {
        if (!is_dir($dir)) {
            $this->createDir($dir);
        }
        if (!is_writable($dir)) {
            throw new InvalidArgumentException(sprintf('The cache directory "%s" is not writable.', $dir));
        }

        $this->cacheDir = $dir;

        return $this;
    }

    public function addDefaultHandlers()
    {
        $this->handlersConfigured = true;
        $this->handlerRegistry->registerSubscribingHandler(new DateHandler());
        $this->handlerRegistry->registerSubscribingHandler(new StdClassHandler());
        $this->handlerRegistry->registerSubscribingHandler(new PhpCollectionHandler());
        $this->handlerRegistry->registerSubscribingHandler(new ArrayCollectionHandler());
        $this->handlerRegistry->registerSubscribingHandler(new PropelCollectionHandler());

        return $this;
    }

    public function configureHandlers(\Closure $closure)
    {
        $this->handlersConfigured = true;
        $closure($this->handlerRegistry);

        return $this;
    }

    public function addDefaultListeners()
    {
        $this->listenersConfigured = true;
        $this->eventDispatcher->addSubscriber(new DoctrineProxySubscriber());

        return $this;
    }

    public function configureListeners(\Closure $closure)
    {
        $this->listenersConfigured = true;
        $closure($this->eventDispatcher);

        return $this;
    }

    public function setObjectConstructor(ObjectConstructorInterface $constructor)
    {
        $this->objectConstructor = $constructor;

        return $this;
    }

    public function setPropertyNamingStrategy(PropertyNamingStrategyInterface $propertyNamingStrategy)
    {
        $this->propertyNamingStrategy = $propertyNamingStrategy;

        return $this;
    }

    public function setAdvancedNamingStrategy(AdvancedNamingStrategyInterface $advancedNamingStrategy)
    {
        $this->propertyNamingStrategy = $advancedNamingStrategy;

        return $this;
    }

    public function setSerializationVisitor($format, VisitorInterface $visitor)
    {
        $this->visitorsAdded = true;
        $this->serializationVisitors->set($format, $visitor);

        return $this;
    }

    public function setDeserializationVisitor($format, VisitorInterface $visitor)
    {
        $this->visitorsAdded = true;
        $this->deserializationVisitors->set($format, $visitor);

        return $this;
    }

    public function addDefaultSerializationVisitors()
    {
        $this->initializePropertyNamingStrategy();

        $this->visitorsAdded = true;
        $this->serializationVisitors->setAll(array(
            'xml' => new XmlSerializationVisitor($this->propertyNamingStrategy, $this->getAccessorStrategy()),
            'yml' => new YamlSerializationVisitor($this->propertyNamingStrategy, $this->getAccessorStrategy()),
            'json' => new JsonSerializationVisitor($this->propertyNamingStrategy, $this->getAccessorStrategy()),
        ));

        return $this;
    }

    public function addDefaultDeserializationVisitors()
    {
        $this->initializePropertyNamingStrategy();

        $this->visitorsAdded = true;
        $this->deserializationVisitors->setAll(array(
            'xml' => new XmlDeserializationVisitor($this->propertyNamingStrategy),
            'json' => new JsonDeserializationVisitor($this->propertyNamingStrategy),
        ));

        return $this;
    }

    /**
     * @param Boolean $include Whether to include the metadata from the interfaces
     *
     * @return SerializerBuilder
     */
    public function includeInterfaceMetadata($include)
    {
        $this->includeInterfaceMetadata = (Boolean)$include;

        return $this;
    }

    /**
     * Sets a map of namespace prefixes to directories.
     *
     * This method overrides any previously defined directories.
     *
     * @param array <string,string> $namespacePrefixToDirMap
     *
     * @return SerializerBuilder
     *
     * @throws InvalidArgumentException When a directory does not exist
     */
    public function setMetadataDirs(array $namespacePrefixToDirMap)
    {
        foreach ($namespacePrefixToDirMap as $dir) {
            if (!is_dir($dir)) {
                throw new InvalidArgumentException(sprintf('The directory "%s" does not exist.', $dir));
            }
        }

        $this->metadataDirs = $namespacePrefixToDirMap;

        return $this;
    }

    /**
     * Adds a directory where the serializer will look for class metadata.
     *
     * The namespace prefix will make the names of the actual metadata files a bit shorter. For example, let's assume
     * that you have a directory where you only store metadata files for the ``MyApplication\Entity`` namespace.
     *
     * If you use an empty prefix, your metadata files would need to look like:
     *
     * ``my-dir/MyApplication.Entity.SomeObject.yml``
     * ``my-dir/MyApplication.Entity.OtherObject.xml``
     *
     * If you use ``MyApplication\Entity`` as prefix, your metadata files would need to look like:
     *
     * ``my-dir/SomeObject.yml``
     * ``my-dir/OtherObject.yml``
     *
     * Please keep in mind that you currently may only have one directory per namespace prefix.
     *
     * @param string $dir The directory where metadata files are located.
     * @param string $namespacePrefix An optional prefix if you only store metadata for specific namespaces in this directory.
     *
     * @return SerializerBuilder
     *
     * @throws InvalidArgumentException When a directory does not exist
     * @throws InvalidArgumentException When a directory has already been registered
     */
    public function addMetadataDir($dir, $namespacePrefix = '')
    {
        if (!is_dir($dir)) {
            throw new InvalidArgumentException(sprintf('The directory "%s" does not exist.', $dir));
        }

        if (isset($this->metadataDirs[$namespacePrefix])) {
            throw new InvalidArgumentException(sprintf('There is already a directory configured for the namespace prefix "%s". Please use replaceMetadataDir() to override directories.', $namespacePrefix));
        }

        $this->metadataDirs[$namespacePrefix] = $dir;

        return $this;
    }

    /**
     * Adds a map of namespace prefixes to directories.
     *
     * @param array <string,string> $namespacePrefixToDirMap
     *
     * @return SerializerBuilder
     */
    public function addMetadataDirs(array $namespacePrefixToDirMap)
    {
        foreach ($namespacePrefixToDirMap as $prefix => $dir) {
            $this->addMetadataDir($dir, $prefix);
        }

        return $this;
    }

    /**
     * Similar to addMetadataDir(), but overrides an existing entry.
     *
     * @param string $dir
     * @param string $namespacePrefix
     *
     * @return SerializerBuilder
     *
     * @throws InvalidArgumentException When a directory does not exist
     * @throws InvalidArgumentException When no directory is configured for the ns prefix
     */
    public function replaceMetadataDir($dir, $namespacePrefix = '')
    {
        if (!is_dir($dir)) {
            throw new InvalidArgumentException(sprintf('The directory "%s" does not exist.', $dir));
        }

        if (!isset($this->metadataDirs[$namespacePrefix])) {
            throw new InvalidArgumentException(sprintf('There is no directory configured for namespace prefix "%s". Please use addMetadataDir() for adding new directories.', $namespacePrefix));
        }

        $this->metadataDirs[$namespacePrefix] = $dir;

        return $this;
    }

    public function setMetadataDriverFactory(DriverFactoryInterface $driverFactory)
    {
        $this->driverFactory = $driverFactory;

        return $this;
    }

    /**
     * @param SerializationContextFactoryInterface|callable $serializationContextFactory
     *
     * @return self
     */
    public function setSerializationContextFactory($serializationContextFactory)
    {
        if ($serializationContextFactory instanceof SerializationContextFactoryInterface) {
            $this->serializationContextFactory = $serializationContextFactory;
        } elseif (is_callable($serializationContextFactory)) {
            $this->serializationContextFactory = new CallableSerializationContextFactory(
                $serializationContextFactory
            );
        } else {
            throw new InvalidArgumentException('expected SerializationContextFactoryInterface or callable.');
        }

        return $this;
    }

    /**
     * @param DeserializationContextFactoryInterface|callable $deserializationContextFactory
     *
     * @return self
     */
    public function setDeserializationContextFactory($deserializationContextFactory)
    {
        if ($deserializationContextFactory instanceof DeserializationContextFactoryInterface) {
            $this->deserializationContextFactory = $deserializationContextFactory;
        } elseif (is_callable($deserializationContextFactory)) {
            $this->deserializationContextFactory = new CallableDeserializationContextFactory(
                $deserializationContextFactory
            );
        } else {
            throw new InvalidArgumentException('expected DeserializationContextFactoryInterface or callable.');
        }

        return $this;
    }

    public function build()
    {
        $annotationReader = $this->annotationReader;
        if (null === $annotationReader) {
            $annotationReader = new AnnotationReader();

            if (null !== $this->cacheDir) {
                $this->createDir($this->cacheDir . '/annotations');
                $annotationsCache = new FilesystemCache($this->cacheDir . '/annotations');
                $annotationReader = new CachedReader($annotationReader, $annotationsCache, $this->debug);
            }
        }

        $metadataDriver = $this->driverFactory->createDriver(
            $this->metadataDirs,
            $annotationReader,
            $this->propertyUpdater
        );
        $metadataFactory = new MetadataFactory($metadataDriver, null, $this->debug);

        $metadataFactory->setIncludeInterfaces($this->includeInterfaceMetadata);

        if (null !== $this->cacheDir) {
            $this->createDir($this->cacheDir . '/metadata');
            $metadataFactory->setCache(new FileCache($this->cacheDir . '/metadata'));
        }

        if (!$this->handlersConfigured) {
            $this->addDefaultHandlers();
        }

        if (!$this->listenersConfigured) {
            $this->addDefaultListeners();
        }

        if (!$this->visitorsAdded) {
            $this->addDefaultSerializationVisitors();
            $this->addDefaultDeserializationVisitors();
        }

        $serializer = new Serializer(
            $metadataFactory,
            $this->handlerRegistry,
            $this->objectConstructor ?: new UnserializeObjectConstructor(),
            $this->serializationVisitors,
            $this->deserializationVisitors,
            $this->eventDispatcher,
            null,
            $this->expressionEvaluator
        );

        if (null !== $this->serializationContextFactory) {
            $serializer->setSerializationContextFactory($this->serializationContextFactory);
        }

        if (null !== $this->deserializationContextFactory) {
            $serializer->setDeserializationContextFactory($this->deserializationContextFactory);
        }

        return $serializer;
    }

    private function initializePropertyNamingStrategy()
    {
        if (null !== $this->propertyNamingStrategy) {
            return;
        }

        $this->propertyNamingStrategy = new SerializedNameAnnotationStrategy(new CamelCaseNamingStrategy());
    }

    private function createDir($dir)
    {
        if (is_dir($dir)) {
            return;
        }

        if (false === @mkdir($dir, 0777, true) && false === is_dir($dir)) {
            throw new RuntimeException(sprintf('Could not create directory "%s".', $dir));
        }
    }
}


1		<?php
2
3		/*
4		* Copyright 2016 Johannes M. Schmitt <[email protected]>
5		*
6		* Licensed under the Apache License, Version 2.0 (the "License");
7		* you may not use this file except in compliance with the License.
8		* You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing, software
13		* distributed under the License is distributed on an "AS IS" BASIS,
14		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15		* See the License for the specific language governing permissions and
16		* limitations under the License.
17		*/
18
19		namespace JMS\Serializer;
20
21		use Doctrine\Common\Annotations\AnnotationReader;
22		use Doctrine\Common\Annotations\CachedReader;
23		use Doctrine\Common\Annotations\Reader;
24		use Doctrine\Common\Cache\FilesystemCache;
25		use JMS\Serializer\Accessor\AccessorStrategyInterface;
26		use JMS\Serializer\Accessor\DefaultAccessorStrategy;
27		use JMS\Serializer\Accessor\ExpressionAccessorStrategy;
28		use JMS\Serializer\Accessor\Updater\ClassAccessorUpdater;
29		use JMS\Serializer\Builder\DefaultDriverFactory;
30		use JMS\Serializer\Builder\DriverFactoryInterface;
31		use JMS\Serializer\Construction\ObjectConstructorInterface;
32		use JMS\Serializer\Construction\UnserializeObjectConstructor;
33		use JMS\Serializer\ContextFactory\CallableDeserializationContextFactory;
34		use JMS\Serializer\ContextFactory\CallableSerializationContextFactory;
35		use JMS\Serializer\ContextFactory\DeserializationContextFactoryInterface;
36		use JMS\Serializer\ContextFactory\SerializationContextFactoryInterface;
37		use JMS\Serializer\EventDispatcher\EventDispatcher;
38		use JMS\Serializer\EventDispatcher\Subscriber\DoctrineProxySubscriber;
39		use JMS\Serializer\Exception\InvalidArgumentException;
40		use JMS\Serializer\Exception\RuntimeException;
41		use JMS\Serializer\Expression\ExpressionEvaluatorInterface;
42		use JMS\Serializer\Handler\ArrayCollectionHandler;
43		use JMS\Serializer\Handler\DateHandler;
44		use JMS\Serializer\Handler\HandlerRegistry;
45		use JMS\Serializer\Handler\PhpCollectionHandler;
46		use JMS\Serializer\Handler\PropelCollectionHandler;
47		use JMS\Serializer\Handler\StdClassHandler;
48		use JMS\Serializer\Metadata\ClassMetadataUpdaterInterface;
49		use JMS\Serializer\Naming\AdvancedNamingStrategyInterface;
50		use JMS\Serializer\Naming\CamelCaseNamingStrategy;
51		use JMS\Serializer\Naming\PropertyNamingStrategyInterface;
52		use JMS\Serializer\Naming\SerializedNameAnnotationStrategy;
53		use Metadata\Cache\FileCache;
54		use Metadata\MetadataFactory;
55		use PhpCollection\Map;
56
57		/**
58		* Builder for serializer instances.
59		*
60		* This object makes serializer construction a breeze for projects that do not use
61		* any special dependency injection container.
62		*
63		* @author Johannes M. Schmitt <[email protected]>
64		*/
65		class SerializerBuilder
66		{
67		private $metadataDirs = array();
68		private $handlerRegistry;
69		private $handlersConfigured = false;
70		private $eventDispatcher;
71		private $listenersConfigured = false;
72		private $objectConstructor;
73		private $serializationVisitors;
74		private $deserializationVisitors;
75		private $visitorsAdded = false;
76		private $propertyNamingStrategy;
77		private $debug = false;
78		private $cacheDir;
79		private $annotationReader;
80		private $includeInterfaceMetadata = false;
81		private $driverFactory;
82		private $serializationContextFactory;
83		private $deserializationContextFactory;
84
85		/**
86		* @var ExpressionEvaluatorInterface
87		*/
88		private $expressionEvaluator;
89
90		/**
91		* @var AccessorStrategyInterface
92		*/
93		private $accessorStrategy;
94
95		/**
96		* @var ClassMetadataUpdaterInterface
97		*/
98		private $propertyUpdater;
99
100	30	public static function create()
101		{
102	30	return new static();
103		}
104
105	30	public function __construct()
106		{
107	30	$this->handlerRegistry = new HandlerRegistry();
108	30	$this->eventDispatcher = new EventDispatcher();
109	30	$this->driverFactory = new DefaultDriverFactory();
110	30	$this->serializationVisitors = new Map();
111	30	$this->deserializationVisitors = new Map();
112	30	$this->propertyUpdater = new ClassAccessorUpdater();
113	30	}
114
115		public function setAccessorStrategy(AccessorStrategyInterface $accessorStrategy)
116		{
117		$this->accessorStrategy = $accessorStrategy;
118		}
119
120	29	protected function getAccessorStrategy()
121		{
122	29	if (!$this->accessorStrategy) {
123	29	$this->accessorStrategy = new DefaultAccessorStrategy();
124
125	29	if ($this->expressionEvaluator) {
126	3	$this->accessorStrategy = new ExpressionAccessorStrategy($this->expressionEvaluator, $this->accessorStrategy);
127		}
128		}
129	29	return $this->accessorStrategy;
130		}
131
132	3	public function setExpressionEvaluator(ExpressionEvaluatorInterface $expressionEvaluator)
133		{
134	3	$this->expressionEvaluator = $expressionEvaluator;
135
136	3	return $this;
137		}
138
139		public function setAnnotationReader(Reader $reader)
140		{
141		$this->annotationReader = $reader;
142
143		return $this;
144		}
145
146		/**
147		* You must preserve default behavior of `ClassAccessorUpdater`.
148		*
149		* @param ClassMetadataUpdaterInterface $propertyUpdater
150		*
151		* @return $this
152		*/
153		public function setPropertyUpdater(ClassMetadataUpdaterInterface $propertyUpdater)
154		{
155		$this->propertyUpdater = $propertyUpdater;
156
157		return $this;
158		}
159
160		public function setDebug($bool)
161		{
162		$this->debug = (boolean)$bool;
163
164		return $this;
165		}
166
167	1	public function setCacheDir($dir)
168		{
169	1	if (!is_dir($dir)) {
170	1	$this->createDir($dir);
171		}
172	1	if (!is_writable($dir)) {
173		throw new InvalidArgumentException(sprintf('The cache directory "%s" is not writable.', $dir));
174		}
175
176	1	$this->cacheDir = $dir;
177
178	1	return $this;
179		}
180
181	29	public function addDefaultHandlers()
182		{
183	29	$this->handlersConfigured = true;
184	29	$this->handlerRegistry->registerSubscribingHandler(new DateHandler());
185	29	$this->handlerRegistry->registerSubscribingHandler(new StdClassHandler());
186	29	$this->handlerRegistry->registerSubscribingHandler(new PhpCollectionHandler());
187	29	$this->handlerRegistry->registerSubscribingHandler(new ArrayCollectionHandler());
188	29	$this->handlerRegistry->registerSubscribingHandler(new PropelCollectionHandler());
189
190	29	return $this;
191		}
192
193	1	public function configureHandlers(\Closure $closure)
194		{
195	1	$this->handlersConfigured = true;
196	1	$closure($this->handlerRegistry);
197
198	1	return $this;
199		}
200
201	29	public function addDefaultListeners()
202		{
203	29	$this->listenersConfigured = true;
204	29	$this->eventDispatcher->addSubscriber(new DoctrineProxySubscriber());
205
206	29	return $this;
207		}
208
209	1	public function configureListeners(\Closure $closure)
210		{
211	1	$this->listenersConfigured = true;
212	1	$closure($this->eventDispatcher);
213
214	1	return $this;
215		}
216
217		public function setObjectConstructor(ObjectConstructorInterface $constructor)
218		{
219		$this->objectConstructor = $constructor;
220
221		return $this;
222		}
223
224		public function setPropertyNamingStrategy(PropertyNamingStrategyInterface $propertyNamingStrategy)
225		{
226		$this->propertyNamingStrategy = $propertyNamingStrategy;
227
228		return $this;
229		}
230
231	1	public function setAdvancedNamingStrategy(AdvancedNamingStrategyInterface $advancedNamingStrategy)
232		{
233	1	$this->propertyNamingStrategy = $advancedNamingStrategy;
234
235	1	return $this;
236		}
237
238	1	public function setSerializationVisitor($format, VisitorInterface $visitor)
239		{
240	1	$this->visitorsAdded = true;
241	1	$this->serializationVisitors->set($format, $visitor);
242
243	1	return $this;
244		}
245
246		public function setDeserializationVisitor($format, VisitorInterface $visitor)
247		{
248		$this->visitorsAdded = true;
249		$this->deserializationVisitors->set($format, $visitor);
250
251		return $this;
252		}
253
254	29	public function addDefaultSerializationVisitors()
255		{
256	29	$this->initializePropertyNamingStrategy();
257
258	29	$this->visitorsAdded = true;
259	29	$this->serializationVisitors->setAll(array(
260	29	'xml' => new XmlSerializationVisitor($this->propertyNamingStrategy, $this->getAccessorStrategy()),
261	29	'yml' => new YamlSerializationVisitor($this->propertyNamingStrategy, $this->getAccessorStrategy()),
262	29	'json' => new JsonSerializationVisitor($this->propertyNamingStrategy, $this->getAccessorStrategy()),
263		));
264
265	29	return $this;
266		}
267
268	29	public function addDefaultDeserializationVisitors()
269		{
270	29	$this->initializePropertyNamingStrategy();
271
272	29	$this->visitorsAdded = true;
273	29	$this->deserializationVisitors->setAll(array(
274	29	'xml' => new XmlDeserializationVisitor($this->propertyNamingStrategy),
275	29	'json' => new JsonDeserializationVisitor($this->propertyNamingStrategy),
276		));
277
278	29	return $this;
279		}
280
281		/**
282		* @param Boolean $include Whether to include the metadata from the interfaces
283		*
284		* @return SerializerBuilder
285		*/
286	1	public function includeInterfaceMetadata($include)
287		{
288	1	$this->includeInterfaceMetadata = (Boolean)$include;
289
290	1	return $this;
291		}
292
293		/**
294		* Sets a map of namespace prefixes to directories.
295		*
296		* This method overrides any previously defined directories.
297		*
298		* @param array <string,string> $namespacePrefixToDirMap
299		*
300		* @return SerializerBuilder
301		*
302		* @throws InvalidArgumentException When a directory does not exist
303		*/
304		public function setMetadataDirs(array $namespacePrefixToDirMap)
305		{
306		foreach ($namespacePrefixToDirMap as $dir) {
307		if (!is_dir($dir)) {
308		throw new InvalidArgumentException(sprintf('The directory "%s" does not exist.', $dir));
309		}
310		}
311
312		$this->metadataDirs = $namespacePrefixToDirMap;
313
314		return $this;
315		}
316
317		/**
318		* Adds a directory where the serializer will look for class metadata.
319		*
320		* The namespace prefix will make the names of the actual metadata files a bit shorter. For example, let's assume
321		* that you have a directory where you only store metadata files for the ``MyApplication\Entity`` namespace.
322		*
323		* If you use an empty prefix, your metadata files would need to look like:
324		*
325		* ``my-dir/MyApplication.Entity.SomeObject.yml``
326		* ``my-dir/MyApplication.Entity.OtherObject.xml``
327		*
328		* If you use ``MyApplication\Entity`` as prefix, your metadata files would need to look like:
329		*
330		* ``my-dir/SomeObject.yml``
331		* ``my-dir/OtherObject.yml``
332		*
333		* Please keep in mind that you currently may only have one directory per namespace prefix.
334		*
335		* @param string $dir The directory where metadata files are located.
336		* @param string $namespacePrefix An optional prefix if you only store metadata for specific namespaces in this directory.
337		*
338		* @return SerializerBuilder
339		*
340		* @throws InvalidArgumentException When a directory does not exist
341		* @throws InvalidArgumentException When a directory has already been registered
342		*/
343		public function addMetadataDir($dir, $namespacePrefix = '')
344		{
345		if (!is_dir($dir)) {
346		throw new InvalidArgumentException(sprintf('The directory "%s" does not exist.', $dir));
347		}
348
349		if (isset($this->metadataDirs[$namespacePrefix])) {
350		throw new InvalidArgumentException(sprintf('There is already a directory configured for the namespace prefix "%s". Please use replaceMetadataDir() to override directories.', $namespacePrefix));
351		}
352
353		$this->metadataDirs[$namespacePrefix] = $dir;
354
355		return $this;
356		}
357
358		/**
359		* Adds a map of namespace prefixes to directories.
360		*
361		* @param array <string,string> $namespacePrefixToDirMap
362		*
363		* @return SerializerBuilder
364		*/
365		public function addMetadataDirs(array $namespacePrefixToDirMap)
366		{
367		foreach ($namespacePrefixToDirMap as $prefix => $dir) {
368		$this->addMetadataDir($dir, $prefix);
369		}
370
371		return $this;
372		}
373
374		/**
375		* Similar to addMetadataDir(), but overrides an existing entry.
376		*
377		* @param string $dir
378		* @param string $namespacePrefix
379		*
380		* @return SerializerBuilder
381		*
382		* @throws InvalidArgumentException When a directory does not exist
383		* @throws InvalidArgumentException When no directory is configured for the ns prefix
384		*/
385		public function replaceMetadataDir($dir, $namespacePrefix = '')
386		{
387		if (!is_dir($dir)) {
388		throw new InvalidArgumentException(sprintf('The directory "%s" does not exist.', $dir));
389		}
390
391		if (!isset($this->metadataDirs[$namespacePrefix])) {
392		throw new InvalidArgumentException(sprintf('There is no directory configured for namespace prefix "%s". Please use addMetadataDir() for adding new directories.', $namespacePrefix));
393		}
394
395		$this->metadataDirs[$namespacePrefix] = $dir;
396
397		return $this;
398		}
399
400	12	public function setMetadataDriverFactory(DriverFactoryInterface $driverFactory)
401		{
402	12	$this->driverFactory = $driverFactory;
403
404	12	return $this;
405		}
406
407		/**
408		* @param SerializationContextFactoryInterface\|callable $serializationContextFactory
409		*
410		* @return self
411		*/
412	3	public function setSerializationContextFactory($serializationContextFactory)
413		{
414	3	if ($serializationContextFactory instanceof SerializationContextFactoryInterface) {
415	1	$this->serializationContextFactory = $serializationContextFactory;
416	2	} elseif (is_callable($serializationContextFactory)) {
417	2	$this->serializationContextFactory = new CallableSerializationContextFactory(
418	2	$serializationContextFactory
419		);
420		} else {
421		throw new InvalidArgumentException('expected SerializationContextFactoryInterface or callable.');
422		}
423
424	3	return $this;
425		}
426
427		/**
428		* @param DeserializationContextFactoryInterface\|callable $deserializationContextFactory
429		*
430		* @return self
431		*/
432	1	public function setDeserializationContextFactory($deserializationContextFactory)
433		{
434	1	if ($deserializationContextFactory instanceof DeserializationContextFactoryInterface) {
435	1	$this->deserializationContextFactory = $deserializationContextFactory;
436		} elseif (is_callable($deserializationContextFactory)) {
437		$this->deserializationContextFactory = new CallableDeserializationContextFactory(
438		$deserializationContextFactory
439		);
440		} else {
441		throw new InvalidArgumentException('expected DeserializationContextFactoryInterface or callable.');
442		}
443
444	1	return $this;
445		}
446
447	30	public function build()
448		{
449	30	$annotationReader = $this->annotationReader;
450	30	if (null === $annotationReader) {
451	30	$annotationReader = new AnnotationReader();
452
453	30	if (null !== $this->cacheDir) {
454	1	$this->createDir($this->cacheDir . '/annotations');
455	1	$annotationsCache = new FilesystemCache($this->cacheDir . '/annotations');
456	1	$annotationReader = new CachedReader($annotationReader, $annotationsCache, $this->debug);
457		}
458		}
459
460	30	$metadataDriver = $this->driverFactory->createDriver(
461	30	$this->metadataDirs,
462	30	$annotationReader,
463	30	$this->propertyUpdater
464		);
465	30	$metadataFactory = new MetadataFactory($metadataDriver, null, $this->debug);
466
467	30	$metadataFactory->setIncludeInterfaces($this->includeInterfaceMetadata);
468
469	30	if (null !== $this->cacheDir) {
470	1	$this->createDir($this->cacheDir . '/metadata');
471	1	$metadataFactory->setCache(new FileCache($this->cacheDir . '/metadata'));
472		}
473
474	30	if (!$this->handlersConfigured) {
475	28	$this->addDefaultHandlers();
476		}
477
478	30	if (!$this->listenersConfigured) {
479	29	$this->addDefaultListeners();
480		}
481
482	30	if (!$this->visitorsAdded) {
483	29	$this->addDefaultSerializationVisitors();
484	29	$this->addDefaultDeserializationVisitors();
485		}
486
487	30	$serializer = new Serializer(
488	30	$metadataFactory,
489	30	$this->handlerRegistry,
490	30	$this->objectConstructor ?: new UnserializeObjectConstructor(),
491	30	$this->serializationVisitors,
492	30	$this->deserializationVisitors,
493	30	$this->eventDispatcher,
494	30	null,
495	30	$this->expressionEvaluator
496		);
497
498	30	if (null !== $this->serializationContextFactory) {
499	3	$serializer->setSerializationContextFactory($this->serializationContextFactory);
500		}
501
502	30	if (null !== $this->deserializationContextFactory) {
503	1	$serializer->setDeserializationContextFactory($this->deserializationContextFactory);
504		}
505
506	30	return $serializer;
507		}
508
509	29	private function initializePropertyNamingStrategy()
510		{
511	29	if (null !== $this->propertyNamingStrategy) {
512	29	return;
513		}
514
515	28	$this->propertyNamingStrategy = new SerializedNameAnnotationStrategy(new CamelCaseNamingStrategy());
516	28	}
517
518	1	private function createDir($dir)
519		{
520	1	if (is_dir($dir)) {
521		return;
522		}
523
524	1	if (false === @mkdir($dir, 0777, true) && false === is_dir($dir)) {
525		throw new RuntimeException(sprintf('Could not create directory "%s".', $dir));
526		}
527	1	}
528		}
529

schmittjoh / serializer

Pull Request — master (#888)

SerializerBuilder::setPropertyUpdater() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like