Kris\LaravelFormBuilder\Rules

Complexity

Total Complexity

16

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

44.44%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setFieldName()	0	5	1
A	getFieldRules()	0	6	2
A	addFieldRule()	0	5	1
A	setFieldRules()	0	4	1
A	ensureFieldName()	0	11	3
A	append()	0	11	2
A	getRules()	0	3	1
A	getAttributes()	0	3	1
A	getMessages()	0	3	1
A	fromArray()	0	13	2

<?php

namespace Kris\LaravelFormBuilder;

class Rules
{

    /**
     * @var string|null
     */
    protected $fieldName;

    /**
     * @var array
     */
    protected $rules;

    /**
     * @var array
     */
    protected $attributes;

    /**
     * @var array
     */
    protected $messages;

    /**
     * @param array $rules
     * @param array $attributes
     * @param array $messages
     */
    public function __construct(array $rules, array $attributes = [], array $messages = []) {
        $this->rules = $rules;
        $this->attributes = $attributes;
        $this->messages = $messages;
    }

    /**
     * @param string $name
     */
    public function setFieldName($name) {
        $this->fieldName = $name;

        return $this;
    }

    /**
     * @param string $fieldName
     */
    public function getFieldRules($fieldName = null) {
      $fieldName = $this->ensureFieldName($fieldName);

      $rules = $this->rules;
      return isset($rules[$fieldName]) ? $rules[$fieldName] : [];
    }

    /**
     * @param mixes $rule
     * @param string $fieldName
     */
    public function addFieldRule($rule, $fieldName = null) {
      $rules = $this->getFieldRules($fieldName);
      $rules[] = $rule;
      $this->setFieldRules($rules, $fieldName);
    }

    /**
     * @param array $rules
     * @param string $fieldName
     */
    public function setFieldRules(array $rules, $fieldName = null) {
      $fieldName = $this->ensureFieldName($fieldName);
      $this->rules[$fieldName] = $rules;
    }

    /**
     * @param string $fieldName
     */
    protected function ensureFieldName($fieldName) {
      if (!$fieldName) {
        if (!$this->fieldName) {

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

          throw new InvalidArgumentException("Field functions on non-field Rules need explicit field name");
        }

        $fieldName = $this->fieldName;
      }

      return $fieldName;
    }

    /**
     * @param array $rules
     * @param array $attributes

There is no parameter named $attributes. Was it maybe removed?

     * @param array $messages

There is no parameter named $messages. Was it maybe removed?

     */
    public function append($rules) {
      if (is_array($rules)) {
        $rules = static::fromArray($rules);
      }

      $this->rules = array_replace_recursive($this->rules, $rules->getRules());
      $this->attributes = array_replace_recursive($this->attributes, $rules->getAttributes());
      $this->messages = array_replace_recursive($this->messages, $rules->getMessages());

      return $this;
    }

    /**
     * @return array
     */
    public function getRules() {
      return $this->rules;
    }

    /**
     * @return array
     */
    public function getAttributes() {
      return $this->attributes;
    }

    /**
     * @return array
     */
    public function getMessages() {
      return $this->messages;
    }

    /**
     * @param array[] $rules
     * @return static
     */
    static public function fromArray($rules) {
        if (!$rules) {

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

            return new static([]);
        }

        $rules += [
            'rules' => [],
            'attributes' => [],
            'error_messages' => [],
        ];

        return new static($rules['rules'], $rules['attributes'], $rules['error_messages']);
    }

}