iamsaint\yml\BaseObject

Complexity

Total Complexity

18

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	rules()	0	3	1
A	writeElements()	0	11	3
B	validate()	0	33	9
A	addError()	0	7	2
A	write()	0	2	1
A	writeTag()	0	4	2

<?php

namespace iamsaint\yml;

use iamsaint\yml\exceptions\IncorrectRuleException;
use iamsaint\yml\interfaces\Base;
use iamsaint\yml\interfaces\Validator;
use XMLWriter;
use function array_key_exists;
use function count;
use function is_array;
use function is_string;

/**
 * Class BaseObject
 * @package iamsaint\yml
 *
 * @property array $errors
 */
class BaseObject implements Base
{
    public $errors = [];

    /**
     * @param string $groupTag
     * @param array|BaseObject[] $elements
     * @param XMLWriter $writer
     */
    public function writeElements(XMLWriter $writer, string $groupTag, array $elements): void
    {
        $writer->startElement($groupTag);

        foreach ($elements as $element) {
            if ($element instanceof Base) {
                $element->write($writer);
            }
        }

        $writer->endElement();
    }

    /**
     * @return bool
     * @throws IncorrectRuleException
     */
    public function validate(): bool
    {
        $this->errors = [];
        $rules = $this->rules();
        foreach ($rules as $rule) {
            if (!is_array($rule)) {
                throw new IncorrectRuleException('Rule must be array');
            }

            if (count($rule) < 2) {
                throw new IncorrectRuleException('Rule is not defined');
            }

            if (!is_string($rule[1])) {
                throw new IncorrectRuleException('Rule name must be a string');
            }

            $class = '\\iamsaint\\yml\\validators\\'.$rule[1];

            if (!class_exists($class)) {
                throw new IncorrectRuleException('Validator not found');
            }

            $attributes = is_array($rule[0]) ? $rule[0] : [$rule[0]];

            $validator = new $class();

            if ($validator instanceof Validator) {
                $validator->validate($this, $attributes, $rule[2] ?: []);
            }
        }

        return count($this->errors) === 0;
    }

    /**
     * @return array
     */
    public function rules(): array
    {
        return [];
    }

    /**
     * @param string $attribute
     * @param string $text
     */
    public function addError($attribute, $text): void
    {
        if (!array_key_exists($attribute, $this->errors)) {
            $this->errors[$attribute] = [];
        }

        $this->errors[$attribute][] = $text;
    }

    /**
     * @param XMLWriter $writer
     */
    public function write($writer): void
    {
    }

    /**
     * @param string $tagName
     * @param mixed $value
     * @param XMLWriter $writer
     * @param null|bool $notWriteCondition
     */
    public function writeTag($tagName, $value, $writer, $notWriteCondition = null): void
    {
        if ($notWriteCondition !== $value) {
            $writer->writeElement($tagName, $value);
        }
    }
}