Reacter::reacterable() - Code Metrics - Inspection of "Weighted Reaction System 2.0" - cybercog/laravel-love - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#91)

by Anton
created 2019-07-29 20:35 UTC
Reacter::reacterable() A

↳ Parent: Reacter
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	3
rs	10
cc	1
nc	1
nop	0
<?php

/*
 * This file is part of Laravel Love.
 *
 * (c) Anton Komarev <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Cog\Laravel\Love\Reacter\Models;

use Cog\Contracts\Love\Reactant\Exceptions\ReactantInvalid;
use Cog\Contracts\Love\Reactant\Models\Reactant as ReactantContract;
use Cog\Contracts\Love\Reacter\Exceptions\NotAssignedToReacterable;
use Cog\Contracts\Love\Reacter\Models\Reacter as ReacterContract;
use Cog\Contracts\Love\Reacterable\Models\Reacterable as ReacterableContract;
use Cog\Contracts\Love\Reaction\Exceptions\ReactionAlreadyExists;
use Cog\Contracts\Love\Reaction\Exceptions\ReactionNotExists;
use Cog\Contracts\Love\Reaction\Models\Reaction as ReactionContract;
use Cog\Contracts\Love\ReactionType\Models\ReactionType as ReactionTypeContract;
use Cog\Laravel\Love\Reaction\Models\Reaction;
use Cog\Laravel\Love\Support\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\MorphTo;

final class Reacter extends Model implements
    ReacterContract
{
    protected $table = 'love_reacters';

    protected $fillable = [
        'type',
    ];

    protected $casts = [
        'id' => 'string',
    ];

    public function reacterable(): MorphTo
    {
        return $this->morphTo('reacterable', 'type', 'id', 'love_reacter_id');
    }

    public function reactions(): HasMany
    {
        return $this->hasMany(Reaction::class, 'reacter_id');
    }

    public function getId(): string
    {
        return $this->getAttributeValue('id');

    }

    public function getReacterable(): ReacterableContract
    {
        $reacterable = $this->getAttribute('reacterable');


        if (is_null($reacterable)) {
            throw new NotAssignedToReacterable();
        }

        return $reacterable;
    }

    public function getReactions(): iterable
    {
        return $this->getAttribute('reactions');
    }

    public function reactTo(
        ReactantContract $reactant,
        ReactionTypeContract $reactionType,
        ?float $rate = null
    ): void {
        if ($reactant->isNull()) {
            throw ReactantInvalid::notExists();
        }

        $reaction = $this->findReaction($reactant, $reactionType);

        if (is_null($reaction)) {
            $this->createReaction($reactant, $reactionType, $rate);

            return;
        }

        if (is_null($rate)) {
            throw new ReactionAlreadyExists(
                sprintf('Reaction of type `%s` already exists.', $reactionType->getName())
            );
        }

        // TODO: Get or compare rate value using reaction contract
        if ($reaction->getAttributeValue('rate') === $rate) {
        if ($reaction->/** @scrutinizer ignore-call */ getAttributeValue('rate') === $rate) {
            throw new ReactionAlreadyExists(
                sprintf('Reaction of type `%s` with `%s` rate already exists.', $reactionType->getName(), $rate)
            );
        }

        $reaction->update([
                   update([
            'rate' => $rate,
        ]);
    }

    public function unreactTo(
        ReactantContract $reactant,
        ReactionTypeContract $reactionType
    ): void {
        if ($reactant->isNull()) {
            throw ReactantInvalid::notExists();
        }

        $reaction = $this->findReaction($reactant, $reactionType);

        if (is_null($reaction)) {
            throw new ReactionNotExists(
                sprintf('Reaction of type `%s` not exists.', $reactionType->getName())
            );
        }

        $reaction->delete();
                   delete();
    }

    public function hasReactedTo(
        ReactantContract $reactant,
        ?ReactionTypeContract $reactionType = null
    ): bool {
        if ($reactant->isNull()) {
            return false;
        }

        return $reactant->isReactedBy($this, $reactionType);
    }

    public function hasNotReactedTo(
        ReactantContract $reactant,
        ?ReactionTypeContract $reactionType = null
    ): bool {
        return $reactant->isNotReactedBy($this, $reactionType);
    }

    public function isEqualTo(
        ReacterContract $that
    ): bool {
        return $that->isNotNull()
            && $this->getId() === $that->getId();
    }

    public function isNotEqualTo(
        ReacterContract $that
    ): bool {
        return !$this->isEqualTo($that);
    }

    public function isNull(): bool
    {
        return !$this->exists;
    }

    public function isNotNull(): bool
    {
        return $this->exists;
    }

    private function createReaction(
        ReactantContract $reactant,
        ReactionTypeContract $reactionType,
        ?float $rate
    ): void {
        $this->reactions()->create([
            'reaction_type_id' => $reactionType->getId(),
            'reactant_id' => $reactant->getId(),
            'rate' => $rate,
        ]);
    }

    /**
     * @param \Cog\Contracts\Love\Reactant\Models\Reactant $reactant
     * @param \Cog\Contracts\Love\ReactionType\Models\ReactionType $reactionType
     * @return null|\Cog\Contracts\Love\Reaction\Models\Reaction|\Illuminate\Database\Eloquent\Model
     */
    private function findReaction(
        ReactantContract $reactant,
        ReactionTypeContract $reactionType
    ): ?ReactionContract {
        return $this
            ->reactions()
            ->where('reactant_id', $reactant->getId())
            ->where('reaction_type_id', $reactionType->getId())
            ->first();
    }
}

cybercog / laravel-love

Pull Request — master (#91)

Reacter::reacterable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
