JamesMoss\Flywheel\QueryExecuter

Complexity

Total Complexity

49

Size/Duplication

Total Lines	208
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

89.66%

Importance

Changes	5
Bugs	1	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
C	run()	0	31	7
B	getFieldValue()	0	22	4
C	matchDocument()	0	22	20
B	filter()	0	47	5
C	sort()	0	45	12

<?php

namespace JamesMoss\Flywheel;

/**
 * Query
 *
 * Builds an executes a query whichs searches and sorts documents from a
 * repository.
 */
class QueryExecuter
{
    protected $repo;
    protected $predicate;
    protected $limit;
    protected $orderBy;

    /**
     * Constructor
     *
     * @param Repository $repo The repo to execute against
     * @param Predicate $pred The predicate to use.
     * @param array $limit The count and offset.
     * @param array $orderBy An array of field names to order by
     */
    public function __construct(Repository $repo, Predicate $pred, array $limit, array $orderBy)
    {
        $this->repo = $repo;
        $this->predicate = $pred;
        $this->limit = $limit;
        $this->orderBy = $orderBy;
    }

    /**
     * Runs the query.
     *
     * @return Result The documents returned from this query.
     */
    public function run()
    {
        $documents = $this->repo->findAll();

        if ($predicates = $this->predicate->getAll()) {
            $documents = $this->filter($documents, $predicates);
        }

        if ($this->orderBy) {

The expression $this->orderBy 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.

            $sorts = array();
            foreach ($this->orderBy as $order) {
                $parts = explode(' ', $order, 2);
                // TODO - validate parts
                $sorts[] = array(
                    $parts[0],
                    isset($parts[1]) && $parts[1] == 'DESC' ? SORT_DESC : SORT_ASC
                );
            }

            $documents = $this->sort($documents, $sorts);
        }

        $totalCount = count($documents);

        if ($this->limit) {

The expression $this->limit 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.

            list($count, $offset) = $this->limit;
            $documents = array_slice($documents, $offset, $count);
        }

        return new Result(array_values($documents), $totalCount);
    }

    public function getFieldValue($doc, $field, &$found = false)
    {
        $found = false;

        if ($field === '__id') {
            $found = true;

            return $doc->getId();
        }

        if (false !== strpos($field, '.')) {
            return $doc->getNestedProperty($field, $found);
        }

        if (!property_exists($doc, $field)) {
            return false;
        }

        $found = true;

        return $doc->{$field};
    }

    public function matchDocument($doc, $field, $operator, $value)
    {
        $docVal = $this->getFieldValue($doc, $field, $found);

        if (!$found) {
            return false;
        }

        switch (true) {
            case ($operator === '==' && $docVal == $value): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case ($operator === '===' && $docVal === $value): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case ($operator === '!=' && $docVal != $value): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case ($operator === '!==' && $docVal !== $value): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case ($operator === '>'  && $docVal >  $value): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case ($operator === '>=' && $docVal >= $value): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case ($operator === '<'  && $docVal <  $value): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case ($operator === '>=' && $docVal >= $value): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

            case ($operator === 'IN' && in_array($docVal, (array)$value)): return true;

The case body in a switch statement must start on the line following the statement.

Terminating statement must be on a line by itself

        }

        return false;
    }

    protected function filter($documents, $predicates)
    {
        $result = array();
        $originalDocs = $documents;

        $andPredicates = array_filter($predicates, function($pred) {
            return $pred[0] !== Predicate::LOGICAL_OR;
        });

        $orPredicates = array_filter($predicates, function($pred) {
            return $pred[0] === Predicate::LOGICAL_OR;
        });

        // 5.3 hack for accessing $this inside closure.
        $self = $this;

        foreach($andPredicates as $predicate) {
            if (is_array($predicate[1])) {
                $documents = $this->filter($documents, $predicate[1]);
            } else {
                list($type, $field, $operator, $value) = $predicate;

The assignment to $type is unused. Consider omitting it like so list($first,,$third).

                $documents = array_values(array_filter($documents, function ($doc) use ($self, $field, $operator, $value) {
                    return $self->matchDocument($doc, $field, $operator, $value);
                }));
            }

            $result = $documents;
        }

        foreach($orPredicates as $predicate) {
            if (is_array($predicate[1])) {
                $documents = $this->filter($originalDocs, $predicate[1]);
            } else {
                list($type, $field, $operator, $value) = $predicate;

The assignment to $type is unused. Consider omitting it like so list($first,,$third).

                $documents = array_values(array_filter($originalDocs, function ($doc) use ($self, $field, $operator, $value) {
                    return $self->matchDocument($doc, $field, $operator, $value);
                }));
            }

            $result = array_unique(array_merge($result, $documents), SORT_REGULAR);
        }

        return $result;
    }

    /**
     * Sorts an array of documents by multiple fields if needed.
     *
     * @param array $array An array of Documents.
     * @param array $args  The fields to sort by.
     *
     * @return array The sorted array of documents.
     */
    protected function sort(array $array, array $args)
    {
        $c = count($args);

        // PHP 5.3 hack
        $self = $this;

        usort($array, function ($a, $b) use ($self, $args, $c) {
            $i   = 0;
            $cmp = 0;
            while ($cmp == 0 && $i < $c) {
                $keyName = $args[$i][0];
                if($keyName == 'id' || $keyName == '__id') {
                    $valueA = $a->getId();
                    $valueB = $b->getId();
                } else {
                    $valueA = $self->getFieldValue($a, $keyName, $found);
                    if ($found === false) {
                        $valueA = null;
                    }
                    $valueB = $self->getFieldValue($b, $keyName, $found);
                    if ($found === false) {
                        $valueB = null;
                    }
                }

                if (is_string($valueA)) {
                    $cmp = strcmp($valueA, $valueB);
                } elseif (is_bool($valueA)) {
                    $cmp = $valueA - $valueB;
                } else {
                    $cmp = ($valueA == $valueB) ? 0 : (($valueA < $valueB) ? -1 : 1);
                }

                if ($args[$i][1] === SORT_DESC) {
                    $cmp *= -1;
                }
                $i++;
            }

            return $cmp;
        });

        return $array;
    }
}