Corundum - Code Metrics - Inspection of "Update .scrutinizer.yml" - bavix/sdk - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 33386c...9439f2 )

by Бабичев
created 2017-12-26 07:49 UTC
Corundum B

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	507
Duplicated Lines	11.05 %
Test Coverage

Coverage
Importance

Changes
Metric	Value
wmc	41
dl	56
loc	507
ccs	0
cts	175
cp	0
rs	8.2769
c	0
b	0
f	0
20 Methods

Rating	Name	Duplication	Size	Complexity
A	authorize()	0	21	2
A	value()	0	8	2
A	getResults()	0	3	1
A	multipart()	0	20	3
A	__construct()	0	8	1
A	apiSend()	0	9	2
A	setTokens()	0	3	1
B	uploadSlice()	0	27	2
A	getBody()	0	4	1
B	upload()	0	24	3
A	getTokens()	0	3	1
B	apiRequest()	0	55	6
A	refreshToken()	0	10	1
A	getCode()	0	8	2
A	fake()	0	8	2
A	update()	23	23	2
B	tokenUpdate()	0	23	4
A	getToken()	0	10	2
A	verify()	0	8	1
B	delete()	25	25	2
How to fix Duplicated Code Complexity

<?php

namespace Bavix\SDK;

use Bavix\Exceptions\Invalid;
use Bavix\Helpers\Arr;
use Bavix\Helpers\File;
use Bavix\Helpers\JSON;
use Bavix\Helpers\Str;
use Bavix\Slice\Slice;
use Carbon\Carbon;
use GuzzleHttp\Client;
use Psr\Http\Message\ResponseInterface;

class Corundum
{

    /**
     * @var array
     */
    protected $tokens = [];

    /**
     * @var string
     */
    protected $urlToken;

    /**
     * @var string
     */
    protected $basic;

    /**
     * @var Slice
     */
    protected $slice;

    /**
     * @var Slice
     */
    protected $fake;

    /**
     * @var ResponseInterface
     */
    protected $response;

    /**
     * @var Slice
     */
    protected $results;

    /**
     * Corundum constructor.
     *
     * @param Slice $slice
     */
    public function __construct(Slice $slice)
    {
        $clientId = $slice->getRequired('app.client_id');
        $secret   = $slice->getRequired('app.client_secret');

        $this->slice    = $slice;
        $this->basic    = \base64_encode($clientId . ':' . $secret);
        $this->basic    = \base64_encode(/** @scrutinizer ignore-type */ $clientId . ':' . $secret);
        $this->urlToken = $slice->getRequired('app.url.token');
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
    }

    /**
     * @return array
     */
    public function getTokens(): array
    {
        return $this->tokens;
    }

    /**
     * @param array $tokens
     */
    public function setTokens(array $tokens)
    {
        $this->tokens = $tokens;
    }

    /**
     * @return Slice
     */
    protected function fake(): Slice
    {
        if (!$this->fake)
        {
            $this->fake = new Slice([]);
        }

        return $this->fake;
    }

    /**
     * @return string
     *
     * @throws \RuntimeException
     */
    public function getBody(): string
    {
        return $this->response->getBody()
            ->getContents();
    }

    /**
     * @return Slice|null
     */
    public function getResults()
    {
        return $this->results;
    }

    /**
     * @return int|null
     */
    public function getCode()
    {
        if ($this->response)
        {
            return $this->response->getStatusCode();
        }

        return null;
    }

    /**
     * @param mixed $value
     *
     * @return mixed
     */
    protected function value($value)
    {
        if (Str::first($value) === '@')
        {
            return fopen(Str::withoutFirst($value), 'rb');
        }

        return $value;
    }

    /**
     * @param array $params
     *
     * @return array
     */
    protected function multipart(array $params): array
    {
        $results = [];

        foreach ($params as $key => $value)
        {
            $content = [
                'name'     => $key,
                'contents' => $this->value($value)
            ];

            if (\is_resource($content['contents']))
            {
                $content['filename'] = basename($value);
            }

            $results[] = $content;
        }

        return $results;
    }

    /**
     * @param Slice $options
     *
     * @return Slice|null
     *
     * @throws Invalid
     */
    protected function apiRequest(Slice $options)
    {
        $allow404 = $options->getData('allow404', false);
        $type     = $options->getData('token_type', 'Basic');
        $method   = $options->getData('method', 'POST');
        $token    = $options->getData('access_token', $this->basic);
        $url      = $options->getData('url', $this->urlToken);
        $params   = $options->getData('params', []);
        $headers  = $options->getData('headers', []);

        // headers
        $headers['Authorization'] = $type . ' ' . $token;
        $headers['Authorization'] = /** @scrutinizer ignore-type */ $type . ' ' . $token;

        $client = new Client([
            'debug'       => $this->slice->getData('debug', false),
            'http_errors' => false
        ]);

        $data = [
            'headers'   => $headers,
            'multipart' => $this->multipart($params),
        ];

        $this->response = $client->request(
            Str::upp($method),
            Str::upp(/** @scrutinizer ignore-type */ $method),
            $url,
            $data
        );

        $this->results = null;

        $response = JSON::decode(
            $this->getBody()
        );

        if (JSON::errorNone())
        {
            $this->results = new Slice($response);
        }

        $code = $this->getCode();

        if ($allow404 && $code === 404)
        {
            return $this->getResults();
        }

        if ($code > 199 && $code < 300)
        {
            return $this->getResults();
        }

        throw new Invalid(
            'Error: ' . $this->response->getReasonPhrase(),
            $code
        );
    }

    /**
     * @param string $user
     * @param array  $params
     *
     * @return Slice
     *
     * @throws Invalid
     */
    protected function authorize(string $user, array $params = []): Slice
    {
        $grantType = $this->slice->getData('grant_type', 'password');
        $userData  = $this->slice->getSlice('users.' . $user);
        $defaults  = [
            'username'   => $userData->getRequired('username'),
            'password'   => $userData->getRequired('password'),
            'grant_type' => $grantType,
        ];

        $response = $this->apiRequest(new Slice([
            'params' => Arr::merge($defaults, $params)
        ]));

        if ($response)
        {
            $response->expires = Carbon::now()
                ->addSeconds($response->expires_in);
        }

        return $response;
    }

    /**
     * @param string $user
     * @param string $scope
     *
     * @return Slice
     *
     * @throws Invalid
     */
    protected function getToken(string $user, string $scope = ''): Slice
    {
        if (!isset($this->tokens[$user]))
        {
            $this->tokens[$user] = $this->authorize($user, [
                'scope' => $scope
            ]);
        }

        return $this->tokens[$user];
    }

    /**
     * @param string $user
     *
     * @return Slice
     *
     * @throws Invalid
     */
    protected function refreshToken(string $user): Slice
    {
        /**
         * @var $token Slice
         */
        $token = $this->tokens[$user];

        return $this->tokens[$user] = $this->authorize($user, [
            'grant_type'    => 'refresh_token',
            'refresh_token' => $token->getRequired('refresh_token'),
        ]);
    }

    /**
     * @param string $user
     * @param string $file
     * @param Slice  $options
     *
     * @return Slice
     *
     * @throws Invalid
     */
    public function upload(string $user, string $file, Slice $options = null): Slice
    {
        if (!File::isFile($file))
        {
            throw new \Bavix\Exceptions\NotFound\Path('File not found!');
        }

        if (!$options)
        {
            $options = $this->fake();
        }

        $token = $this->getToken(
            $user,
            $options->getData('scope', '')
            /** @scrutinizer ignore-type */ $options->getData('scope', '')
        );

        return $this->apiSend(
            $this->uploadSlice($token, $options, $file),
            function () use ($user, $options, $file) {
                return $this->uploadSlice(
                    $this->tokenUpdate($user, $options),
                    $options,
                    $file
                );
            }
        );
    }

    /**
     * @param string     $user
     * @param string     $name
     * @param Slice|null $options
     *
     * @return Slice
     */
    public function update(string $user, string $name, Slice $options = null): Slice

    {
        if (!$options)
        {
            $options = $this->fake();
        }

        $token = $this->getToken(
            $user,
            $options->getData('scope', '')
            /** @scrutinizer ignore-type */ $options->getData('scope', '')
        );

        $options->allow404 = true;

        $urlUpload    = $this->slice->getRequired('app.url.upload');
        $options->url = Path::slash($urlUpload) . $name;
        $options->url = Path::slash(/** @scrutinizer ignore-type */ $urlUpload) . $name;

        return $this->apiSend(
            $this->uploadSlice($token, $options),
            function () use ($user, $options) {
                return $this->uploadSlice(
                    $this->tokenUpdate($user, $options),
                    $options
                );
            }
        );
    }

    /**
     * @param string     $user
     * @param string     $name
     * @param Slice|null $options
     *
     * @return Slice|null
     */
    public function delete(string $user, string $name, Slice $options = null)

    {
        if (!$options)
        {
            $options = $this->fake();
        }

        $token = $this->getToken(
            $user,
            $options->getData('scope', '')
            /** @scrutinizer ignore-type */ $options->getData('scope', '')
        );

        $options->allow404 = true;

        $urlUpload    = $this->slice->getRequired('app.url.upload');
        $options->url = Path::slash($urlUpload) . $name;
        $options->url = Path::slash(/** @scrutinizer ignore-type */ $urlUpload) . $name;

        $options->method = 'delete';

        return $this->apiSend(
            $this->uploadSlice($token, $options),
            function () use ($user, $options) {
                return $this->uploadSlice(
                    $this->tokenUpdate($user, $options),
                    $options
                );
            }
        );
    }

    /**
     * @param Slice    $slice
     * @param callable $callback
     *
     * @return Slice|null
     */
    protected function apiSend(Slice $slice, callable $callback)
    {
        try
        {
            return $this->apiRequest($slice);
        }
        catch (\Throwable $throwable)
        {
            return $this->apiRequest($callback());
        }
    }

    /**
     * @param Slice  $token
     * @param Slice  $options
     * @param string $file
     *
     * @return Slice
     */
    protected function uploadSlice(Slice $token, Slice $options, string $file = null): Slice
    {
        $params = $options->getData('params', []);

        if ($file)
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
        {
            $params = Arr::merge($params, [
                'file' => '@' . \ltrim($file, '@')
            ]);
        }

        return new Slice([
            'token_type'   => $token->getRequired('token_type'),
            'access_token' => $token->getRequired('access_token'),
            'method'       => $options->getData('method', 'post'),
            'url'          => $options->getData(
                'url',
                $this->slice->getRequired('app.url.upload')
            ),

            'allow404' => $options->getData('allow404', false),

            'headers' => Arr::merge($options->getData('headers', []), [
                'Accept' => 'application/json'
            ]),

            'params' => $params
        ]);
    }

    /**
     * @param Slice $token
     *
     * @return Slice
     *
     * @throws Invalid
     */
    protected function verify(Slice $token): Slice
    {
        return $this->apiRequest(new Slice([
            'token_type'   => $token->getRequired('token_type'),
            'access_token' => $token->getRequired('access_token'),
            'url'          => $this->slice->getRequired('app.url.verify'),
            'headers'      => [
                'Accept' => 'application/json'
            ]
        ]));
    }

    /**
     * @param string $user
     * @param Slice  $slice
     *
     * @return Slice
     *
     * @throws Invalid
     */
    protected function tokenUpdate(string $user, Slice $slice): Slice
    {
        try
        {
            $token  = $this->refreshToken($user);
            $verify = $this->verify($token);

            if (!$verify || !$verify->getRequired('verify'))
            {
                throw new Invalid('The token isn\'t verified');
            }
        }
        catch (Invalid $invalid)
        {
            $this->tokens[$user] = null;

            $token = $this->getToken(
                $user,
                $slice->getData('scope', '')
                /** @scrutinizer ignore-type */ $slice->getData('scope', '')
            );
        }

        return $token;
    }

}

bavix / sdk

Push — master ( 33386c...9439f2 )

Corundum B

Complexity

Size/Duplication

Test Coverage

Importance

20 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Duplication Side-by-Side

Filter issues like
