SavinMikhail\CommentsDensity\BaselineManager

Complexity

Total Complexity

11

Size/Duplication

Total Lines	70
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	isUniqueConstraintViolation()	0	3	1
A	set()	0	22	4
A	init()	0	8	2
A	__construct()	0	3	1
A	getAllComments()	0	8	1
A	getInstance()	0	6	2

<?php

declare(strict_types=1);

namespace SavinMikhail\CommentsDensity;

use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Exception;
use SavinMikhail\CommentsDensity\Database\SQLiteDatabaseManager;

The type SavinMikhail\CommentsDensity\Database\SQLiteDatabaseManager was not found. Maybe you did not declare it correctly or list all dependencies?

use SavinMikhail\CommentsDensity\DTO\Output\OutputDTO;

The type SavinMikhail\CommentsDensity\DTO\Output\OutputDTO was not found. Maybe you did not declare it correctly or list all dependencies?

use function file_exists;
use function touch;

final class BaselineManager
{
    private static ?self $instance = null;
    private Connection $connection;

    private function __construct()
    {
        $this->init();
    }

    public static function getInstance(): self
    {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;

The expression return self::instance could return the type null which is incompatible with the type-hinted return SavinMikhail\CommentsDensity\BaselineManager. Consider adding an additional type-check to rule them out.

    }

    private function init(): void
    {
        $databaseFile = __DIR__ . '/../../comments_density.sqlite';
        if (!file_exists($databaseFile)) {
            touch($databaseFile);
        }
        $dbManager = new SQLiteDatabaseManager($databaseFile);
        $this->connection = $dbManager->getConnection();
    }

    /**
     * @throws Exception
     */
    public function set(OutputDTO $outputDTO): void
    {
        foreach ($outputDTO->comments as $comment) {
            try {
                $this->connection->insert('comments', [
                    'file_path' => $comment->file,
                    'line_number' => $comment->line,
                    'comment' => $comment->content,
                    'type' => $comment->commentType,
                ]);
            } catch (Exception $e) {
                if ($this->isUniqueConstraintViolation($e)) {
                    $this->connection->update('comments', [
                        'comment' => $comment->content,
                        'type' => $comment->commentType,
                    ], [
                        'file_path' => $comment->file,
                        'line_number' => $comment->line,
                    ]);
                    continue;
                }
                throw $e;
            }
        }
    }

    private function isUniqueConstraintViolation(Exception $e): bool
    {
        return str_contains($e->getMessage(), 'UNIQUE constraint failed');
    }

    public function getAllComments(): array
    {
        $query = $this->connection->createQueryBuilder()
            ->select('*')
            ->from('comments')
            ->executeQuery();

        return $query->fetchAllAssociative();
    }
}