Crummy\Phlack\Phlack

Complexity

Total Complexity

16

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	1	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	fromConfig()	0	4	1
A	send()	0	4	1
A	factory()	0	4	1
A	__construct()	0	16	4
A	toParameters()	0	12	4
A	getMessageBuilder()	0	8	2
A	getAttachmentBuilder()	0	8	2
A	getClient()	0	4	1

<?php

namespace Crummy\Phlack;

use Crummy\Phlack\Bridge\Guzzle\PhlackClient;
use Crummy\Phlack\Bridge\Guzzle\Response\MessageResponse;
use Crummy\Phlack\Common\Exception\UnexpectedTypeException;
use Guzzle\Common\Collection;
use JsonSerializable;

class Phlack extends Collection
{
    /**
     * Phlack Constructor.
     *
     * @param mixed $client
     *
     * @throws UnexpectedTypeException
     */
    public function __construct($client)
    {
        if (is_string($client) || is_array($client)) {
            $client = new PhlackClient($client);

It seems like $client defined by new \Crummy\Phlack\Bridge\Guzzle\PhlackClient($client) on line 23 can also be of type array; however, Crummy\Phlack\Bridge\Guzzle\PhlackClient::__construct() does only seem to accept string, maybe add an additional type check?

        } elseif (!$client instanceof PhlackClient) {
            throw new UnexpectedTypeException($client, ['string', 'array', 'Crummy\Phlack\Bridge\Guzzle\PhlackClient']);
        }

        parent::__construct([
            'client'   => $client,
            'builders' => [],
            'commands' => [
                'send' => 'Send',
            ],
        ]);
    }

    /**
     * Phlack Factory.
     *
     * @param array|string $config
     *
     * @return Phlack
     */
    public static function factory($config = [])
    {
        return new self(new PhlackClient($config));

It seems like $config defined by parameter $config on line 44 can also be of type array; however, Crummy\Phlack\Bridge\Guzzle\PhlackClient::__construct() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * @return Phlack
     */
    public static function fromConfig(array $config = [], array $defaults = [], array $required = [])
    {
        return new self(new PhlackClient($config));

$config is of type array, but the function expects a string.

    }

    /**
     * @param string|array|JsonSerializable $message
     *
     * @throws UnexpectedTypeException
     *
     * @return MessageResponse
     */
    public function send($message)
    {
        return $this['client']->getCommand($this['commands']['send'], $this->toParameters($message))->execute();
    }

    /**
     * @return Bridge\Guzzle\PhlackClient
     */
    public function getClient()
    {
        return $this['client'];
    }

    /**
     * @return Builder\MessageBuilder
     */
    public function getMessageBuilder()
    {
        if (!isset($this['builders']['message'])) {
            $this->setPath('builders/message', new Builder\MessageBuilder());
        }

        return $this['builders']['message'];
    }

    /**
     * @return Builder\AttachmentBuilder
     */
    public function getAttachmentBuilder()
    {
        if (!isset($this['builders']['attachment'])) {
            $this->setPath('builders/attachment', new Builder\AttachmentBuilder());
        }

        return $this['builders']['attachment'];
    }

    /**
     * @param mixed $message
     *
     * @throws UnexpectedTypeException
     *
     * @return array
     */
    private function toParameters($message)
    {
        if (is_string($message)) {
            return $this->getMessageBuilder()->setText($message)->create()->jsonSerialize();
        } elseif (is_array($message)) {
            return $message;
        } elseif ($message instanceof JsonSerializable) {
            return $message->jsonSerialize();
        }

        throw new UnexpectedTypeException($message, ['string', 'array', 'JsonSerializable']);
    }
}