Larapie\Actions\Attribute

Complexity

Total Complexity

29

Size/Duplication

Total Lines	187
Duplicated Lines	0 %

Test Coverage

Coverage

90.67%

Importance

Changes	7
Bugs	2	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	initializeRules()	0	6	2
A	boot()	0	3	1
A	__construct()	0	3	1
A	cast()	0	7	3
A	optional()	0	9	1
A	hasRule()	0	3	1
A	getCast()	0	3	1
A	required()	0	3	1
A	factory()	0	3	1
A	hasDefault()	0	3	1
A	nullable()	0	3	1
A	__toString()	0	3	1
A	fake()	0	3	1
A	make()	0	3	1
A	getDefault()	0	3	1
A	extractRules()	0	11	4
A	getRules()	0	3	1
A	rule()	0	13	1
A	setDefault()	0	3	1
A	default()	0	6	1
A	setRules()	0	3	1
A	require()	0	3	1
A	isNullable()	0	3	1

<?php

namespace Larapie\Actions;

use Faker\Factory;
use Faker\Generator;
use Larapie\Actions\Attributes\Rules\GeneralRules;

class Attribute
{
    use GeneralRules;

    protected $data = [];

    protected $cast = null;

    final public function __construct()
    {
        $this->boot();
    }

    protected function boot()
    {
        $this->initializeRules();
    }

    protected function initializeRules()
    {
        if (method_exists($this, 'rules')) {
            $this->data['rules'] = $this->extractRules($this->rules());
        } else {
            $this->data['rules'] = [];
        }
    }

    /**
     * @return static
     */
    protected static function make()
    {
        return new static();
    }


    /**
     * @return static
     */
    public static function default($value)
    {
        $attribute = static::make();
        $attribute->setDefault($value);

        return $attribute;
    }

    /**
     * @return static
     */
    public static function required()
    {
        return static::make()->require();
    }

    /**
     * @return static
     */
    public function require()
    {
        return $this->rule('required');
    }

    /**
     * @return static
     */
    public function cast($cast)
    {
        if (is_callable($cast) || is_string($cast)) {
            $this->cast = $cast;
        }

        return $this;
    }

    /**
     * @return static
     */
    public static function optional()
    {
        return tap(static::make(), function (Attribute $attribute) {
            $attribute->setRules(
                collect($attribute->getRules())
                    ->reject(function ($value) {
                        return $value === 'required';
                    })
                    ->toArray()
            );
        });
    }

    /**
     * @return mixed
     */
    public static function fake()
    {
        return static::make()->factory(Factory::create());
    }

    public function factory(Generator $faker)

The parameter $faker is not used and could be removed.

    {
        throw new \RuntimeException('The fake method for this attribute is not implemented.');
    }

    protected function setRules(array $rules)
    {
        $this->data['rules'] = $rules;
    }

    /**
     * @param mixed ...$rules
     * @return static
     */
    public function rule(...$rules)
    {
        collect($rules)->each(function ($rule) {
            $this->setRules(
                collect($this->extractRules($rule))
                    ->flatten()
                    ->merge($this->data['rules'])
                    ->unique()
                    ->toArray()
            );
        });

        return $this;
    }

    /**
     * @return static
     */
    public function nullable()
    {
        return $this->rule('nullable');
    }

    public function isNullable(): bool
    {
        return $this->hasRule('nullable');
    }

    public function hasRule(string $rule): bool
    {
        return in_array($rule, $this->getRules());
    }

    protected function extractRules($rules): array
    {
        if (is_array($rules)) {
            return $rules;
        } elseif (is_string($rules)) {
            return explode('|', $rules);
        } elseif (is_object($rules)) {
            return [$rules];
        }

        return [];
    }

    public function getRules(): array
    {
        return $this->data['rules'];
    }

    public function getCast()
    {
        return $this->cast;
    }

    public function hasDefault(): bool
    {
        return array_key_exists('default', $this->data);
    }

    public function getDefault()
    {
        return $this->data['default'] ?? null;
    }

    protected function setDefault($value)
    {
        $this->data['default'] = $value;
    }

    public function __toString()
    {
        return implode('|', $this->getRules());
    }
}