SSpkS\Package\PackageFilter

Complexity

Total Complexity

30

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Test Coverage

Coverage

98.48%

Importance

Changes	5
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setOldVersionFilter()	0	3	1
A	__construct()	0	4	1
A	isMatchingArchitecture()	0	7	2
A	setChannelFilter()	0	3	1
A	setFirmwareVersionFilter()	0	3	1
A	setArchitectureFilter()	0	10	2
A	isMatchingFirmwareVersion()	0	8	3
A	removeObsoleteVersions()	0	11	4
A	isMatchingChannel()	0	11	5
A	isMatchingFirmwareVersionPre7()	0	5	2
A	getFilteredPackageList()	0	20	6
A	isMatchingFirmwareVersionPost7()	0	5	2

<?php

namespace SSpkS\Package;

use \SSpkS\Device\DeviceList;

The type \SSpkS\Device\DeviceList was not found. Maybe you did not declare it correctly or list all dependencies?

use \SSpkS\Package\Package;

The type \SSpkS\Package\Package was not found. Maybe you did not declare it correctly or list all dependencies?

This use statement conflicts with another class in this namespace, SSpkS\Package\Package. Consider defining an alias.

/**
 * SPK PackageFinder class
 */
class PackageFilter
{
    private $config;
    private $pkgList;
    /** @var bool|string[] $filterArch Array of allowed architectures, or FALSE to ignore. */
    private $filterArch = false;
    /** @var bool|string $filterFwVersion Target firmware version, or FALSE to ignore. */
    private $filterFwVersion = false;
    /** @var bool|string $filterChannel Channel 'stable' or 'beta', or FALSE to ignore. */
    private $filterChannel = false;
    /** @var bool $filterOldVersions TRUE to return unique packages with latest version only. */
    private $filterOldVersions = false;

    /**
     * @param \SSpkS\Config $config Config object
     * @param \SSpkS\Package\Package[] $pkgList List of Package objects to filter
     */
    public function __construct(\SSpkS\Config $config, array $pkgList)
    {
        $this->config = $config;
        $this->pkgList = $pkgList;
    }

    /**
     * Sets the architecture to filter for.
     *
     * @param string $arch Architecture.
     */
    public function setArchitectureFilter($arch)
    {
        // Specific corner case
        if ($arch == '88f6282') {
            $arch = '88f6281';
        }
      
        $dl = new DeviceList($this->config);
        $family = $dl->getFamily($arch);
        $this->filterArch = array_unique(array('noarch', $arch, $family));
    }

    /**
     * Sets the firmware version to filter for.
     *
     * @param string|bool $version Firmware version in dotted notation ('1.2.3456') or FALSE to ignore.
     */
    public function setFirmwareVersionFilter($version)
    {
        $this->filterFwVersion = $version;
    }

    /**
     * Sets the channel to filter for.
     *
     * @param string $channel Channel ('stable' or 'beta')
     */
    public function setChannelFilter($channel)
    {
        $this->filterChannel = $channel;
    }

    /**
     * Enables or disables omitting older versions of the same package from the result set.
     *
     * @param bool $status TRUE to enable the filter, FALSE to disable.
     */
    public function setOldVersionFilter($status)
    {
        $this->filterOldVersions = $status;
    }

    /**
     * If filter is enabled, checks if architecture of $package is compatible to requested one.
     *
     * @param \SSpkS\Package\Package $package Package to test.
     * @return bool TRUE if matching, or FALSE.
     */
    public function isMatchingArchitecture($package)
    {
        if ($this->filterArch === false) {
            return true;
        }
        $matches = array_intersect(/** @scrutinizer ignore-type */ $this->filterArch, $package->arch);
        return (count($matches) > 0);
    }

    /**
     * If filter is enabled, checks if minimal firmware required of $package is
     * smaller or equal to system firmware.
     *
     * @param \SSpkS\Package\Package $package Package to test.
     * @return bool TRUE if matching, or FALSE.
     */
    public function isMatchingFirmwareVersion(\SSpkS\Package\Package $package): bool
    {
        if ($this->filterFwVersion === false) {
            return true;
        }
        if(version_compare(/** @scrutinizer ignore-type */ $this->filterFwVersion, '7', '<'))
            return $this->isMatchingFirmwareVersionPre7($package);
        return $this->isMatchingFirmwareVersionPost7($package);
    }

    private function isMatchingFirmwareVersionPre7(\SSpkS\Package\Package $package): bool
    {
        // on DSM6 or less, package must be <= to filter
        return version_compare($package->firmware, /** @scrutinizer ignore-type */ '7', '<')
        && version_compare($package->firmware, /** @scrutinizer ignore-type */ $this->filterFwVersion, '<=');
    }

    private function isMatchingFirmwareVersionPost7(\SSpkS\Package\Package $package): bool
    {
        // on DSM7 or above (hypothetically), package must be <= to filter
        return version_compare($package->firmware, /** @scrutinizer ignore-type */ '7', '>=')
        && version_compare($package->firmware, /** @scrutinizer ignore-type */ $this->filterFwVersion, '<=');
    }

    /**
     * If filter is enabled, checks if channel of $package matches requested one.
     * 'beta' will show ALL packages, also those from 'stable'.
     *
     * @param \SSpkS\Package\Package $package Package to test.
     * @return bool TRUE if matching, or FALSE.
     */
    public function isMatchingChannel($package)
    {
        if ($this->filterChannel === false) {
            return true;
        }
        if ($this->filterChannel == 'stable' && $package->isBeta() === false) {
            return true;
        } elseif ($this->filterChannel == 'beta') {
            return true;
        }
        return false;
    }

    /**
     * Removes older versions of same package from $pkgList.
     *
     * @param \SSpkS\Package\Package[] $pkgList List of packages
     * @return \SSpkS\Package\Package[] List of unique packages
     */
    public function removeObsoleteVersions($pkgList)
    {
        $uniqueList = array();
        foreach ($pkgList as $package) {
            $pkgId = $package->package;
            if (isset($uniqueList[$pkgId]) && version_compare($uniqueList[$pkgId]->version, $package->version, '>=')) {
                continue;
            }
            $uniqueList[$pkgId] = $package;
        }
        return array_values($uniqueList);
    }

    /**
     * Returns the list of packages matching the currently set filters.
     *
     * @return \SSpkS\Package\Package[] List of Package objects matching filters.
     */
    public function getFilteredPackageList()
    {
        $filteredPackages = array();
        foreach ($this->pkgList as $package) {
            if (!$this->isMatchingArchitecture($package)) {
                continue;
            }
            if (!$this->isMatchingFirmwareVersion($package)) {
                continue;
            }
            if (!$this->isMatchingChannel($package)) {
                continue;
            }
            $filteredPackages[] = $package;
        }
        if ($this->filterOldVersions) {
            // remove older versions of duplicate packages from $filteredPackages
            $filteredPackages = $this->removeObsoleteVersions($filteredPackages);
        }
        return $filteredPackages;
    }
}