AddonUpdater - Code Metrics - silverstripe/addons.silverstripe.org - Measure and Improve Code Quality continuously with Scrutinizer

AddonUpdater F
last analyzed 2017-11-15 00:10 UTC

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	408
Duplicated Lines	0 %
Coupling/Cohesion

Components	1
Dependencies	19
Importance

Changes
Metric	Value
wmc	61
lcom	1
cbo	19
dl	0
loc	408
rs	2.4812
c	0
b	0
f	0
10 Methods

Rating	Name	Size	Complexity
A	usePackagistCache()	4	1
A	__construct()	9	1
C	update()	67	12
B	updateAddon()	60	8
B	updateVersion()	58	6
B	updateLinks()	54	7
D	updateCompatibility()	44	10
D	updateAuthors()	49	14
A	getSilverStripeVersions()	4	1
A	setSilverStripeVersions()	5	1
How to fix Complexity

<?php

use Composer\Package\AliasPackage;
use Composer\Package\CompletePackage;
use Guzzle\Http\Exception\ClientErrorResponseException;
use SilverStripe\Elastica\ElasticaService;
use Packagist\Api\Result\Package;
use Composer\Package\Version\VersionParser;
use Packagist\Api\Result\Package\Version;

/**
 * Updates all add-ons from Packagist.
 */
class AddonUpdater
{

    /**
     * @var PackagistService
     */
    private $packagist;

    /**
     * @var SilverStripe\Elastica\ElasticaService
     */
    private $elastica;

    /**
     * @var SilverStripeVersion[]
     */
    private $silverstripes;

    public function __construct(
        PackagistService $packagist,
        ElasticaService $elastica
    ) {
        $this->packagist = $packagist;
        $this->elastica = $elastica;

        $this->setSilverStripeVersions(SilverStripeVersion::get());
    }

    /**
     * Updates all add-ons.
     *
     * @param Boolean Clear existing addons before updating them.
     * Will also clear their search index, and cascade the delete for associated data.
     * @param Array Limit to specific addons, using their name incl. vendor prefix.
     */
    public function update($clear = false, $limitAddons = null)
    {
        if ($clear && !$limitAddons) {
            Addon::get()->removeAll();
            AddonAuthor::get()->removeAll();
            AddonKeyword::get()->removeAll();
            AddonLink::get()->removeAll();
            AddonVendor::get()->removeAll();
            AddonVersion::get()->removeAll();
        }

        // This call to packagist can be expensive. Requests are served from a cache if usePackagistCache() returns true
        $cache = SS_Cache::factory('addons');

        if ($this->usePackagistCache() && $packages = $cache->load('packagist')) {
            $packages = unserialize($packages);
        } else {
            $packages = $this->packagist->getPackages();
            $cache->save(serialize($packages), 'packagist');
        }

        // TODO: AWS elasticsearch doesn't have this setting enabled
        // https://www.elastic.co/guide/en/elasticsearch/reference/5.2/url-access-control.html
        // and bulk index operations by elastica currently require it
        // Switching to https://github.com/heyday/silverstripe-elastica and SS4 might help

        // $this->elastica->startBulkIndex();

        foreach ($packages as $package) {
            /** @var Packagist\Api\Result\Package $package */

            $isAbandoned = (method_exists($package, 'isAbandoned') && $package->isAbandoned());
            $name = $package->getName();
            $versions = $package->getVersions();

            if ($limitAddons && !in_array($name, $limitAddons)) {
                continue;
            }

            $addon = Addon::get()->filter('Name', $name)->first();

            if (!$addon) {
                if ($isAbandoned) {
                    echo ' - Skipping abandoned package: ' . $name, PHP_EOL;
                    continue;
                }

                $addon = new Addon();
                $addon->Name = $name;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $addon->write();
            }

            if ($isAbandoned) {
                echo ' - Removing abandoned package: ' . $name, PHP_EOL;
                $addon->delete();
                continue;
            }

            usort($versions, function ($a, $b) {
                return version_compare($a->getVersionNormalized(), $b->getVersionNormalized());
            });

            $this->updateAddon($addon, $package, $versions);

        }

        // $this->elastica->endBulkIndex();
    }



    /**
     * Check whether or not we should contact packagist or use a cached version. This allows to speed up the task
     * during development.
     *
     * @return bool
     */
    protected function usePackagistCache()
    {
        return Director::isDev();
    }

    private function updateAddon(Addon $addon, Package $package, array $versions)
    {
        echo "Updating addon {$addon->Name}:\n";
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

        if (!$addon->VendorID) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            $vendor = AddonVendor::get()->filter('Name', $addon->VendorName())->first();

            if (!$vendor) {
                $vendor = new AddonVendor();
                $vendor->Name = $addon->VendorName();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $vendor->write();
            }

            echo " - Set vendor name to {$vendor->Name}\n";

            $addon->VendorID = $vendor->ID;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        }

        $addon->Type = preg_replace('/^silverstripe-(vendor)?/', '', $package->getType());
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $addon->Description = $package->getDescription();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $addon->Released = strtotime($package->getTime());
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $addon->Repository = $package->getRepository();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $addon->Downloads = $package->getDownloads()->getTotal();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $addon->DownloadsMonthly = $package->getDownloads()->getMonthly();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $addon->Favers = $package->getFavers();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

        foreach ($versions as $version) {
            $this->updateVersion($addon, $version);
        }

        // If there is no build, then queue one up if the add-on requires
        // one.
        if (!$addon->BuildQueued) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            echo " - Will queue a rebuild\n";
            if (!$addon->BuiltAt) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $buildJob = new BuildAddonJob(['package' => $addon->ID]);
                singleton('QueuedJobService')->queueJob($buildJob);
                echo " - Queued {$addon->Name} for build\n";
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $addon->BuildQueued = true;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            } else {
                $built = (int) $addon->obj('BuiltAt')->format('U');

                foreach ($versions as $version) {
                    if (strtotime($version->getTime()) > $built) {
                        $buildJob = new BuildAddonJob(['package' => $addon->ID]);
                        singleton('QueuedJobService')->queueJob($buildJob);
                        echo " - Queued {$addon->Name} version {$version->Name} for build\n";
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                        $addon->BuildQueued = true;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

                        break;
                    }
                }
            }
        } else {
            echo " - Will not queue a rebuild\n";
        }

        $addon->LastUpdated = time();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $addon->write();
    }

    private function updateVersion(Addon $addon, Version $package)
    {
        $version = null;

        if ($addon->isInDB()) {
            $version = $addon->Versions()->filter('Version', $package->getVersionNormalized())->first();

        }

        if (!$version) {
            $version = new AddonVersion();
        }

        $version->Name = $package->getName();
        $version->Type = preg_replace('/^silverstripe-(vendor)?/', '', $package->getType());
        $version->Description = $package->getDescription();
        $version->Released = strtotime($package->getTime());
        $keywords = $package->getKeywords();

        if ($keywords) {
            foreach ($keywords as $keyword) {

                $keyword = AddonKeyword::get_by_name($keyword);

                $addon->Keywords()->add($keyword);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                $version->Keywords()->add($keyword);
            }
        }

        $version->Version = $package->getVersionNormalized();
        $version->PrettyVersion = $package->getVersion();

        $stability = VersionParser::parseStability($package->getVersion());
        $isDev = $stability === 'dev';
        $version->Development = $isDev;

        $version->SourceType = $package->getSource()->getType();
        $version->SourceUrl = $package->getSource()->getUrl();
        $version->SourceReference = $package->getSource()->getReference();

        if ($package->getDist()) {
            $version->DistType = $package->getDist()->getType();
            $version->DistUrl = $package->getDist()->getUrl();
            $version->DistReference = $package->getDist()->getReference();
            $version->DistChecksum = $package->getDist()->getShasum();
        }

        $version->Extra = $package->getExtra();
        $version->Homepage = $package->getHomepage();
        $version->License = $package->getLicense();
        // $version->Support = $package->getSupport();

        echo " - Processed version {$version->Version}\n";

        $addon->Versions()->add($version);


        $this->updateLinks($version, $package);
        $this->updateCompatibility($addon, $version, $package);
        $this->updateAuthors($version, $package);
    }

    private function updateLinks(AddonVersion $version, Version $package)
    {
        $getLink = function ($name, $type) use ($version) {
            $link = null;

            if ($version->isInDB()) {
                $link = $version->Links()->filter('Name', $name)->filter('Type', $type)->first();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            }

            if (!$link) {
                $link = new AddonLink();
                $link->Name = $name;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                $link->Type = $type;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            }

            return $link;
        };

        $types = array(
            'require' => 'getRequire',
            'require-dev' => 'getRequireDev',
            'provide' => 'getProvide',
            'conflict' => 'getConflict',
            'replace' => 'getReplace'
        );

        foreach ($types as $type => $method) {
            if ($linked = $package->$method()) {
                foreach ($linked as $link => $constraint) {
                    $name = $link;
                    $addon = Addon::get()->filter('Name', $name)->first();

                    $local = $getLink($name, $type);
                    $local->Constraint = $constraint;

                    if ($addon) {
                        $local->TargetID = $addon->ID;
                    }

                    $version->Links()->add($local);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                }
            }
        }

        //to-do api have no method to get this.
        /*$suggested = $package->getSuggests();

		if ($suggested) foreach ($suggested as $package => $description) {
			$link = $getLink($package, 'suggest');
			$link->Description = $description;

			$version->Links()->add($link);
		}*/
    }

    private function updateCompatibility(Addon $addon, AddonVersion $version, Version $package)
    {
        $require = null;

        if ($package->getRequire()) {
            foreach ($package->getRequire() as $name => $link) {
                if ((string)$link == 'self.version') {
                    continue;
                }

                if ($name == 'silverstripe/framework') {
                    $require = $link;
                    break;
                }

                if ($name == 'silverstripe/cms') {
                    $require = $link;
                }
            }
        }

        if (!$require) {
            return;
        }

        //  >= interpreted as ^, see https://github.com/silverstripe/addons.silverstripe.org/issues/160
        $require = preg_replace('/^>=/', '^', $require);

        $addon->CompatibleVersions()->removeAll();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
        $version->CompatibleVersions()->removeAll();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        foreach ($this->getSilverStripeVersions() as $silverStripeVersion) {
            /** @var SilverStripeVersion $silverStripeVersion */
            try {
                if ($silverStripeVersion->getConstraintValidity($require)) {
                    $addon->CompatibleVersions()->add($silverStripeVersion);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                    $version->CompatibleVersions()->add($silverStripeVersion);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
                }
            } catch (Exception $e) {
                // An exception here shouldn't prevent further updates.
                Debug::log($addon->Name . "\t" . $addon->ID . "\t" . $e->getMessage());
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            }
        }
    }

    private function updateAuthors(AddonVersion $version, Version $package)
    {
        if ($package->getAuthors()) {
            foreach ($package->getAuthors() as $details) {
                $author = null;

                if (!$details->getName() && !$details->getEmail()) {
                    continue;
                }

                if ($details->getEmail()) {
                    $author = AddonAuthor::get()->filter('Email', $details->getEmail())->first();
                }

                if (!$author && $details->getHomepage()) {
                    $author = AddonAuthor::get()
                    ->filter('Name', $details->getName())
                    ->filter('Homepage', $details->getHomepage())
                    ->first();
                }

                if (!$author && $details->getName()) {
                    $author = AddonAuthor::get()
                    ->filter('Name', $details->getName())
                    ->filter('Versions.Addon.Name', $package->getName())
                    ->first();
                }

                if (!$author) {
                    $author = new AddonAuthor();
                }

                if ($details->getName()) {
                    $author->Name = $details->getName();
                }
                if ($details->getEmail()) {
                    $author->Email = $details->getEmail();
                }
                if ($details->getHomepage()) {
                    $author->Homepage = $details->getHomepage();
                }

                        //to-do not supported by API
                        //if(isset($details['role'])) $author->Role = $details['role'];

                $version->Authors()->add($author->write());
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            }
        }
    }

    /**
     * Get the list of SilverStripe versions
     *
     * @return DataList
     */
    public function getSilverStripeVersions()
    {
        return $this->silverstripes;
    }

    /**
     * Set the list of SilverStripeVersions
     *
     * @param  DataList $versions
     * @return $this
     */
    public function setSilverStripeVersions(DataList $versions)
    {
        $this->silverstripes = $versions;

        return $this;
    }
}

silverstripe / addons.silverstripe.org

AddonUpdater F last analyzed 2017-11-15 00:10 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

10 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like

AddonUpdater F
last analyzed 2017-11-15 00:10 UTC
