Peridot\Leo\Matcher\KeysMatcher

Complexity

Total Complexity

12

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefaultTemplate()	0	15	2
A	doMatch()	0	12	2
A	getArrayValue()	0	12	3
A	getKeyString()	0	14	2
A	matchInclusion()	0	10	3

<?php

namespace Peridot\Leo\Matcher;

use Peridot\Leo\Matcher\Template\ArrayTemplate;
use Peridot\Leo\Matcher\Template\TemplateInterface;

/**
 * KeysMatcher determines if the actual array or object has the expected keys. If the Assertion has
 * a 'contain' flag set, it will check if the expected keys are included in the object or array.
 *
 * @package Peridot\Leo\Matcher
 */
class KeysMatcher extends AbstractMatcher
{
    /**
     * The verb used in the template. Uses "have" if the 'contain' flag is not used, otherwise
     * "contain" is used.
     *
     * @var string
     */
    protected $verb = 'have';

    /**
     * {@inheritdoc}
     *
     * @return TemplateInterface
     */
    public function getDefaultTemplate()
    {
        $subject = 'key';

        if (count($this->expected) > 1) {
            $subject = 'keys';
        }

        $template = new ArrayTemplate([
            'default' => "Expected {{actual}} to {$this->verb} $subject {{keys}}",
            'negated' => "Expected {{actual}} to not {$this->verb} $subject {{keys}}",
        ]);

        return $template->setTemplateVars(['keys' => $this->getKeyString()]);
    }

    /**
     * Assert that the actual value is an array or object with the expected keys.
     *
     * @param $actual
     * @return mixed
     */
    protected function doMatch($actual)
    {
        $actual = $this->getArrayValue($actual);
        if ($this->assertion->flag('contain')) {
            $this->verb = 'contain';

            return $this->matchInclusion($actual);
        }
        $keys = array_keys($actual);

        return $keys == $this->expected;
    }

    /**
     * Normalize the actual value into an array, whether it is an object
     * or an array.
     *
     * @param object|array $actual
     */
    protected function getArrayValue($actual)
    {
        if (is_object($actual)) {
            return get_object_vars($actual);
        }

        if (is_array($actual)) {
            return $actual;
        }

        throw new \InvalidArgumentException('KeysMatcher expects object or array');
    }

    /**
     * Returns a formatted string of expected keys.
     *
     * @return string keys
     */
    protected function getKeyString()
    {
        $expected = $this->expected;
        $keys = '';
        $tail = array_pop($expected);

        if (!empty($expected)) {
            $keys = implode('","', $expected) . '", and "';
        }

        $keys .= $tail;

        return $keys;
    }

    /**
     * Used when the 'contain' flag exists on the Assertion. Checks
     * if the expected keys are included in the object or array.
     *
     * @param  array $actual
     * @return true
     */
    protected function matchInclusion($actual)
    {
        foreach ($this->expected as $key) {
            if (!array_key_exists($key, $actual)) {
                return false;
            }
        }

        return true;
    }
}