Saxulum\ElasticSearchQueryBuilder\QueryBuilder

Complexity

Total Complexity

23

Size/Duplication

Total Lines	197
Duplicated Lines	17.26 %

Coupling/Cohesion

Components	2
Dependencies	8

Test Coverage

Coverage

100%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	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()	12	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;

/**
 * @deprecated use Saxulum\ElasticSearchQueryBuilder\Node\ObjectNode
 */
final class QueryBuilder implements QueryBuilderInterface

The interface Saxulum\ElasticSearchQueryBuilder\QueryBuilderInterface has been deprecated with message: use base interface, query builder will be dropped

{
    /**
     * @var ObjectNode
     */
    private $rootNode;

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

    public function __construct()
    {
        @trigger_error(sprintf('Use "%s" instead of the "%s"', ObjectNode::class, self::class), E_USER_DEPRECATED);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        $this->rootNode = ObjectNode::create();
        $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 $allowSerializeEmpty
     *
     * @return ArrayNode
     */
    public function arrayNode(bool $allowSerializeEmpty = false): ArrayNode
    {
        return ArrayNode::create($allowSerializeEmpty);
    }

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

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

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

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

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

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

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

    /**
     * @param bool $beautify
     *
     * @return string
     */
    public function json(bool $beautify = false): string

This method seems to be duplicated in your project.

    {
        if (null === $serialized = $this->serialize()) {
            return '';
        }

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

        return json_encode($serialized);
    }
}