Peridot\Leo\ObjectPath\ObjectPath

Complexity

Total Complexity

12

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	2
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	get()	0	18	5
A	getPathParts()	0	9	2
A	getPropertyCollection()	0	8	2
A	normalizeKey()	0	8	2

<?php
namespace Peridot\Leo\ObjectPath;

/**
 * ObjectPath is a utility for parsing object and array strings into
 * ObjectPathValues.
 *
 * @package Peridot\Leo\Utility
 */
class ObjectPath
{
    /**
     * The subject to match path expressions against.
     *
     * @var array|object
     */
    protected $subject;

    /**
     * A pattern for matching array keys
     *
     * @var string
     */
    private static $arrayKey = '/\[([^\]]+)\]/';

    /**
     * @param array|object $subject
     */
    public function __construct($subject)
    {
        $this->subject = $subject;
    }

    /**
     * Returns an ObjectPathValue if the property described by $path
     * can be located in the subject.
     *
     * A path expression uses object and array syntax.
     *
     * @code
     *
     * $person = new stdClass();
     * $person->name = new stdClass();
     * $person->name->first = 'brian';
     * $person->name->last = 'scaturro';
     * $person->hobbies = ['programming', 'reading', 'board games'];
     *
     * $path = new ObjectPath($person);
     * $first = $path->get('name->first');
     * $reading = $path->get('hobbies[0]');
     *
     * @endcode
     *
     * @param string $path
     * @return ObjectPathValue
     */
    public function get($path)
    {
        $parts = $this->getPathParts($path);
        $properties = $this->getPropertyCollection($this->subject);
        $pathValue = null;
        while ($properties && $parts) {

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

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

            $key = array_shift($parts);
            $key = $this->normalizeKey($key);
            $pathValue = array_key_exists($key, $properties) ? new ObjectPathValue($key, $properties[$key]) : null;

            if (! array_key_exists($key, $properties)) {
                break;
            }

            $properties = $this->getPropertyCollection($properties[$key]);
        }
        return $pathValue;
    }

    /**
     * Breaks a path expression into an array used
     * for navigating a path.
     *
     * @param $path
     * @return array
     */
    public function getPathParts($path)
    {
        $path = preg_replace('/\[/', '->[', $path);
        if (preg_match('/^->/', $path)) {
            $path = substr($path, 2);
        }

        return explode('->', $path);
    }

    /**
     * Returns a property as an array.
     *
     * @param $subject
     * @return array
     */
    protected function getPropertyCollection($subject)
    {
        if (is_object($subject)) {
            return get_object_vars($subject);
        }

        return $subject;
    }

    /**
     * Return a key that can be used on the current subject.
     *
     * @param $key
     * @param $matches
     * @return mixed
     */
    protected function normalizeKey($key)
    {
        if (preg_match(static::$arrayKey, $key, $matches)) {

Since $arrayKey is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $arrayKey to at least protected.

            $key = $matches[1];
            return $key;
        }
        return $key;
    }
}