RetrofitBuilder::createDefaultProxyFactory() - Code Metrics - Inspection of "Retrofit 3" - tebru/retrofit-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#72)

by Nate

created 2017-09-12 22:31 UTC

RetrofitBuilder::createDefaultProxyFactory() B

↳ Parent: RetrofitBuilder

Complexity

Conditions	6
Paths	5

Size

Total Lines	69
Code Lines	51

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	69
rs	8.56
c	0
b	0
f	0
cc	6
eloc	51
nc	5
nop	0

How to fix Long Method

<?php
/*
 * Copyright (c) Nate Brunette.
 * Distributed under the MIT License (http://opensource.org/licenses/MIT)
 */

declare(strict_types=1);

namespace Tebru\Retrofit;

use Doctrine\Common\Annotations\AnnotationReader;
use LogicException;
use PhpParser\BuilderFactory;
use PhpParser\PrettyPrinter\Standard;
use Symfony\Component\Cache\Simple\ArrayCache;
use Symfony\Component\Cache\Simple\ChainCache;
use Symfony\Component\Cache\Simple\FilesystemCache;
use Tebru\AnnotationReader\AnnotationReaderAdapter;
use Tebru\Retrofit\Annotation as Annot;
use Tebru\Retrofit\Finder\ServiceResolver;
use Tebru\Retrofit\Internal\AnnotationHandler as AnnotHandler;
use Tebru\Retrofit\Internal\AnnotationProcessor;
use Tebru\Retrofit\Internal\CallAdapter\CallAdapterProvider;
use Tebru\Retrofit\Internal\Converter\ConverterProvider;
use Tebru\Retrofit\Internal\CallAdapter\DefaultCallAdapterFactory;
use Tebru\Retrofit\Internal\DefaultProxyFactory;
use Tebru\Retrofit\Internal\Filesystem;
use Tebru\Retrofit\Internal\ServiceMethod\ServiceMethodFactory;
use Tebru\Retrofit\Internal\Converter\DefaultConverterFactory;

/**
 * Class RetrofitBuilder
 *
 * @author Nate Brunette <[email protected]>
 */
class RetrofitBuilder
{
    /**
     * Directory to store generated proxy clients
     *
     * @var string
     */
    private $cacheDir;

    /**
     * A Retrofit http client used to make requests
     *
     * @var HttpClient
     */
    private $httpClient;

    /**
     * The service's base url
     *
     * @var string
     */
    private $baseUrl;

    /**
     * An array of factories used to create [@see CallAdapter]s
     *
     * @var CallAdapterFactory[]
     */
    private $callAdapterFactories = [];

    /**
     * An array of factories used to convert types
     *
     * @var ConverterFactory[]
     */
    private $converterFactories = [];

    /**
     * An array of factories used to create [@see Proxy] objects
     *
     * @var ProxyFactory[]
     */
    private $proxyFactories = [];

    /**
     * An array of handlers used to modify the request based on an annotation
     *
     * @var AnnotationHandler[]
     */
    private $annotationHandlers = [];

    /**
     * If we should cache the proxies
     *
     * @var bool
     */
    private $shouldCache = false;

    /**
     * Set the cache directory
     *
     * @param string $cacheDir
     * @return $this
     */
    public function setCacheDir(string $cacheDir): RetrofitBuilder
    {
        $this->cacheDir = $cacheDir;

        return $this;
    }

    /**
     * Set the Retrofit http client
     *
     * @param HttpClient $client
     * @return $this
     */
    public function setHttpClient(HttpClient $client): RetrofitBuilder
    {
        $this->httpClient = $client;

        return $this;
    }

    /**
     * Set the base url
     *
     * @param string $baseUrl
     * @return RetrofitBuilder
     */
    public function setBaseUrl(string $baseUrl): RetrofitBuilder
    {
        $this->baseUrl = $baseUrl;

        return $this;
    }

    /**
     * Add a [@see CallAdapterFactory]
     *
     * @param CallAdapterFactory $callAdapterFactory
     * @return RetrofitBuilder
     */
    public function addCallAdapterFactory(CallAdapterFactory $callAdapterFactory): RetrofitBuilder
    {
        $this->callAdapterFactories[] = $callAdapterFactory;

        return $this;
    }

    /**
     * Add a [@see ConverterFactory]
     *
     * @param ConverterFactory $converterFactory
     * @return RetrofitBuilder
     */
    public function addConverterFactory(ConverterFactory $converterFactory): RetrofitBuilder
    {
        $this->converterFactories[] = $converterFactory;

        return $this;
    }

    /**
     * Add a [@see ProxyFactory]
     *
     * @param ProxyFactory $proxyFactory
     * @return RetrofitBuilder
     */
    public function addProxyFactory(ProxyFactory $proxyFactory): RetrofitBuilder
    {
        $this->proxyFactories[] = $proxyFactory;

        return $this;
    }

    /**
     * Add an [@see AnnotationHandler]
     *
     * @param string $annotationName
     * @param AnnotationHandler $annotationHandler
     * @return RetrofitBuilder
     */
    public function addAnnotationHandler(string $annotationName, AnnotationHandler $annotationHandler): RetrofitBuilder
    {
        $this->annotationHandlers[$annotationName] = $annotationHandler;

        return $this;
    }

    /**
     * Enable caching proxies
     *
     * @param bool $enable
     * @return RetrofitBuilder
     */
    public function enableCache(bool $enable = true): RetrofitBuilder
    {
        $this->shouldCache = $enable;

        return $this;
    }

    /**
     * Build a retrofit instance
     *
     * @return Retrofit
     * @throws \Doctrine\Common\Annotations\AnnotationException
     * @throws \LogicException
     */
    public function build(): Retrofit
    {
        $defaultProxyFactory = $this->createDefaultProxyFactory();
        foreach ($this->proxyFactories as $proxyFactory) {
            if ($proxyFactory instanceof DefaultProxyFactoryAware) {
                $proxyFactory->setDefaultProxyFactory($defaultProxyFactory);
            }
        }
        $this->proxyFactories[] = $defaultProxyFactory;

        return new Retrofit(new ServiceResolver(), $this->proxyFactories);
    }

    /**
     * Creates the default proxy factory and all necessary dependencies
     *
     * @return ProxyFactory
     * @throws \Doctrine\Common\Annotations\AnnotationException
     * @throws \LogicException
     */
    private function createDefaultProxyFactory(): ProxyFactory
    {
        if ($this->baseUrl === null) {
            throw new LogicException('Retrofit: Base URL must be provided');
        }

        if ($this->httpClient === null) {
            throw new LogicException('Retrofit: Must set http client to make requests');
        }

        if ($this->shouldCache && $this->cacheDir === null) {
            throw new LogicException('Retrofit: If caching is enabled, must specify cache directory');
        }

        $this->cacheDir .= '/retrofit';

        // add defaults to any user registered
        $this->callAdapterFactories[] = new DefaultCallAdapterFactory();
        $this->converterFactories[] = new DefaultConverterFactory();

        $cache = $this->shouldCache
            ? new ChainCache([new ArrayCache(), new FilesystemCache()])
            : new ArrayCache();

        $httpRequestHandler = new AnnotHandler\HttpRequestAnnotHandler();
        $annotationHandlers = array_merge(
            [
                Annot\Body::class => new AnnotHandler\BodyAnnotHandler(),
                Annot\DELETE::class => $httpRequestHandler,
                Annot\Field::class => new AnnotHandler\FieldAnnotHandler(),
                Annot\FieldMap::class => new AnnotHandler\FieldMapAnnotHandler(),
                Annot\GET::class => $httpRequestHandler,
                Annot\HEAD::class => $httpRequestHandler,
                Annot\Header::class => new AnnotHandler\HeaderAnnotHandler(),
                Annot\HeaderMap::class => new AnnotHandler\HeaderMapAnnotHandler(),
                Annot\Headers::class => new AnnotHandler\HeadersAnnotHandler(),
                Annot\OPTIONS::class => $httpRequestHandler,
                Annot\Part::class => new AnnotHandler\PartAnnotHandler(),
                Annot\PartMap::class => new AnnotHandler\PartMapAnnotHandler(),
                Annot\PATCH::class => $httpRequestHandler,
                Annot\Path::class => new AnnotHandler\PathAnnotHandler(),
                Annot\POST::class => $httpRequestHandler,
                Annot\PUT::class => $httpRequestHandler,
                Annot\Query::class => new AnnotHandler\QueryAnnotHandler(),
                Annot\QueryMap::class => new AnnotHandler\QueryMapAnnotHandler(),
                Annot\QueryName::class => new AnnotHandler\QueryNameAnnotHandler(),
                Annot\REQUEST::class => $httpRequestHandler,
                Annot\Url::class => new AnnotHandler\UrlAnnotHandler(),
            ],
            $this->annotationHandlers
        );
        $serviceMethodFactory = new ServiceMethodFactory(
            new AnnotationProcessor($annotationHandlers),
            new CallAdapterProvider($this->callAdapterFactories),
            new ConverterProvider($this->converterFactories),
            new AnnotationReaderAdapter(new AnnotationReader(), $cache),
            $this->baseUrl
        );

        return new DefaultProxyFactory(
            new BuilderFactory(),
            new Standard(),
            $serviceMethodFactory,
            $this->httpClient,
            new Filesystem(),
            $this->shouldCache,
            $this->cacheDir
        );
    }
}


1			<?php
2			/*
3			* Copyright (c) Nate Brunette.
4			* Distributed under the MIT License (http://opensource.org/licenses/MIT)
5			*/
6
7			declare(strict_types=1);
8
9			namespace Tebru\Retrofit;
10
11			use Doctrine\Common\Annotations\AnnotationReader;
12			use LogicException;
13			use PhpParser\BuilderFactory;
14			use PhpParser\PrettyPrinter\Standard;
15			use Symfony\Component\Cache\Simple\ArrayCache;
16			use Symfony\Component\Cache\Simple\ChainCache;
17			use Symfony\Component\Cache\Simple\FilesystemCache;
18			use Tebru\AnnotationReader\AnnotationReaderAdapter;
19			use Tebru\Retrofit\Annotation as Annot;
20			use Tebru\Retrofit\Finder\ServiceResolver;
21			use Tebru\Retrofit\Internal\AnnotationHandler as AnnotHandler;
22			use Tebru\Retrofit\Internal\AnnotationProcessor;
23			use Tebru\Retrofit\Internal\CallAdapter\CallAdapterProvider;
24			use Tebru\Retrofit\Internal\Converter\ConverterProvider;
25			use Tebru\Retrofit\Internal\CallAdapter\DefaultCallAdapterFactory;
26			use Tebru\Retrofit\Internal\DefaultProxyFactory;
27			use Tebru\Retrofit\Internal\Filesystem;
28			use Tebru\Retrofit\Internal\ServiceMethod\ServiceMethodFactory;
29			use Tebru\Retrofit\Internal\Converter\DefaultConverterFactory;
30
31			/**
32			* Class RetrofitBuilder
33			*
34			* @author Nate Brunette <[email protected]>
35			*/
36			class RetrofitBuilder
37			{
38			/**
39			* Directory to store generated proxy clients
40			*
41			* @var string
42			*/
43			private $cacheDir;
44
45			/**
46			* A Retrofit http client used to make requests
47			*
48			* @var HttpClient
49			*/
50			private $httpClient;
51
52			/**
53			* The service's base url
54			*
55			* @var string
56			*/
57			private $baseUrl;
58
59			/**
60			* An array of factories used to create [@see CallAdapter]s
61			*
62			* @var CallAdapterFactory[]
63			*/
64			private $callAdapterFactories = [];
65
66			/**
67			* An array of factories used to convert types
68			*
69			* @var ConverterFactory[]
70			*/
71			private $converterFactories = [];
72
73			/**
74			* An array of factories used to create [@see Proxy] objects
75			*
76			* @var ProxyFactory[]
77			*/
78			private $proxyFactories = [];
79
80			/**
81			* An array of handlers used to modify the request based on an annotation
82			*
83			* @var AnnotationHandler[]
84			*/
85			private $annotationHandlers = [];
86
87			/**
88			* If we should cache the proxies
89			*
90			* @var bool
91			*/
92			private $shouldCache = false;
93
94			/**
95			* Set the cache directory
96			*
97			* @param string $cacheDir
98			* @return $this
99			*/
100			public function setCacheDir(string $cacheDir): RetrofitBuilder
101			{
102			$this->cacheDir = $cacheDir;
103
104			return $this;
105			}
106
107			/**
108			* Set the Retrofit http client
109			*
110			* @param HttpClient $client
111			* @return $this
112			*/
113			public function setHttpClient(HttpClient $client): RetrofitBuilder
114			{
115			$this->httpClient = $client;
116
117			return $this;
118			}
119
120			/**
121			* Set the base url
122			*
123			* @param string $baseUrl
124			* @return RetrofitBuilder
125			*/
126			public function setBaseUrl(string $baseUrl): RetrofitBuilder
127			{
128			$this->baseUrl = $baseUrl;
129
130			return $this;
131			}
132
133			/**
134			* Add a [@see CallAdapterFactory]
135			*
136			* @param CallAdapterFactory $callAdapterFactory
137			* @return RetrofitBuilder
138			*/
139			public function addCallAdapterFactory(CallAdapterFactory $callAdapterFactory): RetrofitBuilder
140			{
141			$this->callAdapterFactories[] = $callAdapterFactory;
142
143			return $this;
144			}
145
146			/**
147			* Add a [@see ConverterFactory]
148			*
149			* @param ConverterFactory $converterFactory
150			* @return RetrofitBuilder
151			*/
152			public function addConverterFactory(ConverterFactory $converterFactory): RetrofitBuilder
153			{
154			$this->converterFactories[] = $converterFactory;
155
156			return $this;
157			}
158
159			/**
160			* Add a [@see ProxyFactory]
161			*
162			* @param ProxyFactory $proxyFactory
163			* @return RetrofitBuilder
164			*/
165			public function addProxyFactory(ProxyFactory $proxyFactory): RetrofitBuilder
166			{
167			$this->proxyFactories[] = $proxyFactory;
168
169			return $this;
170			}
171
172			/**
173			* Add an [@see AnnotationHandler]
174			*
175			* @param string $annotationName
176			* @param AnnotationHandler $annotationHandler
177			* @return RetrofitBuilder
178			*/
179			public function addAnnotationHandler(string $annotationName, AnnotationHandler $annotationHandler): RetrofitBuilder
180			{
181			$this->annotationHandlers[$annotationName] = $annotationHandler;
182
183			return $this;
184			}
185
186			/**
187			* Enable caching proxies
188			*
189			* @param bool $enable
190			* @return RetrofitBuilder
191			*/
192			public function enableCache(bool $enable = true): RetrofitBuilder
193			{
194			$this->shouldCache = $enable;
195
196			return $this;
197			}
198
199			/**
200			* Build a retrofit instance
201			*
202			* @return Retrofit
203			* @throws \Doctrine\Common\Annotations\AnnotationException
204			* @throws \LogicException
205			*/
206			public function build(): Retrofit
207			{
208			$defaultProxyFactory = $this->createDefaultProxyFactory();
209			foreach ($this->proxyFactories as $proxyFactory) {
210			if ($proxyFactory instanceof DefaultProxyFactoryAware) {
211			$proxyFactory->setDefaultProxyFactory($defaultProxyFactory);
212			}
213			}
214			$this->proxyFactories[] = $defaultProxyFactory;
215
216			return new Retrofit(new ServiceResolver(), $this->proxyFactories);
217			}
218
219			/**
220			* Creates the default proxy factory and all necessary dependencies
221			*
222			* @return ProxyFactory
223			* @throws \Doctrine\Common\Annotations\AnnotationException
224			* @throws \LogicException
225			*/
226			private function createDefaultProxyFactory(): ProxyFactory
227			{
228			if ($this->baseUrl === null) {
229			throw new LogicException('Retrofit: Base URL must be provided');
230			}
231
232			if ($this->httpClient === null) {
233			throw new LogicException('Retrofit: Must set http client to make requests');
234			}
235
236			if ($this->shouldCache && $this->cacheDir === null) {
237			throw new LogicException('Retrofit: If caching is enabled, must specify cache directory');
238			}
239
240			$this->cacheDir .= '/retrofit';
241
242			// add defaults to any user registered
243			$this->callAdapterFactories[] = new DefaultCallAdapterFactory();
244			$this->converterFactories[] = new DefaultConverterFactory();
245
246			$cache = $this->shouldCache
247			? new ChainCache([new ArrayCache(), new FilesystemCache()])
248			: new ArrayCache();
249
250			$httpRequestHandler = new AnnotHandler\HttpRequestAnnotHandler();
251			$annotationHandlers = array_merge(
252			[
253			Annot\Body::class => new AnnotHandler\BodyAnnotHandler(),
254			Annot\DELETE::class => $httpRequestHandler,
255			Annot\Field::class => new AnnotHandler\FieldAnnotHandler(),
256			Annot\FieldMap::class => new AnnotHandler\FieldMapAnnotHandler(),
257			Annot\GET::class => $httpRequestHandler,
258			Annot\HEAD::class => $httpRequestHandler,
259			Annot\Header::class => new AnnotHandler\HeaderAnnotHandler(),
260			Annot\HeaderMap::class => new AnnotHandler\HeaderMapAnnotHandler(),
261			Annot\Headers::class => new AnnotHandler\HeadersAnnotHandler(),
262			Annot\OPTIONS::class => $httpRequestHandler,
263			Annot\Part::class => new AnnotHandler\PartAnnotHandler(),
264			Annot\PartMap::class => new AnnotHandler\PartMapAnnotHandler(),
265			Annot\PATCH::class => $httpRequestHandler,
266			Annot\Path::class => new AnnotHandler\PathAnnotHandler(),
267			Annot\POST::class => $httpRequestHandler,
268			Annot\PUT::class => $httpRequestHandler,
269			Annot\Query::class => new AnnotHandler\QueryAnnotHandler(),
270			Annot\QueryMap::class => new AnnotHandler\QueryMapAnnotHandler(),
271			Annot\QueryName::class => new AnnotHandler\QueryNameAnnotHandler(),
272			Annot\REQUEST::class => $httpRequestHandler,
273			Annot\Url::class => new AnnotHandler\UrlAnnotHandler(),
274			],
275			$this->annotationHandlers
276			);
277			$serviceMethodFactory = new ServiceMethodFactory(
278			new AnnotationProcessor($annotationHandlers),
279			new CallAdapterProvider($this->callAdapterFactories),
280			new ConverterProvider($this->converterFactories),
281			new AnnotationReaderAdapter(new AnnotationReader(), $cache),
282			$this->baseUrl
283			);
284
285			return new DefaultProxyFactory(
286			new BuilderFactory(),
287			new Standard(),
288			$serviceMethodFactory,
289			$this->httpClient,
290			new Filesystem(),
291			$this->shouldCache,
292			$this->cacheDir
293			);
294			}
295			}
296

tebru / retrofit-php

Pull Request — master (#72)

RetrofitBuilder::createDefaultProxyFactory() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like