Silk\Type\Model

Complexity

Total Complexity

27

Size/Duplication

Total Lines	305
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes	17
Bugs	0	Features	5

20 Methods

Rating	Name	Duplication	Size	Complexity
	newQuery()	0	1	?
	save()	0	1	?
	delete()	0	1	?
	refresh()	0	1	?
A	make()	0	8	2
A	fill()	0	13	3
A	create()	0	6	1
A	query()	0	4	1
A	meta()	0	10	2
A	setId()	0	6	1
A	setObject()	0	6	1
A	aliasSet()	0	13	3
A	aliasGet()	0	8	2
A	getAliasedObject()	0	4	1
A	expandAlias()	0	4	1
A	__get()	0	21	4
A	__isset()	0	4	1
A	__set()	0	8	2
A	__call()	0	6	1
A	__callStatic()	0	4	1

<?php

namespace Silk\Type;

use Silk\Meta\ObjectMeta;
use Illuminate\Support\Collection;

/**
 * @property-read int    $id
 * @property-read object $object
 */
abstract class Model
{
    /**
     * The core model object
     * @var object
     */
    protected $object;

    /**
     * Type object property aliases
     * @var array
     */
    protected $objectAliases = [
        // 'aliasName' => 'propertyNameOnObject'

50% of this comment could be valid code. Did you maybe forget this after debugging?

    ];

    /**
     * The object type in WordPress
     */
    const OBJECT_TYPE = '';

    /**
     * The name of the primary ID property on the object
     */
    const ID_PROPERTY = '';

    /**
    * Get a new query builder for the model.
    *
    * @return \Silk\Contracts\BuildsQueries
    */
    abstract public function newQuery();

    /**
     * Save the changes to the database.
     *
     * @return $this
     */
    abstract public function save();

    /**
     * Delete the modeled record from the database.
     *
     * @return $this
     */
    abstract public function delete();

    /**
     * Reload the object from the database.
     *
     * @return $this
     */
    abstract public function refresh();

    /**
     * Make new instance.
     *
     * All provided arguments are forwarded to the constructor of the called class.
     *
     * @return static
     */
    public static function make()
    {
        if ($arguments = func_get_args()) {
            return (new \ReflectionClass(static::class))->newInstanceArgs($arguments);
        }

        return new static;
    }

    /**
     * Fill the model with an array of attributes.
     *
     * @param  array  $attributes
     *
     * @return $this
     */
    public function fill(array $attributes)
    {
        foreach ($attributes as $key => $value) {
            if ($this->expandAlias($key)) {
                $this->aliasSet($key, $value);
                continue;
            }

            $this->object->$key = $value;
        }

        return $this;
    }

    /**
     * Create a new model of the model's type, and save it to the database.
     *
     * @param  array $attributes
     *
     * @return static
     */
    public static function create($attributes = [])
    {
        $model = new static($attributes);

The call to Model::__construct() has too many arguments starting with $attributes.

        return $model->save();
    }

    /**
     * Create a new query builder instance for this model type.
     *
     * @return \Silk\Contracts\BuildsQueries
     */
    public static function query()
    {
        return (new static)->newQuery();
    }

    /**
     * Meta API for this type
     *
     * @param  string $key  Meta key to retrieve or empty to retrieve all.
     *
     * @return ObjectMeta|\Silk\Meta\Meta
     */
    public function meta($key = '')
    {
        $meta = new ObjectMeta(static::OBJECT_TYPE, $this->id);

        if ($key) {
            return $meta->get($key);
        }

        return $meta;
    }

    /**
     * Set the primary ID on the model.
     *
     * @param string|int $id  The model's ID
     *
     * @return $this
     */
    protected function setId($id)
    {
        $this->object->{static::ID_PROPERTY} = (int) $id;

        return $this;
    }

    /**
     * Set the object for the model.
     *
     * @param $object
     *
     * @return $this
     */
    protected function setObject($object)
    {
        $this->object = $object;

        return $this;
    }

    /**
     * Set a property on the aliased object.
     *
     * @param string $key   The alias name on the model
     * @param mixed  $value The value to set on the aliased object
     *
     * @return bool          True if the alias was resolved and set; otherwise false
     */
    protected function aliasSet($key, $value)
    {
        if (! $expanded = $this->expandAlias($key)) {
            return false;
        }

        if (is_object($aliased = $this->getAliasedObject())) {
            $aliased->$expanded = $value;
            return true;
        }

        return false;
    }

    /**
     * Get a property from the aliased object by the model's key.
     *
     * @param $key
     *
     * @return mixed|null
     */
    protected function aliasGet($key)
    {
        if (! $expanded = $this->expandAlias($key)) {
            return null;
        }

        return data_get($this->getAliasedObject(), $expanded);
    }

    /**
     * Get the aliased object instance.
     *
     * @return object
     */
    protected function getAliasedObject()
    {
        return $this->object;
    }

    /**
     * Expands an alias into its respective object property name.
     *
     * @param string $key  Alias key
     *
     * @return string|false  The expanded alias, or false no alias exists for the key.
     */
    protected function expandAlias($key)
    {
        return data_get($this->objectAliases, $key, false);
    }

    /**
     * Magic getter.
     *
     * @param  string $property
     *
     * @return mixed
     */
    public function __get($property)
    {
        if ($property == 'id') {
            return $this->object->{static::ID_PROPERTY};
        }

        if (in_array($property, ['object', static::OBJECT_TYPE])) {
            return $this->object;
        }

        if (! is_null($aliased = $this->aliasGet($property))) {
            return $aliased;
        }

        /**
         * Finally, hand-off the request to the wrapped object.
         * We don't check for existence as we leverage the magic __get
         * on the wrapped object as well.
         */
        return $this->object->$property;
    }

    /**
     * Magic Isset Checker.
     *
     * @return bool
     */
    public function __isset($property)
    {
        return ! is_null($this->__get($property));
    }

    /**
     * Magic setter.
     *
     * @param string $property  The property name
     * @param mixed  $value     The new property value
     */
    public function __set($property, $value)
    {
        if ($this->aliasSet($property, $value)) {
            return;
        }

        $this->object->$property = $value;
    }

    /**
     * Handle dynamic method calls into the model.
     *
     * @param  string $method
     * @param  array $arguments
     *
     * @return mixed
     */
    public function __call($method, $arguments)
    {
        $query = $this->newQuery();

        return call_user_func_array([$query, $method], $arguments);
    }

    /**
     * Handle dynamic static method calls on the model class.
     *
     * Proxies calls to direct method calls on a new instance
     *
     * @param string $method
     * @param array $arguments
     *
     * @return mixed
     */
    public static function __callStatic($method, array $arguments)
    {
        return call_user_func_array([new static, $method], $arguments);
    }
}