SDK::append() - Code Metrics - Inspection of "Updating README" - SuitcasePHP/builder - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8212b9...355016 )

by Stephen

created 2020-03-25 13:35 UTC

SDK::append() A

↳ Parent: SDK

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	5
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Suitcase\Builder;

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Response;
use Suitcase\Builder\ParameterBag;
use GuzzleHttp\Exception\GuzzleException;
use Tightenco\Collect\Support\Collection;
use Suitcase\Builder\Exceptions\MethodNotAllowed;
use Suitcase\Builder\Exceptions\ResourceException;
use Suitcase\Builder\Exceptions\UnsupportedScheme;
use Suitcase\Builder\Exceptions\ResourceNotRegistered;

final class SDK
{
    protected array $resource;

    protected string $scheme;

    protected string $host;

    protected string $path;

    protected string $appends;

    protected array $url;

    protected Client $client;

    protected ParameterBag $query;

    protected Collection $resources;

    protected array $allowedSchemes = [
        'http',
        'https'
    ];

    private function __construct(string $url)
    {
        $parts = array_merge(parse_url($url));

        $this->scheme = isset($parts['scheme']) ? $this->allowedScheme($parts['scheme']) : '';
        $this->host = $parts['host'] ?? '';
        $this->path = $parts['path'] ?? '/';
        $this->client = new Client();
        $this->query = new ParameterBag();
        $this->resources = new Collection();
    }

    public static function make(string $url): self
    {
        return new self($url);
    }

    public function add(string $name, array $options = []): void
    {
        $resource = [
            'name' => $name,
            'endpoint' => array_key_exists('endpoint', $options) ? $options['endpoint'] : $name,
            'allows' => array_key_exists('allows', $options) ? $options['allows'] : [
                'get', 'find', 'create', 'update', 'delete'
            ],
        ];

        $this->resources->push($resource);
    }

    public function getScheme(): string
    {
        return $this->scheme;
    }

    public function getHost(): string
    {
        return $this->host;
    }

    public function getPath(): string
    {
        return $this->path;
    }

    public function getResources(): Collection
    {
        return $this->resources;
    }

    public function getQuery(): ParameterBag
    {
        return $this->query;
    }

    public function getClient(): Client
    {
        return $this->client;
    }

    public function use(string $resource): self
    {
        if (! $this->resources->pluck('name')->contains($resource)) {
            throw new ResourceNotRegistered("No resource registered for: {$resource}");
        }

        $this->resource = $this->resources->where('name', $resource)->first();

        return $this;
    }

    public function getResource():? array
    {
        return $this->resource;
    }

    public function get(string $method = 'GET')
    {
        if (! $this->checkAbility('get')) {
            throw new MethodNotAllowed("Method get is not available on this resource");
        }

        return $this->call($method, $this->resource['endpoint']);
    }

    public function find($identifier, string $method = 'GET')
    {
        if (! $this->checkAbility('find')) {
            throw new MethodNotAllowed("Method find is not available on this resource");
        }

        return $this->call($method, $this->resource['endpoint'] . '/' . (string) $identifier);
    }

    public function create(array $data)
    {
        if (! $this->checkAbility('create')) {
            throw new MethodNotAllowed("Method create is not available on this resource");
        }

        return $this->call('POST', $this->resource['endpoint'], $data);
    }

    public function update($identifier, array $data, string $method = 'PUT')
    {
        if (! $this->checkAbility('update')) {
            throw new MethodNotAllowed("Method update is not available on this resource");
        }

        return $this->call($method, $this->resource['endpoint'] . '/' . (string) $identifier, $data);
    }

    public function delete($identifier, string $method = 'DELETE')
    {
        if (! $this->checkAbility('delete')) {
            throw new MethodNotAllowed("Method delete is not available on this resource");
        }

        return $this->call($method, $this->resource['endpoint'] . '/' . (string) $identifier);
    }

    public function append(...$appends): self
    {
        $this->appends = implode('/', $appends);

        return $this;
    }

    /**
     * @codeCoverageIgnore
     */
    protected function checkAbility(string $method)
    {
        return collect($this->resource['allows'])->contains($method);
    }

    /**
     * @codeCoverageIgnore
     */
    protected function call(string $method, string $endpoint, array $data = []): \Psr\Http\Message\ResponseInterface
    {
        $uri = $this->buildUri($endpoint);

        try {
            $response = $this->client->request(
                $method,
                $uri,
                $data
            );
        } catch (GuzzleException $e) {
            throw new ResourceException($e->getMessage());
        }

        return $response;
    }

    /**
     * @codeCoverageIgnore
     */
    protected function buildUri(string $endpoint): string
    {
        $uri = '';

        if ($this->getScheme() !== '') {
            $uri .= $this->getScheme() . '://';
        }

        if ($this->getHost() !== '') {
            $uri .= $this->getHost();
        }

        $uri .= rtrim($this->getPath(), '/');

        $uri .= '/' . rtrim($endpoint, '/');

        $uri .= '/' . rtrim($this->appends, '/');

        return $uri;
    }

    /**
     * @codeCoverageIgnore
     */
    protected function allowedScheme(string $scheme): string
    {
        $scheme = strtolower($scheme);

        if (! in_array($scheme, $this->allowedSchemes)) {
            throw new UnsupportedScheme(
                "The scheme `{$scheme}` isn't valid. It should be either `http` or `https`."
            );
        }

        return $scheme;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Suitcase\Builder;
6
7			use GuzzleHttp\Client;
8			use GuzzleHttp\Psr7\Response;
9			use Suitcase\Builder\ParameterBag;
10			use GuzzleHttp\Exception\GuzzleException;
11			use Tightenco\Collect\Support\Collection;
12			use Suitcase\Builder\Exceptions\MethodNotAllowed;
13			use Suitcase\Builder\Exceptions\ResourceException;
14			use Suitcase\Builder\Exceptions\UnsupportedScheme;
15			use Suitcase\Builder\Exceptions\ResourceNotRegistered;
16
17			final class SDK
18			{
19			protected array $resource;
20
21			protected string $scheme;
22
23			protected string $host;
24
25			protected string $path;
26
27			protected string $appends;
28
29			protected array $url;
30
31			protected Client $client;
32
33			protected ParameterBag $query;
34
35			protected Collection $resources;
36
37			protected array $allowedSchemes = [
38			'http',
39			'https'
40			];
41
42			private function __construct(string $url)
43			{
44			$parts = array_merge(parse_url($url));
45
46			$this->scheme = isset($parts['scheme']) ? $this->allowedScheme($parts['scheme']) : '';
47			$this->host = $parts['host'] ?? '';
48			$this->path = $parts['path'] ?? '/';
49			$this->client = new Client();
50			$this->query = new ParameterBag();
51			$this->resources = new Collection();
52			}
53
54			public static function make(string $url): self
55			{
56			return new self($url);
57			}
58
59			public function add(string $name, array $options = []): void
60			{
61			$resource = [
62			'name' => $name,
63			'endpoint' => array_key_exists('endpoint', $options) ? $options['endpoint'] : $name,
64			'allows' => array_key_exists('allows', $options) ? $options['allows'] : [
65			'get', 'find', 'create', 'update', 'delete'
66			],
67			];
68
69			$this->resources->push($resource);
70			}
71
72			public function getScheme(): string
73			{
74			return $this->scheme;
75			}
76
77			public function getHost(): string
78			{
79			return $this->host;
80			}
81
82			public function getPath(): string
83			{
84			return $this->path;
85			}
86
87			public function getResources(): Collection
88			{
89			return $this->resources;
90			}
91
92			public function getQuery(): ParameterBag
93			{
94			return $this->query;
95			}
96
97			public function getClient(): Client
98			{
99			return $this->client;
100			}
101
102			public function use(string $resource): self
103			{
104			if (! $this->resources->pluck('name')->contains($resource)) {
105			throw new ResourceNotRegistered("No resource registered for: {$resource}");
106			}
107
108			$this->resource = $this->resources->where('name', $resource)->first();
109
110			return $this;
111			}
112
113			public function getResource():? array
114			{
115			return $this->resource;
116			}
117
118			public function get(string $method = 'GET')
119			{
120			if (! $this->checkAbility('get')) {
121			throw new MethodNotAllowed("Method get is not available on this resource");
122			}
123
124			return $this->call($method, $this->resource['endpoint']);
125			}
126
127			public function find($identifier, string $method = 'GET')
128			{
129			if (! $this->checkAbility('find')) {
130			throw new MethodNotAllowed("Method find is not available on this resource");
131			}
132
133			return $this->call($method, $this->resource['endpoint'] . '/' . (string) $identifier);
134			}
135
136			public function create(array $data)
137			{
138			if (! $this->checkAbility('create')) {
139			throw new MethodNotAllowed("Method create is not available on this resource");
140			}
141
142			return $this->call('POST', $this->resource['endpoint'], $data);
143			}
144
145			public function update($identifier, array $data, string $method = 'PUT')
146			{
147			if (! $this->checkAbility('update')) {
148			throw new MethodNotAllowed("Method update is not available on this resource");
149			}
150
151			return $this->call($method, $this->resource['endpoint'] . '/' . (string) $identifier, $data);
152			}
153
154			public function delete($identifier, string $method = 'DELETE')
155			{
156			if (! $this->checkAbility('delete')) {
157			throw new MethodNotAllowed("Method delete is not available on this resource");
158			}
159
160			return $this->call($method, $this->resource['endpoint'] . '/' . (string) $identifier);
161			}
162
163			public function append(...$appends): self
164			{
165			$this->appends = implode('/', $appends);
166
167			return $this;
168			}
169
170			/**
171			* @codeCoverageIgnore
172			*/
173			protected function checkAbility(string $method)
174			{
175			return collect($this->resource['allows'])->contains($method);
176			}
177
178			/**
179			* @codeCoverageIgnore
180			*/
181			protected function call(string $method, string $endpoint, array $data = []): \Psr\Http\Message\ResponseInterface
182			{
183			$uri = $this->buildUri($endpoint);
184
185			try {
186			$response = $this->client->request(
187			$method,
188			$uri,
189			$data
190			);
191			} catch (GuzzleException $e) {
192			throw new ResourceException($e->getMessage());
193			}
194
195			return $response;
196			}
197
198			/**
199			* @codeCoverageIgnore
200			*/
201			protected function buildUri(string $endpoint): string
202			{
203			$uri = '';
204
205			if ($this->getScheme() !== '') {
206			$uri .= $this->getScheme() . '://';
207			}
208
209			if ($this->getHost() !== '') {
210			$uri .= $this->getHost();
211			}
212
213			$uri .= rtrim($this->getPath(), '/');
214
215			$uri .= '/' . rtrim($endpoint, '/');
216
217			$uri .= '/' . rtrim($this->appends, '/');
218
219			return $uri;
220			}
221
222			/**
223			* @codeCoverageIgnore
224			*/
225			protected function allowedScheme(string $scheme): string
226			{
227			$scheme = strtolower($scheme);
228
229			if (! in_array($scheme, $this->allowedSchemes)) {
230			throw new UnsupportedScheme(
231			"The scheme `{$scheme}` isn't valid. It should be either `http` or `https`."
232			);
233			}
234
235			return $scheme;
236			}
237			}
238

SuitcasePHP / builder

Push — master ( 8212b9...355016 )

SDK::append() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like