PhpGuard\Curl\Curl

Complexity

Total Complexity

19

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Test Coverage

Coverage

73.32%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getRequestModifierPipeline()	0	3	1
A	get()	0	3	1
A	getCurlRequestFactory()	0	3	1
A	__construct()	0	9	1
A	execute()	0	8	1
A	post()	0	3	1
A	getCurlResponseFactory()	0	3	1
A	prepare()	0	17	2
A	put()	0	3	1
A	delete()	0	3	1
B	multi()	0	38	7
A	patch()	0	3	1

<?php
/**
 * php-guard/curl <https://github.com/php-guard/curl>
 * Copyright (C) ${YEAR} by Alexandre Le Borgne <alexandre.leborgne.83@gmail.com>.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace PhpGuard\Curl;

use PhpGuard\Curl\RequestModifier\FileRequestModifier;
use PhpGuard\Curl\RequestModifier\PlainTextRequestModifier;

class Curl
{
    private $requestModifierPipeline;
    private $curlResponseFactory;
    private $curlRequestFactory;

    public function __construct(?string $host = null)
    {
        $this->requestModifierPipeline = new RequestModifierPipeline();
        $this->curlResponseFactory = new CurlResponseFactory();
        $this->curlRequestFactory = new CurlRequestFactory($this, $host);

        $this->requestModifierPipeline
            ->pipe(new FileRequestModifier())
            ->pipe(new PlainTextRequestModifier());
    }

    /**
     * @param string            $url
     * @param null|array|string $query
     * @param array             $headers
     *
     * @return CurlRequest
     */
    public function get(string $url, $query = null, array $headers = [])
    {
        return $this->curlRequestFactory->create('GET', $url, null, $query, $headers);
    }

    public function post(string $url, $data = null, $query = null, array $headers = [])
    {
        return $this->curlRequestFactory->create('POST', $url, $data, $query, $headers);
    }

    public function put(string $url, $data = null, $query = null, array $headers = [])
    {
        return $this->curlRequestFactory->create('PUT', $url, $data, $query, $headers);
    }

    public function patch(string $url, $data = null, $query = null, array $headers = [])
    {
        return $this->curlRequestFactory->create('PATCH', $url, $data, $query, $headers);
    }

    public function delete(string $url, $data = null, $query = null, array $headers = [])
    {
        return $this->curlRequestFactory->create('DELETE', $url, $data, $query, $headers);
    }

    /**
     * @param CurlRequest[] $requests
     * @param array         $options  Définit les options pour le gestionnaire multiple cURL
     *
     * @return CurlResponse[]
     *
     * @throws CurlError
     */
    public function multi(array $requests, array $options = [])
    {
        $mh = curl_multi_init();

        foreach ($options as $key => $value) {
            curl_multi_setopt($mh, $key, $value);
        }

        $chs = [];
        foreach ($requests as $request) {
            $ch = $this->prepare($request);
            $chs[] = $ch;
            curl_multi_add_handle($mh, $ch);
        }

        $active = null;

        do {
            $code = curl_multi_exec($mh, $active);
            curl_multi_select($mh);
        } while ($active > 0);

        try {
            if ($code > CURLM_OK) {
                throw new CurlError(curl_multi_strerror($code), $code);
            }

            $responses = [];
            foreach ($chs as $ch) {
                $responses[] = $this->curlResponseFactory->create($ch, curl_multi_getcontent($ch));
            }

            return $responses;
        } finally {
            foreach ($chs as $ch) {
                curl_multi_remove_handle($mh, $ch);
            }
            curl_multi_close($mh);
        }
    }

    /**
     * @param CurlRequest $request
     *
     * @return CurlResponse
     *
     * @throws CurlError
     */
    public function execute(CurlRequest $request): CurlResponse
    {
        $ch = $this->prepare($request);

        try {
            return $this->curlResponseFactory->create($ch, curl_exec($ch));
        } finally {
            curl_close($ch);
        }
    }

    /**
     * @param CurlRequest $request
     *
     * @return resource
     */
    protected function prepare(CurlRequest $request)
    {
        $request = $this->requestModifierPipeline->process($request);

        // create curl resource
        $ch = curl_init();

        curl_setopt($ch, CURLOPT_URL, $request->getUrl());
        curl_setopt($ch, CURLOPT_POSTFIELDS, $request->getData());
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $request->getMethod());
        curl_setopt($ch, CURLOPT_HTTPHEADER, $request->getHeaders()->toHttp());

        foreach ($request->getCurlOptions()->all() as $key => $value) {
            curl_setopt($ch, $key, $value);
        }

        return $ch;
    }

    /**
     * @return RequestModifierPipeline
     */
    public function getRequestModifierPipeline(): RequestModifierPipeline
    {
        return $this->requestModifierPipeline;
    }

    /**
     * @return CurlRequestFactory
     */
    public function getCurlRequestFactory(): CurlRequestFactory
    {
        return $this->curlRequestFactory;
    }

    /**
     * @return CurlResponseFactory
     */
    public function getCurlResponseFactory(): CurlResponseFactory
    {
        return $this->curlResponseFactory;
    }
}