ObjectRevision::targetType() - Code Metrics - Inspection of "BREAKING CHANGE: Remove "objType" / "objId" in rev..." - locomotivemtl/charcoal-base - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 19dbb1...b206b9 )

by Mathieu

created 2016-07-19 13:42 UTC

ObjectRevision::targetType() A

↳ Parent: ObjectRevision

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php

namespace Charcoal\Object;

// Dependencies from `PHP`
use \InvalidArgumentException;
use \DateTime;
use \DateTimeInterface;

// From `pimple/pimple`
use \Pimple\Container;

// From `charcoal-factory`
use \Charcoal\Factory\FactoryInterface;

// From `charcoal-core`
use \Charcoal\Model\AbstractModel;

// Local namespace dependencies
use \Charcoal\Object\ObjectRevisionInterface;
use \Charcoal\Object\RevisionableInterface;

/**
 *
 */
class ObjectRevision extends AbstractModel implements ObjectRevisionInterface
{

    /**
     * Object type of this revision (required)
     * @var string $targetType
     */
    private $targetType;

    /**
     * Object ID of this revision (required)
     * @var mixed $objectId
     */
    private $targetId;

    /**
     * Revision number. Sequential integer for each object's ID. (required)
     * @var integer $revNum
     */
    private $revNum;

    /**
     * Timestamp; when this revision was created
     * @var string $revTs (DateTime)
     */
    private $revTs;

    /**
     * The (admin) user that was
     * @var string $revUser
     */
    private $revUser;

    /**
     * @var array $dataPrev
     */
    private $dataPrev;

    /**
     * @var array $dataObj
     */
    private $dataObj;

    /**
     * @var array $dataDiff
     */
    private $dataDiff;

    /**
     * @var FactoryInterface $modelFactory
     */
    private $modelFactory;

    /**
     * Dependencies
     * @param Container $container DI Container.
     * @return void
     */
    public function setDependencies(Container $container)
    {
        parent::setDependencies($container);

        $this->setModelFactory($container['model/factory']);
    }

    /**
     * @param FactoryInterface $factory The factory used to create models.
     * @return AdminScript Chainable
     */
    protected function setModelFactory(FactoryInterface $factory)
    {
        $this->modelFactory = $factory;
        return $this;
    }

    /**
     * @return FactoryInterface The model factory.
     */
    protected function modelFactory()
    {
        return $this->modelFactory;
    }

    /**
     * @param string $targetType The object type (type-ident).
     * @throws InvalidArgumentException If the obj type parameter is not a string.
     * @return ObjectRevision Chainable
     */
    public function setTargetType($targetType)
    {
        if (!is_string($targetType)) {
            throw new InvalidArgumentException(
                'Revisions obj type must be a string.'
            );
        }
        $this->targetType = $targetType;
        return $this;
    }

    /**
     * @return string
     */
    public function targetType()
    {
        return $this->targetType;
    }

    /**
     * @param mixed $targetId The object ID.
     * @return ObjectRevision Chainable
     */
    public function setTargetId($targetId)
    {
        $this->targetId = $targetId;
        return $this;
    }

    /**
     * @return mixed
     */
    public function targetId()
    {
        return $this->targetId;
    }

    /**
     * @param integer $revNum The revision number.
     * @throws InvalidArgumentException If the revision number argument is not numerical.
     * @return ObjectRevision Chainable
     */
    public function setRevNum($revNum)
    {
        if (!is_numeric($revNum)) {
            throw new InvalidArgumentException(
                'Revision number must be an integer (numeric).'
            );
        }
        $this->revNum = (int)$revNum;
        return $this;
    }

    /**
     * @return integer
     */
    public function revNum()
    {
        return $this->revNum;
    }

    /**
     * @param mixed $revTs The revision's timestamp.
     * @throws InvalidArgumentException If the timestamp is invalid.
     * @return ObjectRevision Chainable
     */
    public function setRevTs($revTs)

    {
        if ($revTs === null) {
            $this->revTs = null;
            return $this;
        }
        if (is_string($revTs)) {
            $revTs = new DateTime($revTs);
        }
        if (!($revTs instanceof DateTimeInterface)) {
            throw new InvalidArgumentException(
                'Invalid "Revision Date" value. Must be a date/time string or a DateTimeInterface object.'
            );
        }
        $this->revTs = $revTs;

        return $this;
    }

    /**
     * @return DateTime|null
     */
    public function revTs()
    {
        return $this->revTs;
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());
}
    }

    /**
     * @param string $revUser The revision user ident.
     * @throws InvalidArgumentException If the revision user parameter is not a string.
     * @return ObjectRevision Chainable
     */
    public function setRevUser($revUser)
    {
        if ($revUser === null) {
            $this->revUser = null;
            return $this;
        }
        if (!is_string($revUser)) {
            throw new InvalidArgumentException(
                'Revision user must be a string.'
            );
        }
        $this->revUser = $revUser;
        return $this;
    }

    /**
     * @return string
     */
    public function revUser()
    {
        return $this->revUser;
    }

    /**
     * @param string|array $data The previous revision data.
     * @return ObjectRevision
     */
    public function setDataPrev($data)

    {
        if (!is_array($data)) {
            $data = json_decode($data, true);
        }
        if ($data === null) {
            $data = [];
        }
        $this->dataPrev = $data;

        return $this;
    }

    /**
     * @return array
     */
    public function dataPrev()
    {
        return $this->dataPrev;
    }

    /**
     * @param array|string $data The current revision (object) data.
     * @return ObjectRevision
     */
    public function setDataObj($data)

    {
        if (!is_array($data)) {
            $data = json_decode($data, true);
        }
        if ($data === null) {
            $data = [];
        }
        $this->dataObj = $data;

        return $this;
    }

    /**
     * @return array
     */
    public function dataObj()
    {
        return $this->dataObj;
    }

     /**
      * @param array|string $data The data diff.
      * @return ObjectRevision
      */
    public function setDataDiff($data)

    {
        if (!is_array($data)) {
            $data = json_decode($data, true);
        }
        if ($data === null) {
            $data = [];
        }
        $this->dataDiff = $data;

        return $this;
    }

    /**
     * @return array
     */
    public function dataDiff()
    {
        return $this->dataDiff;
    }

    /**
     * Create a new revision from an object
     *
     * 1. Load the last revision
     * 2. Load the current item from DB
     * 3. Create diff from (1) and (2).
     *
     * @param RevisionableInterface $obj The object to create the revision from.
     * @return ObjectRevision Chainable
     */
    public function createFromObject(RevisionableInterface $obj)
    {
        $prevRev = $this->lastObjectRevision($obj);

        $this->setObjType($obj->targetType());

        $this->setObjId($obj->id());

        $this->setRevNum($prevRev->revNum() + 1);
        $this->setRevTs('now');

        $this->setDataObj($obj->data([
            'sortable'=>false
        ]));
        $this->setDataPrev($prevRev->dataObj());

        $diff = $this->createDiff();
        $this->setDataDiff($diff);

        return $this;
    }

    /**
     * @param array $dataPrev Optional. Previous revision data.
     * @param array $dataObj  Optional. Current revision (object) data.
     * @return array The diff data
     */
    public function createDiff(array $dataPrev = null, array $dataObj = null)
    {
        if ($dataPrev === null) {
            $dataPrev = $this->dataPrev();
        }
        if ($dataObj === null) {
            $dataObj = $this->dataObj();
        }
        $dataDiff = $this->recursiveDiff($dataPrev, $dataObj);
        return $dataDiff;
    }

    /**
     * Recursive arrayDiff.
     *
     * @param array $array1 First array.
     * @param array $array2 Second Array.
     * @return array The array diff.
     */
    public function recursiveDiff(array $array1, array $array2)
    {
        $diff = [];

        // Compare array1
        foreach ($array1 as $key => $value) {
            if (!array_key_exists($key, $array2)) {
                $diff[0][$key] = $value;
            } elseif (is_array($value)) {
                if (!is_array($array2[$key])) {
                    $diff[0][$key] = $value;
                    $diff[1][$key] = $array2[$key];
                } else {
                    $new = $this->recursiveDiff($value, $array2[$key]);
                    if ($new !== false) {
                        if (isset($new[0])) {
                            $diff[0][$key] = $new[0];
                        }
                        if (isset($new[1])) {
                            $diff[1][$key] = $new[1];
                        }
                    }
                }
            } elseif ($array2[$key] !== $value) {
                $diff[0][$key] = $value;
                $diff[1][$key] = $array2[$key];
            }
        }

        // Compare array2
        foreach ($array2 as $key => $value) {
            if (!array_key_exists($key, $array1)) {
                $diff[1][$key] = $value;
            }
        }

        return $diff;
    }

    /**
     * @param RevisionableInterface $obj The object  to load the last revision of.
     * @return ObjectRevision The last revision for the give object.
     */
    public function lastObjectRevision(RevisionableInterface $obj)
    {
        if ($this->source()->tableExists() === false) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            /** @todo Optionnally turn off for some models */
            $this->source()->createTable();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }

        $rev = $this->modelFactory()->create(self::class);

        $rev->loadFromQuery(
            '
            SELECT
                *
            FROM
                `'.$this->source()->table().'`
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            WHERE
                `target_type` = :target_type
            AND
                `target_id` = :target_id
            ORDER BY
                `rev_ts` desc
            LIMIT 1',
            [
                'target_type' => $obj->targetType(),

                'target_id'   => $obj->id()
            ]
        );

        return $rev;
    }
}


Push — master ( 19dbb1...b206b9 )

ObjectRevision::targetType() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace Charcoal\Object;
4
5			// Dependencies from `PHP`
6			use \InvalidArgumentException;
7			use \DateTime;
8			use \DateTimeInterface;
9
10			// From `pimple/pimple`
11			use \Pimple\Container;
12
13			// From `charcoal-factory`
14			use \Charcoal\Factory\FactoryInterface;
15
16			// From `charcoal-core`
17			use \Charcoal\Model\AbstractModel;
18
19			// Local namespace dependencies
20			use \Charcoal\Object\ObjectRevisionInterface;
21			use \Charcoal\Object\RevisionableInterface;
22
23			/**
24			*
25			*/
26			class ObjectRevision extends AbstractModel implements ObjectRevisionInterface
27			{
28
29			/**
30			* Object type of this revision (required)
31			* @var string $targetType
32			*/
33			private $targetType;
34
35			/**
36			* Object ID of this revision (required)
37			* @var mixed $objectId
38			*/
39			private $targetId;
40

locomotivemtl / charcoal-base

Push — master ( 19dbb1...b206b9 )

ObjectRevision::targetType() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like