Client::buildSerializer() - Code Metrics - cct-marketing/kong-php-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Client::buildSerializer() A
last analyzed 2018-04-04 14:38 UTC

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

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

<?php

declare(strict_types=1);

namespace CCT\Kong;

use Assert\Assert;
use CCT\Kong\EventListener\DeserializeExtraFieldsSubscriber;
use CCT\Kong\Exception\InvalidParameterException;
use CCT\Kong\Helper\ObjectConstructor;
use CCT\Kong\Http\Request\ApiRequest;
use CCT\Kong\Http\Request\ConsumerRequest;
use CCT\Kong\Http\Request\CertificateRequest;
use CCT\Kong\Http\Request\KongRequest;
use CCT\Kong\Http\Request\PluginRequest;
use CCT\Kong\Http\Request\SNIRequest;
use CCT\Kong\Http\Request\StatusRequest;
use CCT\Kong\Http\RequestInterface;
use CCT\Kong\Model\Api;
use CCT\Kong\Model\Consumer;
use CCT\Kong\Model\Info;
filter:
    dependency_paths: ["lib/*"]
use CCT\Kong\Model\Kong;
use CCT\Kong\Model\Plugin;
use CCT\Kong\Model\SNI;
use CCT\Kong\Model\Status;
use CCT\Kong\Serializer\Handler\BooleanToStringHandler;
use CCT\Kong\Serializer\Handler\TimestampDatetimeHandler;
use CCT\Kong\Serializer\SerializerBuilder;
use CCT\Kong\Transformer\Response\CollectionObjectTransformer;
use CCT\Kong\Transformer\Response\ObjectTransformer;
use CCT\Kong\Model\Certificate;
use GuzzleHttp\Client as GuzzleClient;
use JMS\Serializer\SerializerInterface;

class Client
{
    /**
     * @var GuzzleClient
     */
    protected $client;

    /**
     * @var Config
     */
    protected $config;

    /**
     * @var bool
     */
    protected $defaultConfig = true;

    /**
     * @var SerializerInterface
     */
    protected static $serializer;

    public function __construct(Config $config, bool $defaultConfig = true)
    {
        Assert::that($config->all())->keyExists(Config::ENDPOINT);

        $this->defaultConfig = $defaultConfig;
        $this->config = $config;
        $this->client = new GuzzleClient([
            'base_uri' => $config->get(Config::ENDPOINT)
        ]);

        if ($defaultConfig) {
            $this->applyDefaults();
        }
    }

    /**
     * @return KongRequest
     */
    public function kong(): KongRequest
    {
        $config = clone $this->config;
        $modelClass = $config->get('kong.model.class', Kong::class);

        if ($this->isDefaultConfig()) {
            $config->set(Config::OBJECT_CONSTRUCTOR, new ObjectConstructor());
            $config->set(Config::EVENT_SUBSCRIBERS, [
                new DeserializeExtraFieldsSubscriber([
                    $modelClass => [
                        'tagline',
                        'lua_version',
                        'hostname',
                        'version',
                    ]
                ]),
            ]);
        }

        $serializer = $this->buildSerializer($config);
        if ($this->shouldUseDefaultResponseTransformers()) {
            $this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
        }

        return $this->createRequestInstance(KongRequest::class, $serializer, $config);
    }

    /**
     * @return StatusRequest
     */
    public function status(): StatusRequest
    {
        $config = clone $this->config;
        $modelClass = $config->get('status.model.class', Status::class);

        $serializer = $this->getBuiltSerializer($config);
        if ($this->shouldUseDefaultResponseTransformers()) {
            $this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
        }

        return $this->createRequestInstance(StatusRequest::class, $serializer, $config);
    }

    /**
     * @return ApiRequest
     */
    public function apis(): ApiRequest
    {
        $config = clone $this->config;
        $modelClass = $config->get('api.model.class', Api::class);

        $serializer = $this->getBuiltSerializer($config);
        if ($this->shouldUseDefaultResponseTransformers()) {
            $this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
        }

        return $this->createRequestInstance(ApiRequest::class, $serializer, $config);
    }

    /**
     * @return ConsumerRequest
     */
    public function consumers(): ConsumerRequest
    {
        $config = clone $this->config;
        $modelClass = $config->get('consumer.model.class', Consumer::class);

        $serializer = $this->getBuiltSerializer($config);
        if ($this->shouldUseDefaultResponseTransformers()) {
            $this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
        }

        return $this->createRequestInstance(ConsumerRequest::class, $serializer, $config);
    }

    /**
     * @return PluginRequest
     */
    public function plugins(): PluginRequest
    {
        $config = clone $this->config;
        $modelClass = $config->get('plugin.model.class', Plugin::class);

        $serializer = $this->getBuiltSerializer($config);
        if ($this->shouldUseDefaultResponseTransformers()) {
            $this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
        }

        return $this->createRequestInstance(PluginRequest::class, $serializer, $config);
    }

    /**
     * @return CertificateRequest
     */
    public function certificates(): CertificateRequest
    {
        $config = clone $this->config;
        $modelClass = $config->get('certificate.model.class', Certificate::class);

        $serializer = $this->getBuiltSerializer($config);
        if ($this->shouldUseDefaultResponseTransformers()) {
            $this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
        }

        return $this->createRequestInstance(CertificateRequest::class, $serializer, $config);
    }

    /**
     * @return SNIRequest
     */
    public function snis(): SNIRequest
    {
        $config = clone $this->config;
        $modelClass = $config->get('sni.model.class', SNI::class);

        $serializer = $this->getBuiltSerializer($config);
        if ($this->shouldUseDefaultResponseTransformers()) {
            $this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
        }

        return $this->createRequestInstance(SNIRequest::class, $serializer, $config);
    }

    public function enableDefaultConfig()
    {
        $this->defaultConfig = true;
    }

    public function disableDefaultConfig()
    {
        $this->defaultConfig = false;
    }

    public function isDefaultConfig(): bool
    {
        return $this->defaultConfig;
    }

    protected function applyDefaults()
    {
        $this->config->set(Config::METADATA_DIRS, [
            [
                'dir' => __DIR__ . '/Resources/metadata',
                'namespacePrefix' => 'CCT\\Kong\\Model',
            ]
        ]);

        $this->config->set(Config::USE_DEFAULT_RESPONSE_TRANSFORMERS, true);
        $this->config->set(Config::SERIALIZATION_HANDLERS, [
            new BooleanToStringHandler(),
            new TimestampDatetimeHandler()
        ]);
    }

    public function clearDefaults()
    {
        $this->config->remove(Config::METADATA_DIRS);
        $this->config->remove(Config::DEBUG);
        $this->config->remove(Config::EVENT_SUBSCRIBERS);
        $this->config->remove(Config::SERIALIZATION_HANDLERS);
        $this->config->remove(Config::OBJECT_CONSTRUCTOR);
        $this->config->remove(Config::USE_DEFAULT_RESPONSE_TRANSFORMERS);
    }

    protected function buildSerializer(Config $config)
    {
        return SerializerBuilder::createByConfig($config)
            ->configureDefaults()
            ->build()
        ;
    }

    protected function getBuiltSerializer(Config $config)
    {
        if (null === static::$serializer) {
            static::$serializer = $this->buildSerializer($config);
        }

        return static::$serializer;
    }

    protected function createRequestInstance($class, SerializerInterface $serializer, Config $config)
    {
        $reflectionClass = new \ReflectionClass($class);

        if (!$reflectionClass->implementsInterface(RequestInterface::class)) {
            throw new InvalidParameterException(sprintf(
                'The class must be an instance of %s',
                RequestInterface::class
            ));
        }

        return $reflectionClass->newInstance(
            $this->client,
            $serializer,
            $config
        );
    }

    /**
     * Should use the default response transformers?
     *
     * @return bool
     */
    protected function shouldUseDefaultResponseTransformers(): bool
    {
        return (bool) $this->config->get(Config::USE_DEFAULT_RESPONSE_TRANSFORMERS, true);
    }

    protected function applyDefaultResponseTransformers(Config $config, SerializerInterface $serializer, $modelClass)
    {
        $config->set(Config::RESPONSE_TRANSFORMERS, [
            new ObjectTransformer($serializer, $modelClass),
            new CollectionObjectTransformer($serializer, $modelClass)
        ]);
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace CCT\Kong;
6
7		use Assert\Assert;
8		use CCT\Kong\EventListener\DeserializeExtraFieldsSubscriber;
9		use CCT\Kong\Exception\InvalidParameterException;
10		use CCT\Kong\Helper\ObjectConstructor;
11		use CCT\Kong\Http\Request\ApiRequest;
12		use CCT\Kong\Http\Request\ConsumerRequest;
13		use CCT\Kong\Http\Request\CertificateRequest;
14		use CCT\Kong\Http\Request\KongRequest;
15		use CCT\Kong\Http\Request\PluginRequest;
16		use CCT\Kong\Http\Request\SNIRequest;
17		use CCT\Kong\Http\Request\StatusRequest;
18		use CCT\Kong\Http\RequestInterface;
19		use CCT\Kong\Model\Api;
20		use CCT\Kong\Model\Consumer;
21		use CCT\Kong\Model\Info;
		0 ignored issues – show Bug introduced 2018-03-16 22:33 UTC by Report Bug Copy Issue Report The type `CCT\Kong\Model\Info` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
22		use CCT\Kong\Model\Kong;
23		use CCT\Kong\Model\Plugin;
24		use CCT\Kong\Model\SNI;
25		use CCT\Kong\Model\Status;
26		use CCT\Kong\Serializer\Handler\BooleanToStringHandler;
27		use CCT\Kong\Serializer\Handler\TimestampDatetimeHandler;
28		use CCT\Kong\Serializer\SerializerBuilder;
29		use CCT\Kong\Transformer\Response\CollectionObjectTransformer;
30		use CCT\Kong\Transformer\Response\ObjectTransformer;
31		use CCT\Kong\Model\Certificate;
32		use GuzzleHttp\Client as GuzzleClient;
33		use JMS\Serializer\SerializerInterface;
34
35		class Client
36		{
37		/**
38		* @var GuzzleClient
39		*/
40		protected $client;
41
42		/**
43		* @var Config
44		*/
45		protected $config;
46
47		/**
48		* @var bool
49		*/
50		protected $defaultConfig = true;
51
52		/**
53		* @var SerializerInterface
54		*/
55		protected static $serializer;
56
57	7	public function __construct(Config $config, bool $defaultConfig = true)
58		{
59	7	Assert::that($config->all())->keyExists(Config::ENDPOINT);
60
61	7	$this->defaultConfig = $defaultConfig;
62	7	$this->config = $config;
63	7	$this->client = new GuzzleClient([
64	7	'base_uri' => $config->get(Config::ENDPOINT)
65		]);
66
67	7	if ($defaultConfig) {
68	7	$this->applyDefaults();
69		}
70	7	}
71
72		/**
73		* @return KongRequest
74		*/
75	1	public function kong(): KongRequest
76		{
77	1	$config = clone $this->config;
78	1	$modelClass = $config->get('kong.model.class', Kong::class);
79
80	1	if ($this->isDefaultConfig()) {
81	1	$config->set(Config::OBJECT_CONSTRUCTOR, new ObjectConstructor());
82	1	$config->set(Config::EVENT_SUBSCRIBERS, [
83	1	new DeserializeExtraFieldsSubscriber([
84	1	$modelClass => [
85		'tagline',
86		'lua_version',
87		'hostname',
88		'version',
89		]
90		]),
91		]);
92		}
93
94	1	$serializer = $this->buildSerializer($config);
95	1	if ($this->shouldUseDefaultResponseTransformers()) {
96	1	$this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
97		}
98
99	1	return $this->createRequestInstance(KongRequest::class, $serializer, $config);
100		}
101
102		/**
103		* @return StatusRequest
104		*/
105		public function status(): StatusRequest
106		{
107		$config = clone $this->config;
108		$modelClass = $config->get('status.model.class', Status::class);
109
110		$serializer = $this->getBuiltSerializer($config);
111		if ($this->shouldUseDefaultResponseTransformers()) {
112		$this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
113		}
114
115		return $this->createRequestInstance(StatusRequest::class, $serializer, $config);
116		}
117
118		/**
119		* @return ApiRequest
120		*/
121	1	public function apis(): ApiRequest
122		{
123	1	$config = clone $this->config;
124	1	$modelClass = $config->get('api.model.class', Api::class);
125
126	1	$serializer = $this->getBuiltSerializer($config);
127	1	if ($this->shouldUseDefaultResponseTransformers()) {
128	1	$this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
129		}
130
131	1	return $this->createRequestInstance(ApiRequest::class, $serializer, $config);
132		}
133
134		/**
135		* @return ConsumerRequest
136		*/
137	1	public function consumers(): ConsumerRequest
138		{
139	1	$config = clone $this->config;
140	1	$modelClass = $config->get('consumer.model.class', Consumer::class);
141
142	1	$serializer = $this->getBuiltSerializer($config);
143	1	if ($this->shouldUseDefaultResponseTransformers()) {
144	1	$this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
145		}
146
147	1	return $this->createRequestInstance(ConsumerRequest::class, $serializer, $config);
148		}
149
150		/**
151		* @return PluginRequest
152		*/
153	1	public function plugins(): PluginRequest
154		{
155	1	$config = clone $this->config;
156	1	$modelClass = $config->get('plugin.model.class', Plugin::class);
157
158	1	$serializer = $this->getBuiltSerializer($config);
159	1	if ($this->shouldUseDefaultResponseTransformers()) {
160	1	$this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
161		}
162
163	1	return $this->createRequestInstance(PluginRequest::class, $serializer, $config);
164		}
165
166		/**
167		* @return CertificateRequest
168		*/
169	1	public function certificates(): CertificateRequest
170		{
171	1	$config = clone $this->config;
172	1	$modelClass = $config->get('certificate.model.class', Certificate::class);
173
174	1	$serializer = $this->getBuiltSerializer($config);
175	1	if ($this->shouldUseDefaultResponseTransformers()) {
176	1	$this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
177		}
178
179	1	return $this->createRequestInstance(CertificateRequest::class, $serializer, $config);
180		}
181
182		/**
183		* @return SNIRequest
184		*/
185	1	public function snis(): SNIRequest
186		{
187	1	$config = clone $this->config;
188	1	$modelClass = $config->get('sni.model.class', SNI::class);
189
190	1	$serializer = $this->getBuiltSerializer($config);
191	1	if ($this->shouldUseDefaultResponseTransformers()) {
192	1	$this->applyDefaultResponseTransformers($config, $serializer, $modelClass);
193		}
194
195	1	return $this->createRequestInstance(SNIRequest::class, $serializer, $config);
196		}
197
198		public function enableDefaultConfig()
199		{
200		$this->defaultConfig = true;
201		}
202
203		public function disableDefaultConfig()
204		{
205		$this->defaultConfig = false;
206		}
207
208	1	public function isDefaultConfig(): bool
209		{
210	1	return $this->defaultConfig;
211		}
212
213	7	protected function applyDefaults()
214		{
215	7	$this->config->set(Config::METADATA_DIRS, [
216		[
217	7	'dir' => __DIR__ . '/Resources/metadata',
218		'namespacePrefix' => 'CCT\\Kong\\Model',
219		]
220		]);
221
222	7	$this->config->set(Config::USE_DEFAULT_RESPONSE_TRANSFORMERS, true);
223	7	$this->config->set(Config::SERIALIZATION_HANDLERS, [
224	7	new BooleanToStringHandler(),
225	7	new TimestampDatetimeHandler()
226		]);
227	7	}
228
229		public function clearDefaults()
230		{
231		$this->config->remove(Config::METADATA_DIRS);
232		$this->config->remove(Config::DEBUG);
233		$this->config->remove(Config::EVENT_SUBSCRIBERS);
234		$this->config->remove(Config::SERIALIZATION_HANDLERS);
235		$this->config->remove(Config::OBJECT_CONSTRUCTOR);
236		$this->config->remove(Config::USE_DEFAULT_RESPONSE_TRANSFORMERS);
237		}
238
239	2	protected function buildSerializer(Config $config)
240		{
241	2	return SerializerBuilder::createByConfig($config)
242	2	->configureDefaults()
243	2	->build()
244		;
245		}
246
247	5	protected function getBuiltSerializer(Config $config)
248		{
249	5	if (null === static::$serializer) {
250	1	static::$serializer = $this->buildSerializer($config);
251		}
252
253	5	return static::$serializer;
254		}
255
256	6	protected function createRequestInstance($class, SerializerInterface $serializer, Config $config)
257		{
258	6	$reflectionClass = new \ReflectionClass($class);
259
260	6	if (!$reflectionClass->implementsInterface(RequestInterface::class)) {
261		throw new InvalidParameterException(sprintf(
262		'The class must be an instance of %s',
263		RequestInterface::class
264		));
265		}
266
267	6	return $reflectionClass->newInstance(
268	6	$this->client,
269	6	$serializer,
270	6	$config
271		);
272		}
273
274		/**
275		* Should use the default response transformers?
276		*
277		* @return bool
278		*/
279	6	protected function shouldUseDefaultResponseTransformers(): bool
280		{
281	6	return (bool) $this->config->get(Config::USE_DEFAULT_RESPONSE_TRANSFORMERS, true);
282		}
283
284	6	protected function applyDefaultResponseTransformers(Config $config, SerializerInterface $serializer, $modelClass)
285		{
286	6	$config->set(Config::RESPONSE_TRANSFORMERS, [
287	6	new ObjectTransformer($serializer, $modelClass),
288	6	new CollectionObjectTransformer($serializer, $modelClass)
289		]);
290	6	}
291		}
292

cct-marketing / kong-php-sdk

Client::buildSerializer() A last analyzed 2018-04-04 14:38 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Client::buildSerializer() A
last analyzed 2018-04-04 14:38 UTC