ArinaSystems\JsonResponse\JsonResponse

Complexity

Total Complexity

25

Size/Duplication

Total Lines	217
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	json()	0	25	6
A	error()	0	6	1
A	status()	0	9	2
A	options()	0	12	3
A	attributes()	0	12	3
A	setOptions()	0	10	2
A	setAttributes()	0	9	2
A	build()	0	12	2
A	structure()	0	10	2
A	instance()	0	4	1

<?php

namespace ArinaSystems\JsonResponse;

use Exception;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Response;

class JsonResponse
{
    /**
     * @var \ArinaSystems\JsonResponse\Status
     */
    protected $status;

    /**
     * @var \ArinaSystems\JsonResponse\Option
     */
    protected $options;

    /**
     * @var \ArinaSystems\JsonResponse\Attribute
     */
    protected $attributes;

    /**
     * Create a new instance.
     *
     * @param  \ArinaSystems\JsonResponse\Option|array|string $options
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct(Option $options, Attribute $attributes, Status $status)
    {
        $this->options = $options;
        $this->status = $status;
        $this->attributes = $attributes;
    }

    /**
     * Return json response.
     *
     * @param  string|array                    $status
     * @param  array                           $attributes
     * @param  array                           $options
     * @return \Illuminate\Http\JsonResponse
     */
    public function json($status = null, array $attributes = [], array $options = [])
    {
        if (is_array($status)) {
            extract($status);
        }

        if ($options) {

The expression $options of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->options($options);
        }

        if ($attributes) {

The expression $attributes of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->attributes($attributes);
        }

        if (!is_null($status) && is_string($status)) {
            $this->status($status);
        }

        return Response::json(
            $this->build($this->attributes('exception', false)),
            $this->attributes('http_code', 200),
            $this->attributes('headers', []),
            $this->options('encoding_options')
        );
    }

    /**
     * Return json response with error.
     *
     * @param  \Throwable                      $exception
     * @param  string|array                    $status
     * @param  array                           $attributes
     * @param  array                           $options
     * @return \Illuminate\Http\JsonResponse
     */
    public function error($exception, $status = null, array $attributes = [], array $options = [])
    {
        $this->setAttributes('exception', $exception);

        return $this->json($status, $attributes, $options);
    }

    /**
     * Retrieve/Set json response status.
     *
     * @param  string                                   $status
     * @return \ArinaSystems\JsonResponse\Status|self
     */
    public function status(string $status = null)
    {
        if (is_string($status)) {
            throw_if(!$this->status->has($status), new Exception("The \"{$status}\" response state does not exist"));

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

            return $this->status->call($status, $this);
        }

        return $this->status;
    }

    /**
     * Retrieve/Set json response options.
     *
     * @param  string|array|null                         $key
     * @param  mixed|null                                $default
     * @return \ArinaSystems\JsonResponse\Option|mixed
     */
    public function options($key = null, $default = null)
    {
        if (is_array($key)) {
            return $this->setOptions($key);
        }

        if (!is_null($key)) {
            return $this->options->get($key, $default);
        }

        return $this->options ?? $default;
    }

    /**
     * Retrieve/Set json response attributes.
     *
     * @param  string|array|null                            $key
     * @param  mixed|null                                   $default
     * @return \ArinaSystems\JsonResponse\Attribute|mixed
     */
    public function attributes($key = null, $default = null)
    {
        if (is_array($key)) {
            return $this->setAttributes($key);
        }

        if (is_string($key)) {
            return $this->attributes->get($key, $default);
        }

        return $this->attributes ?? $default;
    }

    /**
     * Set json response options.
     *
     * @param  \ArinaSystems\JsonResponse\Option|array|string $options
     * @param  null|mixed                                     $value
     * @return self
     */
    public function setOptions($options, $value = null)
    {
        if (is_a($options, Option::class)) {
            $this->options = $options;

It seems like $options can also be of type array or string. However, the property $options is declared as type object<ArinaSystems\JsonResponse\Option>. Maybe add an additional type check?

        }

        $this->options->set($options, $value);

        return $this;
    }

    /**
     * Set json response attributes.
     *
     * @param  \ArinaSystems\JsonResponse\Attribute|array|string $attributes
     * @param  null|mixed                                        $value
     * @return self
     */
    public function setAttributes($attributes, $value = null)
    {
        if (is_a($attributes, Attribute::class)) {
            $this->attributes = $attributes;

It seems like $attributes can also be of type array or string. However, the property $attributes is declared as type object<ArinaSystems\JsonResponse\Attribute>. Maybe add an additional type check?

        }

        $this->attributes->set($attributes, $value);
        return $this;
    }

    /**
     * Get the json response data array.
     *
     * @param  bool    $error
     * @return array
     */
    protected function build(bool $error = false): array
    {
        $structure = $this->structure($error);

        if (!$this->options('debug')) {
            unset($structure['debug']);
        }

        $response = array_intersect_key($this->attributes->all('value'), $structure);

        return $response;
    }

    /**
     * Get response data structure.
     *
     * @param  bool    $error
     * @return array
     */
    public function structure(bool $error = false): array
    {
        $structure = Arr::where($this->attributes->all('on-' . ($error ? 'error' : 'response')), function ($onStructure) {
            return boolval($onStructure);
        });

        $structure = array_keys($structure);

        return array_flip($structure);
    }

    /**
     * Get the current instance of json response builder.
     *
     * @return ArinaSystems\JsonResponse\JsonResponse
     */
    public function instance(): self
    {
        return $this;
    }
}