ntentan\honam\engines\php\Variable

Complexity

Total Complexity

37

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
B	initialize()	0	20	8
A	__construct()	0	13	3
A	__toString()	0	3	1
A	u()	0	3	1
A	count()	0	3	1
A	unescape()	0	3	1
A	rewind()	0	7	2
A	valid()	0	7	2
A	current()	0	7	2
A	key()	0	7	2
A	next()	0	7	2
A	offsetExists()	0	3	1
A	offsetGet()	0	7	2
A	offsetSet()	0	7	2
A	offsetUnset()	0	3	1
A	__call()	0	3	1
A	__get()	0	3	1
A	__debugInfo()	0	3	2
A	getData()	0	3	1
A	getKeys()	0	3	1

<?php

namespace ntentan\honam\engines\php;

class Variable implements \ArrayAccess, \Iterator, \Countable {

    private $keys;
    private $position;
    private $data;
    private $iteratable = false;

    public static function initialize($data) {

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

        $type = gettype($data);
        switch ($type) {
            case 'object':
            case 'string':
                return new Variable($data);

            case 'array':
                return new Variable($data, array_keys($data));

            case 'NULL':
            case 'boolean':
            case 'integer':
            case 'double':
                return $data;

            default:
                throw new \ntentan\honam\ViewException("Cannot handle the $type type in templates");
        }
    }

    public function __construct($data, $keys = array()) {
        if ($data instanceof Variable) {
            $this->data = $data->getData();
            $this->keys = $data->getKeys();
        } else {
            $this->data = $data;
            $this->keys = $keys;
        }

        if ($this->data instanceof \Iterator) {
            $this->iteratable = true;
        }
    }

    public function __toString() {
        return Janitor::cleanHtml($this->data);

$this->data is of type array<integer|string,*>, but the function expects a string.

    }

    public function u() {
        return $this->unescape();
    }

    public function count() {
        return count($this->data);
    }

    public function unescape() {
        return $this->data;
    }

    public function rewind() {
        if ($this->iteratable) {
            $this->data->rewind();

The method rewind cannot be called on $this->data (of type array<integer|string,*>).

        } else {
            $this->position = 0;
        }
    }

    public function valid() {
        if ($this->iteratable) {
            return $this->data->valid();

The method valid cannot be called on $this->data (of type array<integer|string,*>).

        } else {
            return @isset($this->data[$this->keys[$this->position]]);
        }
    }

    public function current() {
        if ($this->iteratable) {
            return $this->data->current();

The method current cannot be called on $this->data (of type array<integer|string,*>).

        } else {
            return Variable::initialize($this->data[$this->keys[$this->position]]);
        }
    }

    public function key() {
        if ($this->iteratable) {
            return $this->data->key();

The method key cannot be called on $this->data (of type array<integer|string,*>).

        } else {
            return $this->keys[$this->position];
        }
    }

    public function next() {
        if ($this->iteratable) {
            $this->data->next();

The method next cannot be called on $this->data (of type array<integer|string,*>).

        } else {
            $this->position++;
        }
    }

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

    public function offsetGet($offset) {
        if (isset($this->data[$offset])) {
            return Variable::initialize($this->data[$offset]);
        } else {
            return null;
        }
    }

    public function offsetSet($offset, $value) {
        if (is_null($offset)) {
            $this->data[] = $value;
        } else {
            $this->data[$offset] = $value;
        }
    }

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

    public function __call($method, $arguments) {

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

        return Variable::initialize(call_user_func_array([$this->data, $method], $arguments));
    }

    public function __get($name) {

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

        return Variable::initialize($this->data->$name);
    }
    
    public function __debugInfo() {
        return is_array($this->data) ? $this->data : [$this->data];
    }
    
    public function getData() {
        return $this->data;
    }

    public function getKeys() {
        return $this->keys;
    }
}