Adlogix\ConfluenceClient\ClientBuilder

Complexity

Total Complexity

8

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	4	1
A	__construct()	0	9	2
A	build()	0	17	2
A	setSerializer()	0	4	1
A	setDebug()	0	5	1
A	buildDefaultSerializer()	0	7	1

<?php
/*
 * This file is part of the Adlogix package.
 *
 * (c) Allan Segebarth <allan@adlogix.eu>
 * (c) Jean-Jacques Courtens <jjc@adlogix.eu>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Adlogix\ConfluenceClient;

use Adlogix\ConfluenceClient\HttpClient\HttpClient;
use Adlogix\GuzzleAtlassianConnect\Middleware\ConnectMiddleware;
use Adlogix\GuzzleAtlassianConnect\Security\AuthenticationInterface;
use GuzzleHttp\HandlerStack;
use JMS\Serializer\SerializerBuilder;


/**
 * Class ClientBuilder
 * @package Adlogix\ConfluenceClient
 * @author  Cedric Michaux <cedric@adlogix.eu>
 */
class ClientBuilder
{

    /**
     * @var string
     */
    private $baseUri;

    /**
     * @var AuthenticationInterface
     */
    private $authentication;

    /**
     * @var SerializerInterface
     */
    private $serializer;

    /**
     * @var boolean
     */
    private $debug;


    /**
     * @param string                  $baseUri
     * @param AuthenticationInterface $authenticationMethod
     *
     * @return ClientBuilder
     */
    public static function create($baseUri, AuthenticationInterface $authenticationMethod)
    {
        return new static($baseUri, $authenticationMethod);
    }

    /**
     * ClientBuilder constructor.
     *
     * @param                                                        $baseUri
     * @param AuthenticationInterface                                $authentication
     */
    private function __construct($baseUri, AuthenticationInterface $authentication)
    {
        $this->authentication = $authentication;

        if (empty($baseUri)) {
            throw new \InvalidArgumentException("The baseUri cannot be empty");
        }
        $this->baseUri = $baseUri;
    }

    /**
     * @return Client
     */
    public function build()
    {
        $this->serializer = $this->serializer ?: $this->buildDefaultSerializer();
        $stack = HandlerStack::create();
        $stack->push(new ConnectMiddleware($this->authentication, $this->baseUri));
        

        return new Client(
            new HttpClient([
                'base_uri' => $this->baseUri,
                'handler' => $stack,
                'debug' => $this->debug
            ]),
            $this->serializer,
            $this->authentication

The call to Client::__construct() has too many arguments starting with $this->authentication.

        );
    }

    /**
     * @param SerializerInterface $serializer
     */
    public function setSerializer(SerializerInterface $serializer)
    {
        $this->serializer = $serializer;
    }


    /**
     * @param boolean $debug
     *
     * @return $this
     */
    public function setDebug($debug)
    {
        $this->debug = (bool)$debug;
        return $this;
    }

    private function buildDefaultSerializer()
    {
        return SerializerBuilder::create()
            ->addMetadataDir(__DIR__ . '/Resources/serializer', __NAMESPACE__)
            ->addDefaultHandlers()
            ->build();
    }
}