Client::delete() - Code Metrics - Inspection of "Add support for Laravel 6.0" - sebdesign/artisan-cloudflare - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 007d53...6e7711 )

by Sébastien
created 2019-09-02 18:03 UTC
Client::delete() A

↳ Parent: Client
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	2
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	4
rs	10
<?php

namespace Sebdesign\ArtisanCloudflare;

use GuzzleHttp\Promise;
use Psr\Log\LoggerInterface;
use Illuminate\Support\Collection;
use GuzzleHttp\Client as GuzzleClient;
use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\RequestException;

class Client
{
    /**
     * Base URI.
     */
    const BASE_URI = 'https://api.cloudflare.com/client/v4/';

    /**
     * @var \GuzzleHttp\Client
     */
    protected $client;

    /**
     * @var \Psr\Log\LoggerInterface
     */
    protected $logger;

    /**
     * Constructor.
     *
     * @param \GuzzleHttp\Client       $client
     * @param \Psr\Log\LoggerInterface $logger
     */
    public function __construct(GuzzleClient $client, LoggerInterface $logger)
    {
        $this->client = $client;
        $this->logger = $logger;
    }

    /**
     * Delete all the given zones with their parameters.
     *
     * All the requests are asynchronous and sent concurrently.
     *
     * The promise waits until all the promises have been resolved or rejected
     * and returns the results of each request.
     *
     * @param  \Illuminate\Support\Collection<string,\Sebdesign\ArtisanCloudflare\Zone>  $zones
     * @return \Illuminate\Support\Collection<string,\Sebdesign\ArtisanCloudflare\Zone>
     */
    public function purge($zones)
    {
        return $zones->map(function (Zone $zone, $identifier) {
            return $this->delete($identifier, $zone);
        })->pipe(function ($promises) {
            return $this->settle($promises);
        })->wait();
    }

    /**
     * @param  string                             $identifier
     * @param  \Sebdesign\ArtisanCloudflare\Zone  $zone
     * @return \GuzzleHttp\Promise\PromiseInterface
     */
    protected function delete($identifier, Zone $zone)
    {
        return $this->client->deleteAsync("zones/{$identifier}/purge_cache", [
            \GuzzleHttp\RequestOptions::JSON => $zone,
        ]);
    }

    /**
     * Returns a promise that is fulfilled when all of the provided promises have
     * been fulfilled or rejected.
     *
     * The returned promise is fulfilled with a collection of results.
     *
     * @param  \Illuminate\Support\Collection<string,\GuzzleHttp\Promise\PromiseInterface> $promises
     * @return \GuzzleHttp\Promise\PromiseInterface
     */
    protected function settle(Collection $promises)
    {
        $results = new Collection();

        return Promise\each(
        return /** @scrutinizer ignore-deprecated */ Promise\each(
            $promises->getIterator(),
            /** @scrutinizer ignore-type */ $promises->getIterator(),
            $this->onFulfilled($results),
        return /** @scrutinizer ignore-call */ Promise\each(
            $this->onRejected($results)
        )->then(function () use ($results) {
            return $results;
        });
    }

    /**
     * Put the body of the fulfilled promise into the results.
     *
     * @param  \Illuminate\Support\Collection<string,\Sebdesign\ArtisanCloudflare\Zone> $results
     * @return \Closure
     */
    protected function onFulfilled($results)
    {
        /**
         * @param  \Psr\Http\Message\ResponseInterface $response
         * @param  string                              $identifier
         * @return \Illuminate\Support\Collection<string,\Sebdesign\ArtisanCloudflare\Zone>
         */
        return function ($response, $identifier) use ($results) {
            return $results->put($identifier, $this->getBody($response));
        };
    }

    /**
     * Handle the rejected promise and put the errors into the results.
     *
     * @param  \Illuminate\Support\Collection<string,\Sebdesign\ArtisanCloudflare\Zone> $results
     * @return \Closure
     */
    protected function onRejected($results)
    {
        /**
         * @param  \GuzzleHttp\Exception\RequestException $reason
         * @param  string                                 $identifier
         * @return \Illuminate\Support\Collection<string,\Sebdesign\ArtisanCloudflare\Zone>
         */
        return function ($reason, $identifier) use ($results) {
            $this->logger->error($reason->getMessage(), [
                'zone' => $identifier,
                'exception' => $reason,
            ]);

            return $results->put($identifier, $this->handleException($reason));
        };
    }

    /**
     * Transform a request exception into a result object.
     *
     * @param  \GuzzleHttp\Exception\RequestException $e
     * @return \Sebdesign\ArtisanCloudflare\Zone
     */
    protected function handleException(RequestException $e)
    {
        if ($e->hasResponse()) {
            /** @var \Psr\Http\Message\ResponseInterface $response */
            $response = $e->getResponse();

            if ($e instanceof ClientException) {
                return $this->getBody($response);
            }

            $message = (string) $response->getBody();
        } else {
            $message = $e->getMessage();
        }

        return new Zone([
            'success' => false,
            'errors' => [
                [
                    'code' => $e->getCode(),
                    'message' => $message,
                ],
            ],
        ]);
    }

    /**
     * Transform the response body into a result object.
     *
     * @param  \Psr\Http\Message\ResponseInterface $response
     * @return \Sebdesign\ArtisanCloudflare\Zone
     */
    protected function getBody(ResponseInterface $response)
    {
        return new Zone(json_decode($response->getBody(), true));
    }

    /**
     * Get the Guzzle client.
     *
     * @return \GuzzleHttp\ClientInterface
     */
    public function getClient()
    {
        return $this->client;
    }
}

sebdesign / artisan-cloudflare

Push — master ( 007d53...6e7711 )

Client::delete() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
