Acme\App\Core\Component\Blog\Domain\Post\Post

Complexity

Total Complexity

33

Size/Duplication

Total Lines	250
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getId()	0	4	1
A	getTitle()	0	4	1
A	setTitle()	0	8	2
A	getSlug()	0	4	1
A	postfixSlug()	0	10	2
A	getContent()	0	4	1
A	setContent()	0	4	1
A	getPublishedAt()	0	4	1
A	setPublishedAt()	0	9	2
A	getAuthorId()	0	4	1
A	setAuthorId()	0	4	1
A	getComments()	0	4	1
A	addComment()	0	7	2
A	removeComment()	0	8	2
A	getSummary()	0	4	1
A	setSummary()	0	4	1
A	addTag()	0	8	3
A	removeTag()	0	6	2
A	getTags()	0	10	2
A	clearTags()	0	10	2
A	contains()	0	5	1
A	getKey()	0	5	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Explicit Architecture POC,
 * which is created on top of the Symfony Demo application.
 *
 * (c) Herberto Graça <herberto.graca@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Acme\App\Core\Component\Blog\Domain\Post;

use Acme\App\Core\Component\Blog\Domain\Post\Comment\Comment;
use Acme\App\Core\Component\Blog\Domain\Post\Tag\Tag;
use Acme\App\Core\SharedKernel\Component\User\Domain\User\UserId;
use Acme\PhpExtension\DateTime\DateTimeGenerator;
use Acme\PhpExtension\String\Slugger;
use DateTime;
use DateTimeImmutable;
use DateTimeInterface;
use function is_array;

/**
 * Defines the properties of the Post entity to represent the blog posts.
 *
 * See https://symfony.com/doc/current/book/doctrine.html#creating-an-entity-class
 *
 * Tip: if you have an existing database, you can generate these entity class automatically.
 * See https://symfony.com/doc/current/cookbook/doctrine/reverse_engineering.html
 *
 * @author Ryan Weaver <weaverryan@gmail.com>
 * @author Javier Eguiluz <javier.eguiluz@gmail.com>
 * @author Yonel Ceruto <yonelceruto@gmail.com>
 * @author Herberto Graca <herberto.graca@gmail.com>
 */
class Post
{
    /**
     * Use constants to define configuration options that rarely change instead
     * of specifying them under parameters section in config/services.yaml file.
     *
     * See https://symfony.com/doc/current/best_practices/configuration.html#constants-vs-configuration-options
     */
    const NUM_ITEMS = 10;

    /**
     * @var PostId
     */
    private $id;

    /**
     * @var string
     */
    private $title;

    /**
     * @var string
     */
    private $slug;

    /**
     * @var string
     */
    private $summary;

    /**
     * @var string
     */
    private $content;

    /**
     * @var DateTimeImmutable
     */
    private $publishedAt;

    /**
     * @var UserId
     */
    private $authorId;

    /**
     * @var Comment[]
     */
    private $comments = [];

    /**
     * We don't want to have any reference to Doctrine in the Domain, so we remove the Collection type hint from here.
     *
     * @var Tag[]
     */
    private $tags = [];

    /**
     * @var bool
     */
    private $isNewPost = false;

    public function __construct()
    {
        $this->publishedAt = DateTimeGenerator::generate();
        $this->id = new PostId();
        $this->isNewPost = true;
    }

    public function getId(): PostId
    {
        return $this->id;
    }

    public function getTitle(): ?string
    {
        return $this->title;
    }

    public function setTitle(string $title): void
    {
        $this->title = $title;

        if ($this->isNewPost) {
            $this->slug = Slugger::slugify($this->getTitle());
        }
    }

    public function getSlug(): ?string
    {
        return $this->slug;
    }

    public function postfixSlug(string $suffix): void
    {
        if (!$this->isNewPost) {
            throw new SlugIsImmutableException();
        }

        $suffix = '-' . ltrim($suffix, '-');

        $this->slug = $this->slug . $suffix;
    }

    public function getContent(): ?string
    {
        return $this->content;
    }

    public function setContent(string $content): void
    {
        $this->content = $content;
    }

    public function getPublishedAt(): DateTimeImmutable
    {
        return $this->publishedAt;
    }

    public function setPublishedAt(DateTimeInterface $publishedAt): void
    {
        /*
         * We need this check here because Symfony/Form 4.0 can not create DateTimeImmutable, but 4.1 will
         */
        $this->publishedAt = $publishedAt instanceof DateTime

It seems like $publishedAt instanceof \DateTime ? \DateTimeImmutable::createFromMutable($publishedAt) : $publishedAt can also be of type object<DateTimeInterface>. However, the property $publishedAt is declared as type object<DateTimeImmutable>. Maybe add an additional type check?

            ? DateTimeImmutable::createFromMutable($publishedAt)
            : $publishedAt;
    }

    public function getAuthorId(): UserId
    {
        return $this->authorId;
    }

    public function setAuthorId(UserId $authorId): void
    {
        $this->authorId = $authorId;
    }

    /**
     * We don't want to have here any reference to doctrine, so we remove the Collection type hint from everywhere.
     * The safest is to treat it as an array but we can't type hint it with 'array' because we might actually
     * return an Collection.
     *
     * @return Comment[]
     */
    public function getComments()
    {
        return $this->comments;
    }

    public function addComment(Comment $comment): void
    {
        $comment->setPost($this);
        if (!$this->contains($comment, $this->comments)) {
            $this->comments[] = $comment;
        }
    }

    /**
     * This method is not used, but I will leave it here as an example
     */
    public function removeComment(Comment $comment): void
    {
        $comment->setPost(null);

null is of type null, but the function expects a object<Acme\App\Core\Component\Blog\Domain\Post\Post>.

        if ($key = $this->getKey($comment, $this->comments)) {
            unset($this->comments[$key]);
        }
    }

    public function getSummary(): ?string
    {
        return $this->summary;
    }

    public function setSummary(string $summary): void
    {
        $this->summary = $summary;
    }

    public function addTag(Tag ...$tags): void
    {
        foreach ($tags as $tag) {
            if (!$this->contains($tag, $this->tags)) {
                $this->tags[] = $tag;
            }
        }
    }

    /**
     * This method is not used, but I will leave it here as an example
     */
    public function removeTag(Tag $tag): void
    {
        if ($key = $this->getKey($tag, $this->tags)) {
            unset($this->tags[$key]);
        }
    }

    /**
     * @return Tag[]
     */
    public function getTags(): array
    {
        // Since we don't type hint `tags` as a Doctrine collection, the `toArray` method is not recognized,
        // however, we do know it's a doctrine collection.
        // If Doctrine would allow us to define our own custom collections, this wouldn't be a problem.
        // As that is not the case, unfortunately we have here a hidden dependency.
        return is_array($this->tags)
            ? $this->tags
            : $this->tags->toArray();
    }

    /**
     * Since we don't type hint `tags` as a Doctrine collection, the `clear()` method below is
     *  not recognized by the IDE, as it is not even possible to call a method on an array.
     *
     * So we create this method here to encapsulate that operation, and minimize the issue, treating the `Post` entity
     * as an aggregate root.
     *
     * It is also a good practise to encapsulate these chained operations,
     * from an object calisthenics point of view.
     */
    public function clearTags(): void
    {
        // Since we don't type hint `tags` as a Doctrine collection, the `clear` method is not recognized,
        // however, we do know it's a doctrine collection.
        // If Doctrine would allow us to define our own custom collections, this wouldn't be a problem.
        // As that is not the case, unfortunately we have here a hidden dependency.
        is_array($this->tags)
            ? $this->tags = []
            : $this->tags->clear();
    }

    private function contains($item, $list): bool
    {
        // we need to cast the list to array because it might just actually be a doctrine collection
        return \in_array($item, (array) $list, true);
    }

    /**
     * @return false|int|string
     */
    private function getKey($item, $list)
    {
        // we need to cast the list to array because it might just actually be a doctrine collection
        return \array_search($item, (array) $list, true);
    }
}