Iatstuti\Database\Support\CascadeSoftDeletes

Complexity

Total Complexity

12

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	2

5 Methods

Rating	Name	Duplication	Size	Complexity
B	bootCascadeSoftDeletes()	0	23	4
A	implementsSoftDeletes()	0	4	1
A	getClassTraits()	0	10	3
A	hasInvalidCascadingRelationships()	0	6	2
A	getCascadingDeletes()	0	4	2

<?php

namespace Iatstuti\Database\Support;

use Illuminate\Database\Eloquent\Relations\Relation;
use LogicException;

trait CascadeSoftDeletes
{
    /**
     * Boot the trait.
     *
     * Listen for the deleting event of a soft deleting model, and run
     * the delete operation for any configured relationship methods.
     *
     * @throws \LogicException
     */
    protected static function bootCascadeSoftDeletes()
    {
        static::deleting(function ($model) {
            if (! $model->implementsSoftDeletes()) {
                throw new LogicException(sprintf(
                    '%s does not implement Illuminate\Database\Eloquent\SoftDeletes',
                    get_called_class()
                ));
            }

            if ($invalidCascadingRelationships = $model->hasInvalidCascadingRelationships()) {
                throw new LogicException(sprintf(
                    '%s [%s] must exist and return an object of type Illuminate\Database\Eloquent\Relations\Relation',
                    str_plural('Relationship', count($invalidCascadingRelationships)),
                    join(', ', $invalidCascadingRelationships)
                ));
            }

            foreach ($model->getCascadingDeletes() as $relationship) {
                $model->{$relationship}()->delete();
            }
        });
    }


    /**
     * Determine if the current model implements soft deletes.
     *
     * @return bool
     */
    protected function implementsSoftDeletes()
    {
        return in_array('Illuminate\Database\Eloquent\SoftDeletes', $this->getClassTraits($this));
    }
    

    /**
     * Get all traits used by class, including those inherited from ancestor classes.
     *
     * @param      $class
     * @param bool $autoload
     *
     * @return array
     */
    protected function getClassTraits($class, $autoload = true) {
        $traits = [];
        do {
            $traits = array_merge(class_uses($class, $autoload), $traits);
        } while($class = get_parent_class($class));
        foreach ($traits as $trait => $same) {
            $traits = array_merge(class_uses($trait, $autoload), $traits);
        }
        return array_unique($traits);
    }


    /**
     * Determine if the current model has any invalid cascading relationships defined.
     *
     * A relationship is considered invalid when the method does not exist, or the relationship
     * method does not return an instance of Illuminate\Database\Eloquent\Relations\Relation.
     *
     * @return array
     */
    protected function hasInvalidCascadingRelationships()
    {
        return array_filter($this->getCascadingDeletes(), function ($relationship) {
            return ! method_exists($this, $relationship) || ! $this->{$relationship}() instanceof Relation;
        });
    }


    /**
     * Fetch the defined cascading soft deletes for this model.
     *
     * @return array
     */
    protected function getCascadingDeletes()
    {
        return isset($this->cascadeDeletes) ? (array) $this->cascadeDeletes : [];
    }
}