Sunnysideup\VersionPruner\PruningTemplatesTemplate

Complexity

Total Complexity

13

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Importance

Changes	7
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	normaliseOffset()	0	7	2
A	__construct()	0	5	1
A	normaliseLimit()	0	7	2
A	addVersionNumberToArray()	0	8	2
A	getToDelete()	0	3	1
A	normaliseWhere()	0	4	1
A	setToDelete()	0	5	1
A	getBaseQuery()	0	6	1
A	setBaseTable()	0	5	1
A	getUniqueKey()	0	3	1

<?php

namespace Sunnysideup\VersionPruner;

use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\Queries\SQLSelect;

abstract class PruningTemplatesTemplate
{
    /**
     * @var int
     */
    private const DEFAULT_ALWAYS_KEEP = 12;

    /**
     * @var int
     */
    private const DEFAULT_MAX_DELETE_IN_ONE_GO = 1000;

    /**
     * @var string[]
     */
    private const BASE_FIELDS = [
        'ID',
        'Version',
        'LastEdited',
    ];

    /**
     * Versioned DataObject.
     *
     * @var DataObject
     */
    protected $object;

    /**
     * the table that contains the fields like Version and ClassName
     * does not include the _Version bit.
     *
     * @var string
     */
    protected $baseTable = '';

    /**
     * array of items to delete.
     *
     * @var array
     */
    protected $toDelete = [];

    /**
     * @param mixed $object
     */
    public function __construct($object, array $toDelete)
    {
        $this->object = $object;
        $this->toDelete[$this->getUniqueKey()] = $toDelete;
        $this->baseTable = $this->object->baseTable();
    }

    /**
     * adds / removes records to be deleted.
     */
    abstract public function run(?bool $verbose = false);

    abstract public function getTitle(): string;

    abstract public function getDescription(): string;

    public function getToDelete(): array
    {
        return $this->toDelete[$this->getUniqueKey()];
    }

    public function setBaseTable(): self
    {
        $this->baseTable = $this->object->baseTable();

        return $this;
    }

    public function setToDelete(array $toDelete): self
    {
        $this->toDelete[$this->getUniqueKey()] = $toDelete;

        return $this;
    }

    /**
     * we use this unique key to accidentally mix up records.
     */
    protected function getUniqueKey(): string
    {
        return $this->object->ClassName . '_' . $this->object->ID;
    }

    /**
     * we keep adding to array ...
     *
     * @param mixed $records
     */
    protected function addVersionNumberToArray(array $array, $records, ?string $field = 'Version'): array
    {
        $myArray = [];
        foreach ($records as $record) {
            $myArray[$record[$field]] = $record[$field];
        }

        return $array + $myArray;
    }

    protected function getBaseQuery(?array $additionalFieldsToSelect = []): SQLSelect
    {
        return (new SQLSelect())
            ->setFrom($this->baseTable . '_Versions') // important, of course!
            ->setSelect(array_merge(self::BASE_FIELDS, $additionalFieldsToSelect)) // not sure if we need this.
            ->setOrderBy('"ID" DESC') // important - we always work backwards
        ;
    }

    protected function normaliseWhere(array $array): array
    {
        return $array + [
            '"RecordID" = ?' => $this->object->ID,
        ];
    }

    protected function normaliseLimit(?int $int = self::DEFAULT_MAX_DELETE_IN_ONE_GO): int
    {
        if ($int > self::DEFAULT_MAX_DELETE_IN_ONE_GO) {
            $int = self::DEFAULT_MAX_DELETE_IN_ONE_GO;
        }

        return $int;

The expression return $int could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    protected function normaliseOffset(?int $int = self::DEFAULT_ALWAYS_KEEP): int
    {
        if ($int < self::DEFAULT_ALWAYS_KEEP) {
            $int = self::DEFAULT_ALWAYS_KEEP;
        }

        return $int;

The expression return $int could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }
}