ntentan\nibii\RecordWrapper

Complexity

Total Complexity

57

Size/Duplication

Total Lines	323
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

94.26%

Importance

Changes	53
Bugs	8	Features	10

39 Methods

Rating	Name	Duplication	Size	Complexity
A	getData()	0	14	4
A	fetchRelatedFields()	0	14	3
A	getRelationships()	0	8	1
A	getDescription()	0	10	1
A	retrieveItem()	0	9	3
A	createNew()	0	5	1
A	__callStatic()	0	4	1
A	__set()	0	5	1
A	__get()	0	4	1
A	getTable()	0	4	1
A	save()	0	6	1
A	hasMultipleData()	0	8	2
A	setData()	0	5	1
A	offsetExists()	0	4	1
A	offsetGet()	0	8	2
A	offsetSet()	0	5	1
A	wrap()	0	10	2
A	getInvalidFields()	0	4	1
A	current()	0	4	1
A	next()	0	4	1
A	rewind()	0	4	1
A	valid()	0	4	1
A	preSaveCallback()	0	4	1
A	postSaveCallback()	0	4	1
A	preUpdateCallback()	0	4	1
A	postUpdateCallback()	0	4	1
A	getBehaviours()	0	4	1
A	__construct()	0	9	2
A	count()	0	8	2
A	__call()	0	7	2
A	expandArrayValue()	0	7	2
A	toArray()	0	15	4
A	isValid()	0	4	1
A	mergeData()	0	7	2
A	offsetUnset()	0	4	1
A	getHasMany()	0	4	1
A	getBelongsTo()	0	4	1
A	key()	0	4	1
A	usetField()	0	4	1

<?php
/*
 * The MIT License
 *
 * Copyright 2015 ekow.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

namespace ntentan\nibii;

use ntentan\utils\Utils;
use ntentan\kaikai\Cache;
use ntentan\panie\InjectionContainer;

class RecordWrapper implements \ArrayAccess, \Countable, \Iterator
{
    use \ntentan\panie\ComponentContainerTrait;
    
    protected $hasMany = [];
    protected $belongsTo = [];
    protected $manyHaveMany = [];
    protected $behaviours = [];
    protected $table;
    private $modelData = [];
    private $invalidFields;
    private $dynamicOperations;
    private $index = 0;
    private $dataSet = false;
    protected $adapter;

    public function __construct(DriverAdapter $adapter)
    {
        $this->table = Nibii::getModelTable($this);
        $this->adapter = $adapter;
        foreach($this->behaviours as $behaviour) {
            $behaviourInstance = $this->getComponentInstance($behaviour);
            $behaviourInstance->setModel($this);
        }
    }

    /**
     *
     * @return \ntentan\nibii\DriverAdapter
     */
    //protected function getDataAdapter()

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

    //{
        
        /*if(!$this->adapter)

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

        {
            $this->adapter = DriverAdapter::getDefaultInstance();
        }
        return $this->adapter;*/
    //}

    /**
     * 
     * @return ModelDescription
     */
    public function getDescription()
    {
        return Cache::read(
            (new \ReflectionClass($this))->getName() . '::desc',
            function() 
            {
                return new ModelDescription($this);
            }
        );
    }
    
    public function count()
    {
        if ($this->dataSet) {
            return count($this->getData());
        } else {
            return $this->__call('count', []);

'count' is of type string, but the function expects a object<ntentan\nibii\type>.

array() is of type array, but the function expects a object<ntentan\nibii\type>.

        }
    }

    private function retrieveItem($key)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $relationships = $this->getDescription()->getRelationships();
        if(isset($relationships[$key])) {
            return $this->fetchRelatedFields($relationships[$key]);
        } else {
            return isset($this->modelData[$key]) ? $this->modelData[$key] : null;
        }
    }

    /**
     * Create a new instance of this Model
     * @return \ntentan\nibii\RecordWrapper
     */
    public static function createNew()
    {
        $class = get_called_class();
        return InjectionContainer::resolve($class);
    }

    /**
     * @method
     * @param type $name
     * @param type $arguments
     * @return type
     */
    public function __call($name, $arguments)
    {
        if($this->dynamicOperations === null) {
            $this->dynamicOperations = new Operations($this, InjectionContainer::singleton(DriverAdapter::class));
        }
        return $this->dynamicOperations->perform($name, $arguments);
    }

    public static function __callStatic($name, $arguments)
    {
        return call_user_func_array([self::createNew(), $name], $arguments);
    }

    public function __set($name, $value)
    {
        $this->dataSet = true;
        $this->modelData[$name] = $value;
    }

    public function __get($name)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->retrieveItem($name);
    }

    public function getTable()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->table;
    }
    
    private function expandArrayValue($array, $relationships, $depth, $index = null)

The return type could not be reliably inferred; please add a @return annotation.

    {
        foreach($relationships as $name => $relationship) {
            $array[$name] = $this->fetchRelatedFields($relationship, $index)->toArray($depth);
        }
        return $array;
    }

    public function toArray($depth = 0)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $relationships = $this->getDescription()->getRelationships();
        $array = $this->modelData;
        if($depth > 0) {
            if($this->hasMultipleData()) {
                foreach($array as $i => $value) {
                    $array[$i] = $this->expandArrayValue($value, $relationships, $depth - 1, $i);
                }
            } else {
                $array = $this->expandArrayValue($array, $relationships, $depth - 1);
            }
        }
        return $array;
    }
    
    public function save()
    {
        $return = $this->__call('save', [$this->hasMultipleData()]);

'save' is of type string, but the function expects a object<ntentan\nibii\type>.

array($this->hasMultipleData()) is of type array<integer,boolean,{"0":"boolean"}>, but the function expects a object<ntentan\nibii\type>.

        $this->invalidFields = $this->dynamicOperations->getInvalidFields();
        return $return;
    }
    
    public function isValid()
    {
        return $this->__call('isValid', []);

'isValid' is of type string, but the function expects a object<ntentan\nibii\type>.

array() is of type array, but the function expects a object<ntentan\nibii\type>.

    }

    private function hasMultipleData()
    {
        if(count($this->modelData) > 0) {
            return is_numeric(array_keys($this->modelData)[0]);
        } else {
            return false;
        }
    }

    public function getData()
    {
        $data = [];
                
        if(count($this->modelData) == 0) {
            $data = $this->modelData;
        } else if($this->hasMultipleData()) {
            $data = $this->modelData;
        } else if(count($this->modelData) > 0) {
            $data[] = $this->modelData;
        }
        
        return $data;
    }

    public function setData($data)
    {
        $this->dataSet = true;
        $this->modelData = $data;
    }
    
    public function mergeData($data)
    {
        foreach($data as $key => $value) {
            $this->modelData[$key] = $value;
        }
        $this->dataSet = true;
    }

    public function offsetExists($offset)
    {
        return isset($this->modelData[$offset]);
    }

    public function offsetGet($offset)
    {
        if (is_numeric($offset)) {
            return $this->wrap($offset);
        } else {
            return $this->retrieveItem($offset);
        }
    }

    public function offsetSet($offset, $value)
    {
        $this->dataSet = true;
        $this->modelData[$offset] = $value;
    }

    public function offsetUnset($offset)
    {
        unset($this->modelData[$offset]);
    }

    private function wrap($offset)
    {
        if(isset($this->modelData[$offset])) {
            $newInstance = $this->createNew();
            $newInstance->setData($this->modelData[$offset]);
            return $newInstance;
        } else {
            return null;
        }
    }

    public function getInvalidFields()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->invalidFields;
    }

    public function getHasMany()
    {
        return $this->hasMany;
    }

    public function getBelongsTo()
    {
        return $this->belongsTo;
    }

    public function current()
    {
        return $this->wrap($this->index);
    }

    public function key()
    {
        return $this->index;
    }

    public function next()
    {
        $this->index++;
    }

    public function rewind()
    {
        $this->index = 0;
    }

    public function valid()
    {
        return isset($this->modelData[$this->index]);
    }

    private function fetchRelatedFields($relationship, $index = null)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if($index === null) {
            $data = $this->modelData;
        } else {
            $data = $this->modelData[$index];
        }
        $model = $relationship->getModelInstance();
        if(empty($data)) {
            return $model;
        } else {
            return $model->fetch($relationship->getQuery($data));
        }
    }

    public function getRelationships()
    {
        return [
            'HasMany' => $this->hasMany,
            'BelongsTo' => $this->belongsTo,
            'ManyHaveMany' => $this->manyHaveMany
        ];
    }
    
    public function usetField($field)
    {
        unset($this->modelData[$field]);
    }
    
    public function preSaveCallback()
    {
        
    }
    
    public function postSaveCallback($id)

The parameter $id is not used and could be removed.

    {
        
    }
    
    public function preUpdateCallback()
    {
        
    }
    
    public function postUpdateCallback()
    {
        
    }
    
    public function getBehaviours()
    {
        return $this->loadedComponents;
    }
}