Carpediem\JSend\JSend

Complexity

Total Complexity

56

Size/Duplication

Total Lines	495
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	0	Features	0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	filterStatus()	0	9	2
A	__construct()	0	6	1
A	filterData()	0	16	4
A	filterError()	0	8	2
B	validateErrorMessage()	0	11	5
A	validateErrorCode()	0	12	3
A	getStatus()	0	4	1
A	getData()	0	4	1
A	getErrorMessage()	0	4	1
A	getErrorCode()	0	4	1
A	isSuccess()	0	4	1
A	isFail()	0	4	1
A	isError()	0	4	1
A	__toString()	0	4	1
A	jsonSerialize()	0	4	1
B	toArray()	0	18	5
A	__debugInfo()	0	4	1
A	send()	0	12	2
A	filterHeaders()	0	9	2
A	validateHeaderName()	0	8	2
A	validateHeaderValue()	0	10	3
A	withStatus()	0	8	2
A	withData()	0	9	2
A	withError()	0	8	4
A	success()	0	4	1
A	fail()	0	4	1
A	error()	0	4	1
A	createFromString()	0	12	2
A	__set_state()	0	4	1
A	createFromArray()	0	7	1

<?php

namespace Carpediem\JSend;

use InvalidArgumentException;
use JsonSerializable;
use UnexpectedValueException;

/**
 * A Immutable Value Object Class to represent a JSend object
 */
class JSend implements JsonSerializable
{
    const STATUS_SUCCESS = 'success';

    const STATUS_ERROR = 'error';

    const STATUS_FAIL = 'fail';

    /**
     * JSend status
     *
     * @var string
     */
    protected $status;

    /**
     * JSend Data
     *
     * @var array
     */
    protected $data;

    /**
     * JSend Error Message
     *
     * @var string
     */
    protected $errorMessage;

    /**
     * JSend Error Code
     * @var int|null
     */
    protected $errorCode;

    /**
     * New Instance
     *
     * @param string $status
     * @param mixed  $data
     * @param string $errorMessage
     * @param int    $errorCode
     */
    public function __construct($status, $data = null, $errorMessage = null, $errorCode = null)
    {
        $this->status = $this->filterStatus($status);
        $this->data = $this->filterData($data);
        list($this->errorMessage, $this->errorCode) = $this->filterError($errorMessage, $errorCode);
    }

    /**
     * Filter and Validate the JSend Status
     *
     * @param string $status
     *
     * @throws UnexpectedValueException If the status value does not conform to JSend Spec.
     *
     * @return string
     */
    protected function filterStatus($status)
    {
        $res = [self::STATUS_SUCCESS => 1, self::STATUS_ERROR => 1, self::STATUS_FAIL => 1];
        if (isset($res[$status])) {
            return $status;
        }

        throw new UnexpectedValueException('The given status does not conform to Jsend specification');
    }

    /**
     * Filter and Validate the JSend Data
     *
     * @param mixed $data The data can be
     *                    <ul>
     *                    <li>An Array
     *                    <li>A JsonSerializable object
     *                    <li>null
     *                    </ul>
     *
     * @throws UnexpectedValueException If the input does not conform to one of the valid type
     *
     * @return array
     */
    protected function filterData($data)
    {
        if (null === $data) {
            return [];
        }

        if ($data instanceof JsonSerializable) {
            return $data->jsonSerialize();
        }

        if (is_array($data)) {
            return $data;
        }

        throw new UnexpectedValueException('The data must be an array, a JsonSerializable object or null');
    }

    /**
     * Filter and Validate the JSend Error properties
     *
     * @param string $errorMessage
     * @param int    $errorCode
     */
    protected function filterError($errorMessage, $errorCode)
    {
        if (self::STATUS_ERROR !== $this->status) {
            return;
        }

        return [$this->validateErrorMessage($errorMessage), $this->validateErrorCode($errorCode)];
    }

    /**
     * Validate a string
     *
     * @param mixed $str
     *
     * @throws UnexpectedValueException If the data value is not a empty string
     *
     * @return string
     */
    protected function validateErrorMessage($str)
    {
        if (is_string($str) || (is_object($str) && method_exists($str, '__toString'))) {
            $str = (string) $str;
            if ('' !== $str) {
                return $str;
            }
        }

        throw new UnexpectedValueException('The error message must be a non empty string');
    }

    /**
     * Validate a integer
     *
     * @param mixed $int
     *
     * @throws UnexpectedValueException If the data value is not an integer
     *
     * @return int
     */
    protected function validateErrorCode($int)
    {
        if (null === $int) {
            return $int;
        }

        if (false !== ($res = filter_var($int, FILTER_VALIDATE_INT))) {
            return $res;
        }

        throw new UnexpectedValueException('The error code must be a integer or null');
    }

    /**
     * Returns the status
     *
     * @return string
     */
    public function getStatus()
    {
        return $this->status;
    }

    /**
     * Returns the data
     *
     * @return array
     */
    public function getData()
    {
        return $this->data;
    }

    /**
     * Returns the error message
     *
     * @return string
     */
    public function getErrorMessage()
    {
        return $this->errorMessage;
    }

    /**
     * Returns the error code
     *
     * @return int|null
     */
    public function getErrorCode()
    {
        return $this->errorCode;
    }

    /**
     * Returns whether the status is success
     *
     * @return bool
     */
    public function isSuccess()
    {
        return self::STATUS_SUCCESS === $this->status;
    }

    /**
     * Returns whether the status is fail
     *
     * @return bool
     */
    public function isFail()
    {
        return self::STATUS_FAIL === $this->status;
    }

    /**
     * Returns whether the status is error
     *
     * @return bool
     */
    public function isError()
    {
        return self::STATUS_ERROR === $this->status;
    }

    /**
     * @inheritdoc
     */
    public function __toString()
    {
        return json_encode($this, JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_HEX_AMP);
    }

    /**
     * @inheritdoc
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }

    /**
     * Retuns the array representation
     *
     * @return array
     */
    public function toArray()
    {
        $arr = ['status' => $this->status, 'data' => $this->data ?: null];
        if (self::STATUS_ERROR !== $this->status) {
            return $arr;
        }

        $arr['message'] = (string) $this->errorMessage;
        if (null !== $this->errorCode) {
            $arr['code'] = $this->errorCode;
        }

        if (null === $arr['data']) {
            unset($arr['data']);
        }

        return $arr;
    }

    /**
     * @inheritdoc
     */
    public function __debugInfo()
    {
        return $this->toArray();
    }

    /**
     * Returns the generated HTTP Response
     *
     * @param array $headers Optional headers to add to the response
     *
     * @return string
     */
    public function send(array $headers = [])
    {
        $body = $this->__toString();
        $headers = $this->filterHeaders(array_merge([
            'Content-Type' => 'application/json;charset=utf-8',
            'Content-Length' => strlen($body),
        ], $headers));
        foreach ($headers as $header) {
            header($header);
        }
        echo $body;
    }

    /**
     * Filter Submitted Headers
     *
     * @param array $headers a Collection of key/value headers
     *
     * @return array
     */
    protected function filterHeaders(array $headers)
    {
        $formattedHeaders = [];
        foreach ($headers as $name => $value) {
            $formattedHeaders[] = $this->validateHeaderName($name).': '.$this->validateHeaderValue($value);
        }

        return $formattedHeaders;
    }

    /**
     * Validate Header name
     *
     * @param string $name
     *
     * @throws InvalidArgumentException if the header name is invalid
     *
     * @return string
     */
    protected function validateHeaderName($name)
    {
        if (!preg_match('/^[a-zA-Z0-9\'`#$%&*+.^_|~!-]+$/', $name)) {
            throw new InvalidArgumentException('Invalid header name');
        }

        return $name;
    }

    /**
     * Validate Header value
     *
     * @param string $value
     *
     * @throws InvalidArgumentException if the header value is invalid
     *
     * @return string
     */
    protected function validateHeaderValue($value)
    {
        if (preg_match("#(?:(?:(?<!\r)\n)|(?:\r(?!\n))|(?:\r\n(?![ \t])))#", $value)
            || preg_match('/[^\x09\x0a\x0d\x20-\x7E\x80-\xFE]/', $value)
        ) {
            throw new InvalidArgumentException('Invalid header value');
        }

        return $value;
    }

    /**
     * Returns an instance with the specified status.
     *
     * This method MUST retain the state of the current instance, and return
     * an instance that contains the specified status.
     *
     * @param string $status The status to use with the new instance.
     *
     * @return static A new instance with the specified status.
     */
    public function withStatus($status)

This method seems to be duplicated in your project.

    {
        if ($status === $this->status) {
            return $this;
        }

        return new static($status, $this->data, $this->errorMessage, $this->errorCode);
    }

    /**
     * Returns an instance with the specified data.
     *
     * This method MUST retain the state of the current instance, and return
     * an instance that contains the specified data.
     *
     * @param mixed $data The data to use with the new instance.
     *
     * @return static A new instance with the specified data.
     */
    public function withData($data)

This method seems to be duplicated in your project.

    {
        $data = $this->filterData($data);
        if ($data === $this->data) {
            return $this;
        }

        return new static($this->status, $data, $this->errorMessage, $this->errorCode);
    }

    /**
     * Returns an instance with the specified error message and error code.
     *
     * This method MUST retain the state of the current instance, and return
     * an instance that contains the specified error message and error code.
     *
     * @param string   $errorMessage The error message to use with the new instance.
     * @param int|null $errorCode    The error code to use with the new instance.
     *
     * @return static A new instance with the specified status.
     */
    public function withError($errorMessage, $errorCode = null)
    {
        if ($this->isError() && $errorMessage === $this->errorMessage && $errorCode === $this->errorCode) {
            return $this;
        }

        return new static(static::STATUS_ERROR, $this->data, $errorMessage, $errorCode);
    }

    /**
     * Returns a successful JSend object with the specified data
     *
     * @param mixed $data The data to use with the new instance.
     *
     * @return static A new succesful instance with the specified data.
     */
    public static function success($data = null)
    {
        return new static(static::STATUS_SUCCESS, $data);
    }

    /**
     * Returns a failed JSend object with the specified data
     *
     * @param mixed $data The data to use with the new instance.
     *
     * @return static A new failed instance with the specified data.
     */
    public static function fail($data = null)
    {
        return new static(static::STATUS_FAIL, $data);
    }

    /**
     * Returns a error JSend object with the specified error message and error code.
     *
     * @param string   $errorMessage The error message to use with the new instance.
     * @param int|null $errorCode    The error code to use with the new instance.
     * @param array    $data         The optional data to use with the new instance.
     *
     * @return static A new failed instance with the specified data.
     */
    public static function error($errorMessage, $errorCode = null, $data = null)
    {
        return new static(static::STATUS_ERROR, $data, $errorMessage, $errorCode);
    }

    /**
     * Returns a new instance from a JSON string
     *
     * @param string $json    The string being decoded
     * @param int    $depth   User specified recursion depth.
     * @param int    $options Bitmask of JSON decode options
     *
     * @throws InvalidArgumentException If the string can not be decode
     *
     * @return static
     */
    public static function createFromString($json, $depth = 512, $options = 0)
    {
        $raw = json_decode($json, true, $depth, $options);
        if (JSON_ERROR_NONE !== json_last_error()) {
            throw new InvalidArgumentException(sprintf(
                'Unable to decode the submitted JSON string: %s',
                json_last_error_msg()
            ));
        }

        return static::createFromArray($raw);
    }

    /**
     * @inheritdoc
     */
    public static function __set_state(array $properties)
    {
        return static::createFromArray($properties);
    }

    /**
     * Returns a new instance from an array
     *
     * @param array $arr The array to build a new JSend object with
     *
     * @return static
     */
    public static function createFromArray(array $arr)
    {
        $defaultValues = ['status' => null, 'data' => null, 'message' => null, 'code' => null];
        $arr = array_replace($defaultValues, array_intersect_key($arr, $defaultValues));

        return new static($arr['status'], $arr['data'], $arr['message'], $arr['code']);
    }
}