Netdudes\DataSourceryBundle\DataSource\Driver\Doctrine\QueryBuilder\JoinGenerator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	136
Duplicated Lines	6.62 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	generate()	9	9	2
B	build()	0	20	6
B	generateJoinDependencyTree()	0	19	5
A	walkDependencyTreeNode()	0	13	3

<?php
namespace Netdudes\DataSourceryBundle\DataSource\Driver\Doctrine\QueryBuilder;

use Doctrine\ORM\Query\Expr\Join;
use Netdudes\DataSourceryBundle\DataSource\Configuration\Field;
use Netdudes\DataSourceryBundle\Query\Query;

class JoinGenerator
{
    /**
     * @var array
     */
    private $uniqueJoinNameCache = [];

    /**
     * @var Field[]
     */
    private $queryBuilderDataSourceFields;

    /**
     * @var Join[]
     */
    private $joins;

    /**
     * @var string
     */
    private $fromAlias;

    /**
     * @var Join[][]
     */
    private $joinCache = [];

    /**
     * @param array                   $queryBuilderDataSourceFields
     * @param                         $fromAlias
     * @param RequiredFieldsExtractor $requiredFieldsExtractor
     */
    public function __construct(array $queryBuilderDataSourceFields, $fromAlias, RequiredFieldsExtractor $requiredFieldsExtractor)
    {
        $this->requiredFieldsExtractor = $requiredFieldsExtractor;

The property requiredFieldsExtractor does not exist. Did you maybe forget to declare it?

        $this->queryBuilderDataSourceFields = $queryBuilderDataSourceFields;
        $this->fromAlias = $fromAlias;
    }

    /**
     * Generate the needed joins given a $query. This function will build a dependency tree and
     * walk it recursively to generate an ordered list of Join statements.
     *
     * @param Query $query
     *
     * @return Join[]
     */
    public function generate(Query $query)

This method seems to be duplicated in your project.

    {
        $uniqueId = spl_object_hash($query);
        if (!isset($this->joinCache[$uniqueId])) {
            $this->joinCache[$uniqueId] = $this->build($query);
        }

        return $this->joinCache[$uniqueId];
    }

    /**
     * @param Query $query
     *
     * @return Join[]
     */
    protected function build(Query $query)
    {
        $elements = [];
        $requiredFields = $this->requiredFieldsExtractor->extractRequiredFields($query);
        foreach ($this->queryBuilderDataSourceFields as $field) {
            if (!is_null($query) && !in_array($field->getUniqueName(), $requiredFields, true)) {
                continue;
            }
            if (!is_null($field->getDatabaseFilterQueryField())) {
                $elements[] = $field->getDatabaseFilterQueryField();
            }
        }
        $tree = $this->generateJoinDependencyTree($elements);
        $this->joins = [];
        foreach ($tree as $child => $grandChildren) {
            $this->walkDependencyTreeNode($this->fromAlias, $child, $grandChildren);
        }

        return $this->joins;
    }

    /**
     * Builds a tree of dependencies between entity fields, relating what joins
     * are needed for each selected field in the query.
     *
     * This action is performed recursively.
     *
     * @param array $elements
     *
     * @return array
     */
    protected function generateJoinDependencyTree(array $elements)
    {
        $subtree = [];
        foreach ($elements as $element) {
            $parts = explode('.', $element, 2);
            if (count($parts) == 1) {
                continue;
            }
            if (!isset($subtree[$parts[0]])) {
                $subtree[$parts[0]] = [];
            }
            $subtree[$parts[0]][] = $parts[1];
        }
        foreach ($subtree as $key => $elements) {
            $subtree[$key] = $this->generateJoinDependencyTree($elements);
        }

        return $subtree;
    }

    /**
     * Walks a node of the dependency tree, recursively generating an ordered list on Joins
     * that is stored in the $this->joins cache.
     *
     * @param       $parentUniqueIdentifier
     * @param       $node
     * @param       $descendants
     * @param array $completePath
     */
    protected function walkDependencyTreeNode($parentUniqueIdentifier, $node, $descendants, $completePath = [])
    {
        $completePath[] = $node;
        $joinedCompletePath = implode('.', $completePath);
        $joinUniqueIdentifier =
            array_key_exists($joinedCompletePath, $this->uniqueJoinNameCache) ?
                $this->uniqueJoinNameCache[$joinedCompletePath] :
                ($this->uniqueJoinNameCache[$joinedCompletePath] = uniqid("JOIN_${node}_"));
        $this->joins[$joinedCompletePath] = new Join(Join::LEFT_JOIN, $parentUniqueIdentifier . '.' . $node, $joinUniqueIdentifier);
        foreach ($descendants as $child => $grandChildren) {
            $this->walkDependencyTreeNode($joinUniqueIdentifier, $child, $grandChildren, $completePath);
        }
    }
}