Padosoft\Laravel\Validable\Validable

Complexity

Total Complexity

24

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	bootValidable()	0	10	2
A	setValidator()	0	4	1
A	hasValidator()	0	4	1
A	validate()	0	11	3
A	setErrors()	0	4	1
A	getErrors()	0	4	2
A	hasErrors()	0	4	1
A	wasSaved()	0	4	1
A	getRules()	0	8	2
A	getCreatingRules()	0	8	2
A	replacePlaceholders()	0	12	3
A	getUpdatingRules()	0	14	3
A	getMessages()	0	8	2

<?php
/**
 * Copyright (c) Padosoft.com 2018.
 */

namespace Padosoft\Laravel\Validable;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\App;
use Illuminate\Validation\Factory as ValidatorFactory;

/**
 * Trait Validable
 * @package Padosoft\Laravel\Validable
 * @property Array $rules Validation rules
 * @property Array $messages Validation messages
 */
trait Validable
{
    /**
     * Error message bag
     *
     * @var Illuminate\Support\MessageBag
     */
    protected $errors;
    /**
     * Validator instance
     *
     * @var Illuminate\Validation\Factory
     */
    protected $validator = null;

    protected static function bootValidable()
    {
        static::saving(function (Model $model) {
            if (!$model->hasValidator()) {
                $model->setValidator(App::make('validator'));
            }

            return $model->validate();
        });
    }

    public function setValidator(ValidatorFactory $validator)
    {
        $this->validator = $validator;

It seems like $validator of type object<Illuminate\Validation\Factory> is incompatible with the declared type object<Padosoft\Laravel\Validable\Illuminate\Validation\Factory> of property $validator.

    }

    public function hasValidator()
    {
        return $this->validator !== null;
    }

    /**
     * Validates current attributes against rules
     */
    public function validate()
    {
        $v = $this->validator->make($this->attributes,

The property attributes does not exist. Did you maybe forget to declare it?

            $this->exists ? static::getUpdatingRules($this) : static::getCreatingRules(), static::getMessages());

The property exists does not exist. Did you maybe forget to declare it?

        if ($v->passes()) {
            return true;
        }
        $this->setErrors($v->messages());

        return false;
    }

    /**
     * Set error message bag
     *
     * @var Illuminate\Support\MessageBag
     */
    protected function setErrors($errors)
    {
        $this->errors = $errors;
    }

    /**
     * Retrieve error message bag
     */
    public function getErrors()
    {
        return $this->errors !== null ? $this->errors : [];
    }

    /**
     * Inverse of wasSaved
     */
    public function hasErrors()
    {
        return !empty($this->errors);
    }

    /**
     * Return true if the validation is passed and the model was saved on db
     * @return bool
     */
    public function wasSaved()
    {
        return empty($this->errors);
    }


    public static function getRules()
    {
        if (isset(static::$rules)) {
            return static::$rules;
        }

        return [];
    }

    public static function getCreatingRules()
    {
        if (isset(static::$rules)) {
            return static::$rules;
        }

        return [];
    }

    protected static function replacePlaceholders(Model $model, $rules)
    {
        $replaced = [];
        foreach ($rules as $key => $rule) {
            foreach ($model->attributes as $attr => $val) {
                $rule = str_replace('{' . $attr . '}', $val, $rule);
            }
            $replaced[$key] = $rule;
        }

        return $replaced;
    }

    public static function getUpdatingRules(Model $model)
    {
        $rules = [];

        if (isset(static::$rules)) {
            $rules = static::$rules;
        }

        if (isset(static::$updating_rules)) {
            $rules = static::$updating_rules;
        }

        return static::replacePlaceholders($model, $rules);
    }

    public static function getMessages()
    {
        if (isset(static::$messages)) {
            return static::$messages;
        }

        return [];
    }
}