+global\AbstractObject::add()

Complexity

Conditions	25
Paths	1321

Size

Total Lines	154
Code Lines	83

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	0

<?php
    public function add(
        $class,
        $options = null,
        $template_spot = null,
        $template_branch = null
    ) {
        if (is_array($class)) {
            if (!$class[0]) {
                throw $this->exception('When passing class as array, use ["Class", "option"=>123] format')
                    ->addMoreInfo('class', var_export($class, true));
            }
            $o = $class;
            $class = $o[0];
            unset($o[0]);
            $options = $options ? array_merge($options, $o) : $o;
        }

        if (is_string($options)) {
            $options = array('name' => $options);
        }
        if (!is_array($options)) {
            $options = array();
        }

        if (is_object($class)) {
            // Object specified, just add the object, do not create anything
            if (!($class instanceof self)) {
                throw $this->exception(
                    'You may only add objects based on AbstractObject'
                );
            }
            if (!$class->short_name) {
                $class->short_name = str_replace('\\', '_', strtolower(get_class($class)));
            }
            if (!$class->app) {
                $class->app = $this->app;
                $class->api = $this->app; // compatibility with ATK 4.2 and lower

The property AbstractObject::$api has been deprecated with message: 4.3.0 Left for compatibility with ATK 4.2 and lower, use ->app instead

            }
            $class->short_name = $this->_unique_element($class->short_name);
            $class->name = $this->_shorten($this->name.'_'.$class->short_name);

            $this->elements[$class->short_name] = $class;
            if ($class instanceof AbstractView) {
                /** @type AbstractView $class */
                $class->owner->elements[$class->short_name] = true;
            }
            $class->owner = $this;
            if ($class instanceof AbstractView) {
                /** @type AbstractView $class */
                // Scrutinizer complains that $this->template is not defined and it really is not :)
                if (!isset($this->template) || !$this->template) {

The property template does not exist. Did you maybe forget to declare it?

                    $class->initializeTemplate($template_spot, $template_branch);
                }
            }

            return $class;
        }

        if (!is_string($class) || !$class) {
            throw $this->exception('Class is not valid')
                ->addMoreInfo('class', $class);
        }

        $class = str_replace('/', '\\', $class);

        if ($class[0] == '.') {
            // Relative class name specified, extract current namespace
            // and make new class name relative to this namespace
            $ns = get_class($this);
            $ns = substr($ns, 0, strrpos($ns, '\\'));
            $class = $ns.'\\'.substr($class, 2);
        }

        $short_name = isset($options['name'])
            ? $options['name']
            : str_replace('\\', '_', strtolower($class));

        // Adding same controller twice will return existing one
        if (isset($this->elements[$short_name])) {
            if ($this->elements[$short_name] instanceof AbstractController) {
                return $this->elements[$short_name];
            }
        }

        $short_name = $this->_unique_element($short_name);

        if (isset($this->elements[$short_name])) {
            throw $this->exception($class.' with requested name already exists')
                ->addMoreInfo('class', $class)
                ->addMoreInfo('new_short_name', $short_name)
                ->addMoreInfo('object', $this)
                ->addMoreInfo('counts', json_encode($this->_element_name_counts))
                ->addThis($this);
        }

        $class_name_nodash = str_replace('-', '', $class);
        /*
         * Even though this might break some applications,
         * your loading must be configured properly instead
         * of relying on this
         *
        if (!class_exists($class_name_nodash, false)
            && isset($this->app->pathfinder)
        ) {
            $this->app->pathfinder->loadClass($class);
        }*/
        $element = new $class_name_nodash($options);

        if (!($element instanceof self)) {
            throw $this->exception(
                'You can add only classes based on AbstractObject'
            );
        }

        $element->owner = $this;
        $element->app = $this->app;
        $element->api = $this->app; // compatibility with ATK 4.2 and lower

The property AbstractObject::$api has been deprecated with message: 4.3.0 Left for compatibility with ATK 4.2 and lower, use ->app instead

        $element->name = $this->_shorten($this->name.'_'.$short_name);
        $element->short_name = $short_name;

        if (!$element->auto_track_element) {
            // dont store extra reference to models and controlers
            // for purposes of better garbage collection
            $this->elements[$short_name] = true;
        } else {
            $this->elements[$short_name] = $element;
        }

        // Initialize template before init() starts
        if ($element instanceof AbstractView) {
            $element->initializeTemplate($template_spot, $template_branch);
        }

        // Avoid using this hook. Agile Toolkit creates LOTS of objects,
        // so you'll get significantly slower code if you try to use this
        $this->app->hook('beforeObjectInit', array(&$element));

        // Initialize element
        $element->init();

        // Make sure init()'s parent was called. It's a popular coder's mistake.
        if (!$element->_initialized) {
            throw $element->exception(
                'You should call parent::init() when you override it'
            )
                ->addMoreInfo('object_name', $element->name)
                ->addMoreInfo('class', get_class($element));
        }

        // Great hook to affect children recursively
        $this->hook('afterAdd', array($element));

        return $element;
    }