Yoeunes\Commentable\Traits\Commentable

Complexity

Total Complexity

13

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	comments()	0	4	1
A	commentsCount()	0	4	1
A	isCommented()	0	4	1
A	isCommentedByUser()	0	4	1
A	deleteComment()	0	4	1
A	resetComments()	0	4	1
A	deleteCommentsForUser()	0	4	1
A	updateComment()	0	4	1
A	getCommentBuilder()	0	5	1
A	getCommentQueryBuilder()	0	4	1
A	commenters()	0	4	1
A	scopeOrderByCommentsCount()	0	12	2

<?php

namespace Yoeunes\Commentable\Traits;

use Yoeunes\Commentable\CommentBuilder;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Query\JoinClause;
use Yoeunes\Commentable\CommentQueryBuilder;
use Illuminate\Database\Eloquent\Relations\Relation;

trait Commentable
{
    /**
     * This model has many comments.
     *
     * @return \Illuminate\Database\Eloquent\Relations\MorphMany
     */
    public function comments()
    {
        return $this->morphMany(config('commentable.comment'), 'commentable');

It seems like morphMany() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    public function commentsCount()
    {
        return $this->comments()->count();
    }

    public function isCommented()
    {
        return $this->comments()->exists();
    }

    public function isCommentedByUser(int $user_id)
    {
        return $this->comments()->where('user_id', $user_id)->exists();
    }

    public function scopeOrderByCommentsCount(Builder $query, string $direction = 'asc')
    {
        return $query
            ->leftJoin('comments', function (JoinClause $join) {
                $join
                    ->on('comments.commentable_id', $this->getTable() . '.id')

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                    ->where('comments.commentable_type', in_array(__CLASS__, Relation::morphMap()) ? array_search(__CLASS__, Relation::morphMap()) : __CLASS__);
            })
            ->addSelect(DB::raw('COUNT(comments.id) as count_comments'))
            ->groupBy($this->getTable(). '.id')

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->orderBy('count_comments', $direction);
    }

    public function deleteComment(int $comment_id)
    {
        return $this->comments()->where('id', $comment_id)->delete();
    }

    public function resetComments()
    {
        return $this->comments()->delete();
    }

    public function deleteCommentsForUser(int $user_id)
    {
        return $this->comments()->where('user_id', $user_id)->delete();
    }

    public function updateComment(int $comment_id, string $comment)
    {
        return $this->comments()->where('id', $comment_id)->update(['comment' => $comment]);
    }

    public function getCommentBuilder()
    {
        return (new CommentBuilder())
            ->commentable($this);
    }

    /**
     * @return CommentQueryBuilder
     */
    public function getCommentQueryBuilder()
    {
        return new CommentQueryBuilder($this->comments());
    }

    public function commenters()
    {
        return $this->morphToMany(config('commentable.user'), 'commentable', 'comments');

It seems like morphToMany() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }
}