object::get_workspace() - Code Metrics - Inspection of "Support no metadata types in get_object_by_guid" - flack/midgard-portable - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 5ddc8c...aac2ef )

by Andreas
created 2016-11-27 20:02 UTC
object::get_workspace() A

↳ Parent: object
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0
<?php
/**
 * @author CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @license http://www.gnu.org/licenses/gpl.html GNU General Public License
 */
namespace midgard\portable\api;

use midgard\portable\storage\connection;
use midgard\portable\storage\objectmanager;
use midgard\portable\storage\collection;
use midgard\portable\storage\interfaces\metadata as metadata_interface;
use midgard\portable\mgdschema\translator;
use midgard\portable\api\error\exception;
use Doctrine\ORM\Query;
use midgard_connection;
use Doctrine\Common\Persistence\Proxy;

abstract class object extends dbobject
{
    protected $metadata; // compat with mgd behavior: If the schema has no metadata, the property is present anyway

    public $action = ''; // <== does this need to do anything?

    private $collections = array();

    /**
     *
     * @param mixed $id ID or GUID
     */
    public function __construct($id = null)
    {
        if ($id !== null) {
            if (is_int($id)) {
                $this->get_by_id($id);
            } elseif (is_string($id)) {
                $this->get_by_guid($id);
            }
        }
    }

    /**
     *
     * @param string $classname
     * @return collection
     */
    private function get_collection($classname)
    {
        if (!array_key_exists($classname, $this->collections)) {
            $this->collections[$classname] = new collection($classname);
        }
        return $this->collections[$classname];
    }

    public function __debugInfo()
    {
        $ret = parent::__debugInfo();
        if (property_exists($this, 'metadata')) {
            $metadata = new \stdClass;
            foreach ($this->cm->getFieldNames() as $name) {
                if (strpos($name, 'metadata_') !== false) {
                    $fieldname = str_replace('metadata_', '', $name);
                    $metadata->$fieldname = $this->__get($name);
                }
            }
            $ret['metadata'] = $metadata;
        }

        return $ret;
    }

    public function __set($field, $value)
    {
        if ($field == 'guid') {
            return;
        }
        parent::__set($field, $value);
    }

    public function __get($field)
    {
        if (   $field === 'metadata'
            && $this->metadata === null
            && $this instanceof metadata_interface) {
            $this->metadata = new metadata($this);
        }

        return parent::__get($field);
    }

    public function __call($method, $args)
    {
        if ($method === 'list') {
            return $this->_list();
        }
        throw new \BadMethodCallException("Unknown method " . $method . " on " . get_class($this));
    }

    protected function load_parent(array $candidates)
    {
        foreach ($candidates as $candidate) {
            if ($this->$candidate !== null) {
                //Proxies become stale if the object itself is detached, so we have to re-fetch
                if (   $this->$candidate instanceof \Doctrine\ORM\Proxy\Proxy
                    && $this->$candidate->__isInitialized()) {
                    try {
                        $this->$candidate->get_by_id($this->$candidate->id);
                    } catch (exception $e) {
                        connection::log()->error('Failed to refresh parent from proxy: ' . $e->getMessage());
                        return null;
                    }
                }
                return $this->$candidate;
            }
        }
        return null;
    }

    public function get_by_id($id)
    {
        $entity = connection::get_em()->find(get_class($this), $id);

        if ($entity === null) {
            throw exception::not_exists();
        }
        // According to Doctrine documentation, proxies should be transparent, but in practice,
        // there will be problems if we don't force-load
        if (   $entity instanceof \Doctrine\ORM\Proxy\Proxy
            && !$entity->__isInitialized()) {
            try {
                $entity->__load();
            } catch (\Doctrine\ORM\EntityNotFoundException $e) {
                throw exception::object_purged();
            }
        }
        if ($entity instanceof metadata_interface && $entity->{metadata_interface::DELETED_FIELD}) {
            // This can happen when the "deleted" entity is still in EM's identity map
            throw exception::object_deleted();
        }
        if (empty($entity->guid)) {
            // This can happen when a reference proxy to a purged entity is still in EM's identity map
            throw exception::object_purged();
        }

        $this->populate_from_entity($entity);

        connection::get_em()->detach($entity);
        midgard_connection::get_instance()->set_error(MGD_ERR_OK);
        return true;
    }

    public function get_by_guid($guid)
    {
        if (!mgd_is_guid($guid)) {
            throw new \InvalidArgumentException("'$guid' is not a valid guid");
        }
        $entity = connection::get_em()->getRepository(get_class($this))->findOneBy(array('guid' => $guid));
        if ($entity === null) {
            throw exception::not_exists();
        }
        $this->populate_from_entity($entity);

        connection::get_em()->detach($entity);
        midgard_connection::get_instance()->set_error(MGD_ERR_OK);
        return true;
    }

    public function create()
    {
        if (!empty($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.");
        }
    }

}
            exception::duplicate();
            return false;
        }
        if (   !$this->is_unique()
            || !$this->check_parent()) {
            return false;
        }
        if (!$this->check_fields()) {
            return false;
        }
        try {
            $om = new objectmanager(connection::get_em());

            $om->create($this);
        } catch (\Exception $e) {
            exception::internal($e);
            return false;
        }

        midgard_connection::get_instance()->set_error(MGD_ERR_OK);

        return ($this->id != 0);
<?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 update()

    {
        if (empty($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.");
        }
    }

}
            midgard_connection::get_instance()->set_error(MGD_ERR_INTERNAL);
            return false;
        }
        if (!$this->check_fields()) {
            return false;
        }
        try {
            $om = new objectmanager(connection::get_em());

            $om->update($this);
        } catch (\Exception $e) {
            exception::internal($e);
            return false;
        }
        midgard_connection::get_instance()->set_error(MGD_ERR_OK);

        return true;
    }

    /**
     * @todo: Tests indicate that $check_dependencies is ignored in the mgd2 extension,
     * so we might consider ignoring it, too
     */
    public function delete($check_dependencies = true)
    {
        if (empty($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.");
        }
    }

}
            midgard_connection::get_instance()->set_error(MGD_ERR_INVALID_PROPERTY_VALUE);
            return false;
        }
        if (   $check_dependencies
            && $this->has_dependents()) {
            exception::has_dependants();
            return false;
        }
        if (!($this instanceof metadata_interface)) {
            exception::invalid_property_value();
            return false;
        }
        if ($this->{metadata_interface::DELETED_FIELD}) {
            return true;
        }

        try {
            $om = new objectmanager(connection::get_em());

            $om->delete($this);
        } catch (\Exception $e) {
            exception::internal($e);
            return false;
        }

        midgard_connection::get_instance()->set_error(MGD_ERR_OK);
        return true;
    }

    private function is_unique()
    {
        $this->initialize();

        if (empty($this->cm->midgard['unique_fields'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            return true;
        }

        $qb = connection::get_em()->createQueryBuilder();
        $qb->from(get_class($this), 'c');
        $conditions = $qb->expr()->andX();
        if ($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.");
        }
    }

}
            $parameters = array(
                'id' => $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.");
        }
    }

}
            );
            $conditions->add($qb->expr()->neq('c.id', ':id'));
        }
        $found = false;
        foreach ($this->cm->midgard['unique_fields'] as $field) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            if (empty($this->$field)) {
                //empty names automatically pass according to Midgard logic
                continue;
            }
            $conditions->add($qb->expr()->eq('c.' . $field, ':' . $field));
            $parameters[$field] = $this->$field;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            $found = true;
        }

        if (!$found) {
            return true;
        }

        if (!empty($this->cm->midgard['upfield'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            // TODO: This needs to be changed so that value is always numeric, since this is how midgard does it
            if ($this->{$this->cm->midgard['upfield']} === null) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $conditions->add($qb->expr()->isNull('c.' . $this->cm->midgard['upfield']));
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            } else {
                $conditions->add($qb->expr()->eq('c.' . $this->cm->midgard['upfield'], ':' . $this->cm->midgard['upfield']));
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $parameters[$this->cm->midgard['upfield']] = $this->{$this->cm->midgard['upfield']};
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            }
        } elseif (!empty($this->cm->midgard['parentfield'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            // TODO: This needs to be changed so that value is always numeric, since this is how midgard does it
            if ($this->{$this->cm->midgard['parentfield']} === null) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $conditions->add($qb->expr()->isNull('c.' . $this->cm->midgard['parentfield']));
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            } else {
                $conditions->add($qb->expr()->eq('c.' . $this->cm->midgard['parentfield'], ':' . $this->cm->midgard['parentfield']));
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $parameters[$this->cm->midgard['parentfield']] = $this->{$this->cm->midgard['parentfield']};
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            }
        }
        $qb->where($conditions)
            ->setParameters($parameters);

        $qb->select("count(c)");
        $count = intval($qb->getQuery()->getSingleScalarResult());

        if ($count !== 0) {
            exception::object_name_exists();
            return false;
        }
        return true;
    }

    private function check_parent()
    {
        $this->initialize();

        if (   empty($this->cm->midgard['parentfield'])
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            || empty($this->cm->midgard['parent'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            return true;
        }

        if (empty($this->{$this->cm->midgard['parentfield']})) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            exception::object_no_parent();
            return false;
        }
        return true;
    }

    private function check_fields()
    {
        $this->initialize();

        foreach ($this->cm->fieldMappings as $name => $field) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            if (   $field['midgard:midgard_type'] == translator::TYPE_GUID
                && !empty($this->$name)
                && !mgd_is_guid($this->$name)) {
                exception::invalid_property_value("'" . $name . "' property's value is not a guid.");
                return false;
            }
        }
        return true;
    }

    public function is_in_parent_tree($root_id, $id)

    {
        return false;
    }

    public function is_in_tree($root_id, $id)

    {
        return false;
    }

    public function has_dependents()
    {
        $this->initialize();

        $stat = false;

        if (!empty($this->cm->midgard['upfield'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $qb = connection::get_em()->createQueryBuilder();
            $qb->from(get_class($this), 'c')
                ->where('c.' . $this->cm->midgard['upfield'] . ' = ?0')
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                ->setParameter(0, $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.");
        }
    }

}
                ->select("COUNT(c)");
            $results = intval($qb->getQuery()->getSingleScalarResult());
            $stat = ($results > 0);
        }

        if (   !$stat
            && !empty($this->cm->midgard['childtypes'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            foreach ($this->cm->midgard['childtypes'] as $typename => $parentfield) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $qb = connection::get_em()->createQueryBuilder();
                $qb->from('midgard:' . $typename, 'c')
                    ->where('c.' . $parentfield . ' = ?0')
                    ->setParameter(0, $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.");
        }
    }

}
                    ->select("COUNT(c)");

                $results = intval($qb->getQuery()->getSingleScalarResult());
                $stat = ($results > 0);
                if ($stat) {
                    break;
                }
            }
        }

        return $stat;
    }

    public function get_parent()
    {
        return null;
    }

    /**
     * This function is called list() in Midgard, but that doesn't work in plain PHP
     *
     * @return array
     */
    private function _list()
    {
        $this->initialize();

        if (!empty($this->cm->midgard['upfield'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $qb = connection::get_em()->createQueryBuilder();
            $qb->from(get_class($this), 'c')
                ->where('c.' . $this->cm->midgard['upfield'] . ' = ?0')
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                ->setParameter(0, $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.");
        }
    }

}
                ->select("c");
            return $qb->getQuery()->getResult();
        }

        return array();
    }

    /**
     * This should return child objects, but only if they are of a different type
     * For all other input, an empty array is returned
     * (not implemented yet)
     *
     * @param string $classname
     * @return array
     */
    public function list_children($classname)

    {
        return array();
    }

    public function get_by_path($path)
    {
        $parts = explode('/', trim($path, '/'));
        if (empty($parts)) {
            return false;
        }
        $this->initialize();

        if (count($this->cm->midgard['unique_fields']) != 1) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            return false;
        }

        $field = $this->cm->midgard['unique_fields'][0];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        if (!empty($this->cm->midgard['parent'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $parent_cm = connection::get_em()->getClassMetadata('midgard:' . $this->cm->midgard['parent']);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $parentclass = $this->cm->fullyQualifiedClassName($this->cm->midgard['parent']);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $parentfield = $parent_cm->midgard['upfield'];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $upfield = $this->cm->midgard['parentfield'];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        } elseif (!empty($this->cm->midgard['upfield'])) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $parentclass = get_class($this);
            $upfield = $this->cm->midgard['upfield'];
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $parentfield = $upfield;
        } else {
            return false;
        }

        $name = array_pop($parts);
        $up = 0;
        foreach ($parts as $part) {
            $qb = $this->get_uniquefield_query($parentclass, $field, $part, $parentfield, $up);
            $qb->select("c.id");
            $up = intval($qb->getQuery()->getOneOrNullResult(Query::HYDRATE_SINGLE_SCALAR));
            if ($up === 0) {

                exception::not_exists();
                $this->id = 0;
<?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.");
        }
    }

}
                $this->set_guid('');
                return false;
            }
        }

        $qb = $this->get_uniquefield_query(get_class($this), $field, $name, $upfield, $up);
        $qb->select("c");

        $entity = $qb->getQuery()->getOneOrNullResult();

        if ($entity === null) {

            exception::not_exists();
            $this->id = 0;
<?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.");
        }
    }

}
            $this->set_guid('');
            return false;
        }
        $this->populate_from_entity($entity);

        return true;
    }

    /**
     * @return int
     */
    protected function get_uniquefield_query($classname, $field, $part, $upfield, $up)
    {
        $qb = connection::get_em()->createQueryBuilder();
        $qb->from($classname, 'c');
        $conditions = $qb->expr()->andX();
        $conditions->add($qb->expr()->eq('c.' . $field, ':' . $field));
        $parameters = array(
            $field => $part
        );

        if (empty($up)) {
            // If the database was created by Midgard, it might contain 0 instead of NULL, so...
            $empty_conditions = $qb->expr()->orX()
                ->add($qb->expr()->isNull('c.' . $upfield))
                ->add($qb->expr()->eq('c.' . $upfield, '0'));
            $conditions->add($empty_conditions);
        } else {
            $conditions->add($qb->expr()->eq('c.' . $upfield, ':' . $upfield));
            $parameters[$upfield] = $up;
        }

        $qb->where($conditions)
            ->setParameters($parameters);

        return $qb;
    }

    public function parent()
    {
        return false;
    }

    public function has_parameters()
    {
        return $this->get_collection('midgard_parameter')->is_empty($this->guid);
    }

    public function list_parameters($domain = false)
    {
        $constraints = array();
        if ($domain) {
            $constraints[] = array("domain", "=", $domain);
        }

        return $this->get_collection('midgard_parameter')->find($this->guid, $constraints);
    }

    public function find_parameters(array $constraints = array())
    {
        return $this->get_collection('midgard_parameter')->find($this->guid, $constraints);
    }

    public function delete_parameters(array $constraints = array())
    {
        return $this->get_collection('midgard_parameter')->delete($this->guid, $constraints);
    }

    public function purge_parameters(array $constraints = array())
    {
        return $this->get_collection('midgard_parameter')->purge($this->guid, $constraints);
    }

    public function get_parameter($domain, $name)
    {
        if (!$this->guid) {
            return false;
        }
        $qb = connection::get_em()->createQueryBuilder();
        $qb
            ->select('c.value')
            ->from('midgard:midgard_parameter', 'c')
            ->where('c.domain = :domain AND c.name = :name AND c.parentguid = :parentguid')
            ->setParameters(array('domain' => $domain, 'name' => $name, 'parentguid' => $this->guid));

        // workaround for http://www.doctrine-project.org/jira/browse/DDC-2655
        try {
            return $qb->getQuery()->getOneOrNullResult(Query::HYDRATE_SINGLE_SCALAR);
        } catch (\Doctrine\ORM\NoResultException $e) {
            return null;
        }
    }

    public function set_parameter($domain, $name, $value)
    {
        $constraints = array(
            array('domain', '=', $domain),
            array('name', '=', $name),
        );
        $params = $this->get_collection('midgard_parameter')->find($this->guid, $constraints);

        // check value
        if ($value === false || $value === null || $value === "") {
            if (count($params) == 0) {
                exception::not_exists();
                return false;
            }
            foreach ($params as $param) {
                $stat = $param->delete();
            }
            return $stat;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
        }

        $om = new objectmanager(connection::get_em());

        try {
            // create new
            if (count($params) == 0) {
                $parameter = $om->new_instance(connection::get_em()->getClassMetadata('midgard:midgard_parameter')->getName());
                $parameter->parentguid = $this->guid;
<?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.");
        }
    }

}
                $parameter->domain = $domain;
<?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.");
        }
    }

}
                $parameter->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.");
        }
    }

}
                $parameter->value = $value;
<?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.");
        }
    }

}
                $om->create($parameter);
            }
            // use existing
            else {
                $parameter = array_shift($params);
                $parameter->value = $value;
                $om->update($parameter);
            }
            midgard_connection::get_instance()->set_error(MGD_ERR_OK);
            return true;
        } catch (\Exception $e) {
            exception::internal($e);
            return false;
        }
    }

    /**
     * The signature is a little different from original, because Doctrine doesn't support func_get_args() in proxies
     */
    public function parameter($domain, $name, $value = '__UNINITIALIZED__')
    {
        if ($value === '__UNINITIALIZED__') {
            return $this->get_parameter($domain, $name);
        }
        return $this->set_parameter($domain, $name, $value);
    }

    public function has_attachments()
    {
        return $this->get_collection('midgard_attachment')->is_empty($this->guid);
    }

    public function list_attachments()
    {
        return $this->get_collection('midgard_attachment')->find($this->guid, array());
    }

    public function find_attachments(array $constraints = array())
    {
        return $this->get_collection('midgard_attachment')->find($this->guid, $constraints);
    }

    public function delete_attachments(array $constraints = array())
    {
        return $this->get_collection('midgard_attachment')->delete($this->guid, $constraints);
    }

    /**
     *
     * @param array $constraints
     * @param boolean $delete_blob
     * @return boolean False if one or more attachments couldn't be deleted
     * @todo Implement delete_blob & return value
     */
    public function purge_attachments(array $constraints = array(), $delete_blob = true)

    {
        return $this->get_collection('midgard_attachment')->purge($this->guid, $constraints);
    }

    public function create_attachment($name, $title = '', $mimetype = '')
    {
        $existing = $this->get_collection('midgard_attachment')->find($this->guid, array('name' => $name));
        if (count($existing) > 0) {
            exception::object_name_exists();
            return null;
        }
        $om = new objectmanager(connection::get_em());

        $att = $om->new_instance(connection::get_em()->getClassMetadata('midgard:midgard_attachment')->getName());

        $att->parentguid = $this->guid;
<?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.");
        }
    }

}
        $att->title = $title;
<?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.");
        }
    }

}
        $att->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.");
        }
    }

}
        $att->mimetype = $mimetype;
<?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 {
            $om->create($att);
            midgard_connection::get_instance()->set_error(MGD_ERR_OK);
            return $att;
        } catch (\Exception $e) {
            exception::internal($e);
            return null;
        }
    }

    public static function serve_attachment($guid)

    {
        return false;
    }

    /**
     * @todo: Tests indicate that $check_dependencies is ignored in the mgd2 extension,
     * so we might consider ignoring it, too
     */
    public function purge($check_dependencies = true)
    {
        if (empty($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.");
        }
    }

}
            // This usually means that the object has been purged already
            exception::not_exists();
            return false;
        }
        if (   $check_dependencies
            && $this->has_dependents()) {
            exception::has_dependants();
            return false;
        }

        try {
            $om = new objectmanager(connection::get_em());

            $om->purge($this);
        } catch (\Doctrine\ORM\EntityNotFoundException $e) {
            exception::not_exists();
            return false;
        } catch (\Exception $e) {
            exception::internal($e);
            return false;
        }
        midgard_connection::get_instance()->set_error(MGD_ERR_OK);

        return true;
    }

    public static function undelete($guid)
    {
        return \midgard_object_class::undelete($guid);
    }

    public function connect($signal, $callback, $user_data)

    {
        return false;
    }

    public static function new_query_builder()
    {
        return new \midgard_query_builder(get_called_class());
    }

    public static function new_collector($field, $value)
    {
        return new \midgard_collector(get_called_class(), $field, $value);
    }

    public static function new_reflection_property()
    {
        return new \midgard_reflection_property(get_called_class());
    }

    public function set_guid($guid)
    {
        parent::__set('guid', $guid);
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
    }

    public function emit($signal)

    {
        return false;
    }

    /**
     * Helper for managing the isapproved and islocked metadata properties
     *
     * @param string $action the property to manage (either approve or lock)
     * @param bool $value
     * @return boolean
     */
    private function manage_meta_property($action, $value)
    {
        if (!($this instanceof metadata_interface)) {
            exception::no_metadata();
            return false;
        }
        $user = connection::get_user();
        if ($user === null) {
            exception::access_denied();
            return false;
        }
        if ($action == 'lock') {
            $flag = 'islocked';
        } elseif ($action == 'approve') {
            $flag = 'isapproved';
        } else {
            throw new exception('Unsupported action ' . $action);
        }
        // same val
        if ($this->__get('metadata')->$flag === $value) {
            return false;
        }
        if ($value === false) {
            $action = 'un' . $action;
        }

        if ($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.");
        }
    }

}
            try {
                $om = new objectmanager(connection::get_em());

                $om->{$action}($this);
            } catch (\Exception $e) {
                exception::internal($e);
                return false;
            }
        }
        midgard_connection::get_instance()->set_error(MGD_ERR_OK);

        return true;
    }

    public function approve()
    {
        return $this->manage_meta_property("approve", true);
    }

    public function is_approved()
    {
        if (!($this instanceof metadata_interface)) {
            exception::no_metadata();
            return false;
        }
        return $this->metadata_isapproved;

    }

    public function unapprove()
    {
        return $this->manage_meta_property("approve", false);
    }

    public function lock()
    {
        if ($this->is_locked()) {
            exception::object_is_locked();
            return false;
        }
        return $this->manage_meta_property("lock", true);
    }

    public function is_locked()
    {
        if (!($this instanceof metadata_interface)) {
            exception::no_metadata();
            return false;
        }
        return $this->metadata_islocked;

    }

    public function unlock()
    {
        return $this->manage_meta_property("lock", false);
    }

    public function get_workspace()
    {
        return false;
    }
}

Push — master ( 5ddc8c...aac2ef )

object::get_workspace() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

flack / midgard-portable

Push — master ( 5ddc8c...aac2ef )

object::get_workspace() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
