CloudImage::getAbsoluteSize() - Code Metrics - markguinn/silverstripe-cloudassets - Measure and Improve Code Quality continuously with Scrutinizer

CloudImage::getAbsoluteSize() A
last analyzed 2018-09-25 15:47 UTC

↳ Parent: CloudImage
Complexity

Conditions	2
Paths	2
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	0
<?php
/**
 * Wraps the Image object. We have to replace a few more methods
 * with Image because things like formatting and dimensions don't
 * work the same with a placeholder file.
 *
 * @mixin CloudFileExtension
 *
 * @author Mark Guinn <[email protected]>
 * @date 01.10.2014
 * @package cloudassets
 * @subpackage wrappers
 */
class CloudImage extends Image implements CloudAssetInterface
{
    private static $has_many = array(

        'DerivedImages' => 'CloudImageCachedStore',
    );


    public function Link()
    {
        $this->createLocalIfNeeded();
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 { }
        return $this->CloudStatus == 'Live' ? $this->getCloudURL() : parent::Link();
<?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.");
        }
    }

}
    }

    public function RelativeLink()
    {
        $this->createLocalIfNeeded();
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 { }
        return $this->CloudStatus == 'Live' ? $this->getCloudURL() : parent::RelativeLink();
<?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.");
        }
    }

}
    }

    public function getURL()
    {
        $this->createLocalIfNeeded();
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 { }
        return $this->CloudStatus == 'Live' ? $this->getCloudURL() : parent::getURL();
<?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.");
        }
    }

}
    }

    public function getAbsoluteURL()
    {
        $this->createLocalIfNeeded();
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 { }
        return $this->CloudStatus == 'Live' ? $this->getCloudURL() : parent::getAbsoluteURL();
<?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.");
        }
    }

}
    }

    public function getAbsoluteSize()
    {
        $this->createLocalIfNeeded();
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 { }
        return $this->CloudStatus == 'Live' ? $this->CloudSize : parent::getAbsoluteSize();
<?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.");
        }
    }

}
    }

    public function exists()
    {
        $this->createLocalIfNeeded();
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 { }
        return parent::exists();
    }


    /**
     * Save the dimensions before we potentially wipe out the file
     */
    public function onBeforeCloudPut()
    {
        $this->setCloudMeta('Dimensions', $this->getDimensions('live'));
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 { }
    }


    /**
     * @param string $dim - 'string' or 0 (width) or 1 (height)
     * @return int|string
     */
    public function getDimensions($dim = "string")
    {
        // give an option to get the real dimensions
        if ($dim === 'live') {
            return parent::getDimensions();
        }
        if ($this->CloudStatus != 'Live') {
<?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 parent::getDimensions($dim);
        }

        // otherwise we need to resort to stored dimensions because the
        // file may be in the cloud and the local may be a placeholder
        $val = $this->getCloudMeta('Dimensions');
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 (empty($val) || !preg_match('/^\d+x\d+$/', $val)) {
            $this->downloadFromCloud();
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 { }
            $val = parent::getDimensions('string');
            $this->convertToPlaceholder();
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 (preg_match('/^\d+x\d+$/', $val)) {
                $this->setCloudMeta('Dimensions', $val);
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 { }
                $this->write();
            } else {
                CloudAssets::inst()->getLogger()->error("Corrupted image/metadata in {$this->ID} =>  {$val}");
                $val = "1x1";
            }
        }

        if ($dim === 'string') {
            return $val;
        }

        $val = explode('x', $val);
        return $val[$dim];
    }


    /**
     * Return an image object representing the image in the given format.
     * This image will be generated using generateFormattedImage().
     * The generated image is cached, to flush the cache append ?flush=1 to your URL.
     *
     * Just pass the correct number of parameters expected by the working function
     *
     * @param string $format The name of the format.
     * @return CloudImageCached|null
     */
    public function getFormattedImage($format)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $args = func_get_args();
        $logger = CloudAssets::inst()->getLogger();

        if ($this->ID && $this->Filename && Director::fileExists($this->Filename)) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $cacheFile = call_user_func_array(array($this, "cacheFilename"), $args);
            $cachePath = Director::baseFolder()."/".$cacheFile;

            /** @var CloudImageCachedStore $stored */
            $stored = CloudImageCachedStore::get()->filter('Filename', $cacheFile)->first();
            if ($stored && !$stored->exists()) {
                $stored = null;
            }

            // If ?flush is present, always wipe existing data and start clean
            if (isset($_GET['flush'])) {
                // There was a bug here caused by the fact that GDBackend tries
                // to read the size off the cached image, which would be a placeholder
                // in certain cases.
                // I'm not 100% sure what the correct behaviour is here. For now
                // we'll destroy the existing image, causing it to be re-uploaded
                // every time. That seems safer if a little bit wasteful.
                $logger->debug("CloudAssets: deleting cached image because of flush: $cachePath");
                if (file_exists($cachePath)) {
                    unlink($cachePath);
                }

                // delete the existing meta if it existed
                if ($stored) {
                    $stored->delete();
                    $stored = null;
                }
            }

            // start building out the record
            $cached = new CloudImageCached($cacheFile);
            $cached->Title = $this->Title;
            $cached->ParentID = $this->ParentID;

            // Is there a meta record for this formatted file?
            if ($stored) {
                // Has it been successfully uploaded to the cloud?
                // If so, we can just send this puppy on
                // If not, is there a local file that's present and correct?
                // If not, we need to wipe the meta and anything local and regenerate
                if ($stored->CloudStatus !== 'Live' && $cached->isLocalMissing()) {
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 { }
                    $stored->delete();
                    $stored = null;
                    if (file_exists($cachePath)) {
                        unlink($cachePath);
                    }
                } else {
                    $cached->setStoreRecord($stored);
                }
            }

            // If there is no meta record (or an invalid one), is there a local file or placeholder?
            if (!$stored) {
                // if the local exists as a placeholder, we need to check if the cloud version is valid
                if (file_exists($cachePath) && $cached->containsPlaceholder()) {
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 { }
                    try {
                        $cached->downloadFromCloud();
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) {
                        // We want to fail silently here if there is any trouble
                        // because we can always regenerate the thumbnail
                        if (CloudAssets::config()->missing_image) {
                            return new CloudImageMissing($this, $args);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                        }
                    }
                }

                // If we don't have a valid local version at this point...
                if ($cached->isLocalMissing()) {
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 { }
                    // delete whatever might have been there
                    if (file_exists($cachePath)) {
                        unlink($cachePath);
                    }
                    $logger->debug("CloudAssets: generating formatted image at $cachePath");

                    // Regenerate the formatted image
                    if ($this->CloudStatus === 'Live' && $this->isLocalMissing()) {
<?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.");
        }
    }

}
                        try {
                            $this->downloadFromCloud();
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) {
                            if (CloudAssets::config()->missing_image) {
                                return new CloudImageMissing($this, $args);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
                            }
                        }

                        call_user_func_array(array($this, "generateFormattedImage"), $args);
                        $this->convertToPlaceholder();
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 { }
                    } else {
                        call_user_func_array(array($this, "generateFormattedImage"), $args);
                    }
                }

                // If we now have a valid image, generate a stored meta record for it
                if (file_exists($cachePath)) {
                    $stored = new CloudImageCachedStore();
                    $stored->Filename = $cacheFile;
<?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.");
        }
    }

}
                    $stored->SourceID = $this->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.");
        }
    }

}
                    $stored->write();
                    // all the other fields will get set when the cloud status is updated
                    $cached->setStoreRecord($stored);
                }
            }

            // upload to cloud if needed
            $cached->updateCloudStatus();
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 { }

            return $cached;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }
    }


    /**
     * Checks if the local file is an image that can be used and not
     * a placeholder or a corrupted file.
     *
     * @return bool
     */
    public function isLocalValid()
    {
        $path = $this->getFullPath();
        if (!file_exists($path)) {
            return false;
        }
        return (getimagesize($path) !== false);
    }


    /**
     * @return int The number of formatted images deleted
     */
    public function deleteFormattedImages()
    {
        foreach ($this->DerivedImages() as $store) {
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 { }
            $img = $store->getCloudImageCached();
            $img->delete();
        }

        // The above should have covered everything but this will clean up any
        // loose ends that were maybe created before wrapping or fell through a crack
        parent::deleteFormattedImages();
    }
}

markguinn / silverstripe-cloudassets

CloudImage::getAbsoluteSize() A last analyzed 2018-09-25 15:47 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CloudImage::getAbsoluteSize() A
last analyzed 2018-09-25 15:47 UTC
