Collections\Traits\ExtractTrait

Complexity

Total Complexity

36

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Test Coverage

Coverage

58.33%

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	propertyExtractor()	0	11	2
B	extractData()	0	20	5
A	createMatcherFilter()	0	20	4

<?php

// Copyright (c) Lellys Informática. All rights reserved. See License.txt in the project root for license information.
namespace Collections\Traits;

use Symfony\Component\PropertyAccess\PropertyAccess;

/**
 * Provides utility protected methods for extracting a property or column
 * from an array or object.
 */
trait ExtractTrait
{
    /**
     * Returns a callable that can be used to extract a property or column from
     * an array or object based on a dot separated path.
     *
     * @param string|callable $callback A dot separated path of column to follow
     * so that the final one can be returned or a callable that will take care
     * of doing that.
     * @return callable
     */
    public function propertyExtractor($callback)
    {
        if (is_string($callback)) {
            $path = explode('.', $callback);
            $callback = function ($element) use ($path) {
                return $this->extractData($element, $path);
            };
        }

        return $callback;
    }

    /**
     * Returns a column from $data that can be extracted
     * by iterating over the column names contained in $path
     *
     * @param array|\ArrayAccess $data Data.
     * @param array $path Path to extract from.
     * @return mixed
     */
    protected function extractData($data, $path)
    {
        $accessor = PropertyAccess::createPropertyAccessor();
        $value = null;
        foreach ($path as $column) {
            if (is_array($data) || $data instanceof \ArrayAccess) {
                $value = $accessor->getValue($data, "[$column]");
            } else {

Expected 1 newline after opening brace; 2 found

                if (!$accessor->isReadable($data, $column)) {
                    return null;
                }

                $value = $accessor->getValue($data, $column);
            }
            $data = $value;
        }

        return $value;
    }

    /**
     * Returns a callable that receives a value and will return whether or not
     * it matches certain condition.
     *
     * @param array $conditions A key-value list of conditions to match where the
     * key is the property path to get from the current item and the value is the
     * value to be compared the item with.
     * @return callable
     */
    protected function createMatcherFilter(array $conditions)
    {
        $matchers = [];
        foreach ($conditions as $property => $value) {
            $extractor = $this->propertyExtractor($property);

It seems like $property can also be of type integer; however, Collections\Traits\ExtractTrait::propertyExtractor() does only seem to accept callable, maybe add an additional type check?

            $matchers[] = function ($v) use ($extractor, $value) {
                return $extractor($v) == $value;
            };
        }

        return function ($value) use ($matchers) {
            foreach ($matchers as $match) {
                if (!$match($value)) {
                    return false;
                }
            }

            return true;
        };
    }
}