Charcoal\Object\Content

Complexity

Total Complexity

19

Size/Duplication

Total Lines	185
Duplicated Lines	3.24 %

Coupling/Cohesion

Components	4
Dependencies	5

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	setDependencies()	0	7	1
A	setModelFactory()	0	5	1
A	modelFactory()	0	4	1
A	setActive()	0	5	1
A	setPosition()	6	17	4
A	setRequiredAclPermissions()	0	18	5
A	preSave()	0	10	1
A	preUpdate()	0	14	2
A	getActive()	0	4	1
A	getPosition()	0	4	1
A	getRequiredAclPermissions()	0	4	1

<?php

namespace Charcoal\Object;

use InvalidArgumentException;

// From Pimple
use Pimple\Container;

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

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

// From 'charcoal-translator'
use Charcoal\Translator\TranslatorAwareTrait;

// From 'charcoal-object'
use Charcoal\Object\ContentInterface;
use Charcoal\Object\AuthorableInterface;
use Charcoal\Object\AuthorableTrait;
use Charcoal\Object\RevisionableInterface;
use Charcoal\Object\RevisionableTrait;
use Charcoal\Object\TimestampableInterface;
use Charcoal\Object\TimestampableTrait;

/**
 *
 */
class Content extends AbstractModel implements

There is at least one abstract method in this class. Maybe declare it as abstract, or implement the remaining methods: hasProperty, p, properties, property

    AuthorableInterface,
    ContentInterface,
    RevisionableInterface,
    TimestampableInterface
{
    use AuthorableTrait;
    use RevisionableTrait;
    use TranslatorAwareTrait;
    use TimestampableTrait;

    /**
     * Objects are active by default
     * @var boolean
     */
    private $active = true;

    /**
     * The position is used for ordering lists
     * @var integer
     */
    private $position = 0;


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

    /**
     * @var string[]
     */
    private $requiredAclPermissions = [];

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

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

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

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

    /**
     * @param boolean $active The active flag.
     * @return Content Chainable
     */
    public function setActive($active)
    {
        $this->active = !!$active;
        return $this;
    }

    /**
     * @return boolean
     */
    public function getActive()
    {
        return $this->active;
    }

    /**
     * @param integer $position The position (for ordering purpose).
     * @throws InvalidArgumentException If the position is not an integer (or numeric integer string).
     * @return Content Chainable
     */
    public function setPosition($position)
    {
        if ($position === null) {
            $this->position = null;
            return $this;
        }

        if (!is_numeric($position)) {

This code seems to be duplicated across your project.

            throw new InvalidArgumentException(sprintf(
                'Position must be an integer, received %s',
                is_object($position) ? get_class($position) : gettype($position)
            ));
        }

        $this->position = (int)$position;
        return $this;
    }

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


    /**
     * @throws InvalidArgumentException If the ACL permissions are invalid.
     * @param  string|string[] $permissions The required ACL permissions.
     * @return Content Chainable
     */
    public function setRequiredAclPermissions($permissions)
    {
        if ($permissions === null || !$permissions) {
            $this->requiredAclPermissions = [];
            return $this;
        }
        if (is_string($permissions)) {
            $permissions = explode(',', $permissions);
            $permissions = array_map('trim', $permissions);
        }
        if (!is_array($permissions)) {
            throw new InvalidArgumentException(
                sprintf('Invalid ACL permissions. Permissions need to be an array (%s given)', gettype($permissions))
            );
        }
        $this->requiredAclPermissions = $permissions;
        return $this;
    }

    /**
     * @return string[]
     */
    public function getRequiredAclPermissions()
    {
        return $this->requiredAclPermissions;
    }

    /**
     * StorableTrait > preSave(): Called automatically before saving the object to source.
     * For content object, set the `created` and `lastModified` properties automatically
     * @return boolean
     */
    protected function preSave()
    {
        parent::preSave();

        // Timestampable properties
        $this->setCreated('now');
        $this->setLastModified('now');

        return true;
    }

    /**
     * StorableTrait > preUpdate(): Called automatically before updating the object to source.
     * For content object, set the `lastModified` property automatically.
     *
     * @param array $properties The properties (ident) set for update.
     * @return boolean
     */
    protected function preUpdate(array $properties = null)
    {
        parent::preUpdate($properties);

        // Content is revisionable
        if ($this->revisionEnabled()) {
            $this->generateRevision();
        }

        // Timestampable propertiees
        $this->setLastModified('now');

        return true;
    }
}