Saxulum\ElasticSearchQueryBuilder\QueryBuilder

Complexity

Total Complexity

23

Size/Duplication

Total Lines	186
Duplicated Lines	11.83 %

Coupling/Cohesion

Components	2
Dependencies	8

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	2	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	add()	0	8	2
A	addToArrayNode()	11	11	2
A	addToObjectNode()	11	11	2
A	reassignParent()	0	6	3
A	end()	0	8	2
A	arrayNode()	0	4	1
A	boolNode()	0	4	1
A	floatNode()	0	4	1
A	intNode()	0	4	1
A	nullNode()	0	4	1
A	objectNode()	0	4	1
A	stringNode()	0	4	1
A	serialize()	0	4	1
A	json()	0	12	3

<?php

declare(strict_types=1);

namespace Saxulum\ElasticSearchQueryBuilder;

use Saxulum\ElasticSearchQueryBuilder\Node\AbstractNode;
use Saxulum\ElasticSearchQueryBuilder\Node\ArrayNode;
use Saxulum\ElasticSearchQueryBuilder\Node\BoolNode;
use Saxulum\ElasticSearchQueryBuilder\Node\FloatNode;
use Saxulum\ElasticSearchQueryBuilder\Node\IntNode;
use Saxulum\ElasticSearchQueryBuilder\Node\NullNode;
use Saxulum\ElasticSearchQueryBuilder\Node\ObjectNode;
use Saxulum\ElasticSearchQueryBuilder\Node\StringNode;

final class QueryBuilder implements QueryBuilderInterface
{
    /**
     * @var ObjectNode
     */
    private $rootNode;

    /**
     * @var AbstractNode
     */
    private $node;

    public function __construct()
    {
        $this->rootNode = new ObjectNode();
        $this->node = $this->rootNode;
    }

    /**
     * @param array ...$arguments
     * @return QueryBuilderInterface
     * @throws \Exception
     */
    public function add(...$arguments): QueryBuilderInterface
    {
        if ($this->node instanceof ObjectNode) {
            return $this->addToObjectNode(...$arguments);

The call to addToObjectNode() misses a required argument $node.

$arguments is of type array<integer,array>, but the function expects a string.

        }

        return $this->addToArrayNode(...$arguments);

$arguments is of type array<integer,array>, but the function expects a object<Saxulum\ElasticSearchQueryBuilder\Node\AbstractNode>.

    }

    /**
     * @param AbstractNode $node
     *
     * @return QueryBuilderInterface
     *
     * @throws \Exception
     */
    public function addToArrayNode(AbstractNode $node): QueryBuilderInterface

This method seems to be duplicated in your project.

    {
        if (!$this->node instanceof ArrayNode) {
            throw new \Exception(sprintf('You cannot call %s on node type: %s', __FUNCTION__, get_class($this->node)));
        }

        $this->node->add($node);
        $this->reassignParent($node);

        return $this;
    }

    /**
     * @param string       $key
     * @param AbstractNode $node
     *
     * @return QueryBuilderInterface
     *
     * @throws \Exception
     */
    public function addToObjectNode(string $key, AbstractNode $node): QueryBuilderInterface

This method seems to be duplicated in your project.

    {
        if (!$this->node instanceof ObjectNode) {
            throw new \Exception(sprintf('You cannot call %s on node type: %s', __FUNCTION__, get_class($this->node)));
        }

        $this->node->add($key, $node);
        $this->reassignParent($node);

        return $this;
    }

    /**
     * @param AbstractNode $node
     */
    private function reassignParent(AbstractNode $node)
    {
        if ($node instanceof ArrayNode || $node instanceof ObjectNode) {
            $this->node = $node;
        }
    }

    /**
     * @return QueryBuilderInterface
     *
     * @throws \Exception
     */
    public function end(): QueryBuilderInterface
    {
        if (null === $this->node = $this->node->getParent()) {
            throw new \Exception(sprintf('You cannot call %s on main node', __FUNCTION__));
        }

        return $this;
    }

    /**
     * @param bool $allowDefault
     * @return ArrayNode
     */
    public function arrayNode(bool $allowDefault = false): ArrayNode
    {
        return new ArrayNode($allowDefault);
    }

    /**
     * @param bool|null $value
     * @param bool $allowDefault
     * @return BoolNode
     */
    public function boolNode($value = null, bool $allowDefault = false): BoolNode
    {
        return new BoolNode($value, $allowDefault);
    }

    /**
     * @param float|null $value
     * @param bool $allowDefault
     * @return FloatNode
     */
    public function floatNode($value = null, bool $allowDefault = false): FloatNode
    {
        return new FloatNode($value, $allowDefault);
    }

    /**
     * @param int|null $value
     * @param bool $allowDefault
     * @return IntNode
     */
    public function intNode($value = null, bool $allowDefault = false): IntNode
    {
        return new IntNode($value, $allowDefault);
    }

    /**
     * @return NullNode
     */
    public function nullNode(): NullNode
    {
        return new NullNode;
    }

    /**
     * @param bool $allowDefault
     * @return ObjectNode
     */
    public function objectNode(bool $allowDefault = false): ObjectNode
    {
        return new ObjectNode($allowDefault);
    }

    /**
     * @param string|null $value
     * @param bool $allowDefault
     * @return StringNode
     */
    public function stringNode($value = null, bool $allowDefault = false): StringNode
    {
        return new StringNode($value, $allowDefault);
    }

    /**
     * @return \stdClass|null
     */
    public function serialize()
    {
        return $this->rootNode->serialize();
    }

    /**
     * @param boolean $beautify
     * @return string
     */
    public function json(bool $beautify = false): string
    {
        if (null === $serialized = $this->serialize()) {
            return '';
        }

        if ($beautify) {
            return json_encode($serialized, JSON_PRETTY_PRINT);
        }

        return json_encode($serialized);
    }
}