Pulsar\Errors

Complexity

Total Complexity

20

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	3
Bugs	0	Features	2

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	getLocale()	0	4	1
A	add()	0	10	2
B	all()	0	21	5
A	has()	0	4	1
A	clear()	0	6	1
A	parse()	0	10	1
A	getIterator()	0	4	1
A	count()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	6	2

<?php

/**
 * @author Jared King <j@jaredtking.com>
 *
 * @link http://jaredtking.com
 *
 * @copyright 2015 Jared King
 * @license MIT
 */
namespace Pulsar;

use ArrayAccess;
use ArrayIterator;
use Countable;
use IteratorAggregate;
use Infuse\Locale;

class Errors implements IteratorAggregate, Countable, ArrayAccess
{
    /**
     * @var array
     */
    private $stack = [];

    /**
     * @var Model
     */
    private $model;

    /**
     * @var Locale
     */
    private $locale;

    /**
     * @var int
     */
    private $pointer = 0;

The property $pointer is not used and could be removed.

    /**
     * @param string $model class name of model
     *
     * @var Locale
     */
    public function __construct($model, Locale $locale = null)
    {
        if (!$locale) {
            $locale = new Locale();
        }

        $this->locale = $locale;
        $this->model = $model;

It seems like $model of type string is incompatible with the declared type object<Pulsar\Model> of property $model.

    }

    /**
     * Gets the locale instance.
     *
     * @return Locale
     */
    public function getLocale()
    {
        return $this->locale;
    }

    /**
     * Adds an error message to the stack.
     *
     * @param string $property name of property the error is about
     * @param string $error    error code or message
     *
     * @return self
     */
    public function add($property, $error)
    {
        if (!isset($this->stack[$property])) {
            $this->stack[$property] = [];
        }

        $this->stack[$property][] = $error;

        return $this;
    }

    /**
     * Gets all of the errors on the stack and also attempts
     * translation using the Locale class.
     *
     * @param string|false $property property to filter by
     * @param string|false $locale   locale name to translate to
     *
     * @return array errors
     */
    public function all($property = false, $locale = false)
    {
        $errors = $this->stack;
        if ($property) {

The expression $property of type false|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

            if (!isset($errors[$property])) {
                return [];
            }

            $errors = [$property => $this->stack[$property]];
        }

        // convert errors into messages
        $messages = [];
        foreach ($errors as $property => $errors2) {
            foreach ($errors2 as $error) {
                $messages[] = $this->parse($property, $error, $locale);
            }
        }

        return $messages;
    }

    /**
     * Checks if a property has an error.
     *
     * @param string $property
     *
     * @return bool
     */
    public function has($property)
    {
        return isset($this->stack[$property]);
    }

    /**
     * Clears all errors.
     *
     * @return self
     */
    public function clear()
    {
        $this->stack = [];

        return $this;
    }

    /**
     * Parses an error message before displaying it.
     *
     * @param string       $property
     * @param string       $error
     * @param string|false $locale
     *
     * @return array
     */
    private function parse($property, $error, $locale)
    {
        $model = $this->model;

        $parameters = [
            'property' => $model::getPropertyTitle($property),
        ];

        return $this->locale->t($error, $parameters, $locale);

It seems like $locale defined by parameter $locale on line 149 can also be of type string; however, Infuse\Locale::t() does only seem to accept boolean, maybe add an additional type check?

    }

    //////////////////////////
    // IteratorAggregate Interface
    //////////////////////////

    public function getIterator()
    {
        return new ArrayIterator($this->stack);
    }

    //////////////////////////
    // Countable Interface
    //////////////////////////

    /**
     * Get total number of errors.
     *
     * @return int
     */
    public function count()
    {
        return count($this->all());
    }

    /////////////////////////////
    // ArrayAccess Interface
    /////////////////////////////

    public function offsetExists($offset)
    {
        return $this->has($offset);
    }

    public function offsetGet($offset)
    {
        return $this->all($offset);
    }

    public function offsetSet($offset, $error)
    {
        $this->add($offset, $error);
    }

    public function offsetUnset($offset)
    {
        if ($this->has($offset)) {
            unset($this->stack[$offset]);
        }
    }
}