Koch\DI\Engine\Context

Complexity

Total Complexity

42

Size/Duplication

Total Lines	220
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	willUse()	0	11	3
A	forVariable()	0	4	1
A	whenCreating()	0	8	2
A	forType()	0	8	2
A	wrapWith()	0	4	1
A	pickFactory()	0	17	4
A	hasWrapper()	0	11	3
A	invokeSetters()	0	13	2
A	settersFor()	0	6	2
A	wrappersFor()	0	4	1
A	createDependencies()	0	16	4
B	instantiateParameter()	0	21	5
A	determineContext()	0	10	3
A	invoke()	0	4	1
A	preferFrom()	0	10	3
A	cons()	0	6	1
A	repository()	0	4	1
A	create()	0	21	2

<?php

/**
 * Koch Framework
 * Jens-André Koch © 2005 - onwards.
 *
 * This file is part of "Koch Framework".
 *
 * License: GNU/GPL v2 or any later version, see LICENSE file.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

namespace Koch\DI\Engine;

use Koch\DI\AbstractLifecycle;
use Koch\DI\Exception\CannotFindImplementation;
use Koch\DI\Lifecycle\Factory;
use Koch\DI\Lifecycle\Value;

class Context
{
    private $parent;
    /*private $repository;*/
    private $registry  = [];
    private $variables = [];
    private $contexts  = [];
    private $types     = [];
    private $wrappers  = [];

    public function __construct($parent)
    {
        $this->parent = $parent;
    }

    public function willUse($preference)
    {
        if ($preference instanceof AbstractLifecycle) {
            $lifecycle = $preference;
        } elseif (true === is_object($preference)) {
            $lifecycle = new Value($preference);
        } else {
            $lifecycle = new Factory($preference);
        }
        array_unshift($this->registry, $lifecycle);
    }

    /**
     * @param string $name
     */
    public function forVariable($name)
    {
        return $this->variables[$name] = new Variable($this);
    }

    /**
     * @param string $type
     */
    public function whenCreating($type)

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

    {
        if (false === isset($this->contexts[$type])) {
            $this->contexts[$type] = new self($this);
        }

        return $this->contexts[$type];
    }

    /**
     * @param string $type
     */
    public function forType($type)

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

    {
        if (false === isset($this->types[$type])) {
            $this->types[$type] = new Type();
        }

        return $this->types[$type];
    }

    public function wrapWith($type)
    {
        array_push($this->wrappers, $type);
    }

    public function create($type, $nesting = [])

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

    {
        $lifecycle = $this->pickFactory($type, $this->repository()->candidatesFor($type));
        $context   = $this->determineContext($lifecycle->class);
        $wrapper   = $context->hasWrapper($type, $nesting);

        if ($wrapper) {
            return $this->create($wrapper, $this->cons($wrapper, $nesting));
        }

        $instance = $lifecycle->instantiate(
            $context->createDependencies(
                $this->repository()->getConstructorParameters($lifecycle->class),
                $this->cons($lifecycle->class, $nesting)
            )
        );

        $this->invokeSetters($context, $nesting, $lifecycle->class, $instance);

        return $instance;
    }

    public function pickFactory($type, $candidates)

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

    {
        if (count($candidates) === 0) {
            throw new CannotFindImplementation($type);
        }

        $preference = $this->preferFrom($candidates);
        if ($preference) {
            return $preference;
        }

        if (count($candidates) === 1) {
            return new Factory($candidates[0]);
        }

        return $this->parent->pickFactory($type, $candidates);
    }

    public function hasWrapper($type, $already_applied)

$already_applied does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

    {
        $wrappers = $this->wrappersFor($type);
        foreach ($wrappers as $wrapper) {
            if (false === in_array($wrapper, $already_applied, true)) {

$already_applied does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                return $wrapper;
            }
        }

        return false;
    }

    private function invokeSetters($context, $nesting, $class, $instance)
    {
        foreach ($context->settersFor($class) as $setter) {
            $context->invoke(
                $instance,
                $setter,
                $context->createDependencies(
                    $this->repository()->getParameters($class, $setter),
                    $this->cons($class, $nesting)
                )
            );
        }
    }

    private function settersFor($class)
    {
        $setters = isset($this->types[$class]) ? $this->types[$class]->setters : [];

        return array_values(array_keys(array_flip(array_merge($setters, $this->parent->settersFor($class)))));
    }

    public function wrappersFor($type)
    {
        return array_values(array_merge($this->wrappers, $this->parent->wrappersFor($type)));
    }

    public function createDependencies($parameters, $nesting)
    {
        $values = [];
        foreach ($parameters as $parameter) {
            try {
                $values[] = $this->instantiateParameter($parameter, $nesting);
            } catch (\Exception $e) {
                if ($parameter->isOptional()) {
                    break;
                }
                throw $e;
            }
        }

        return $values;
    }

    private function instantiateParameter($parameter, $nesting)

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

    {
        $hint = $parameter->getClass();
        if ($hint) {
            return $this->create($hint->getName(), $nesting);
        }

        if (true === isset($this->variables[$parameter->getName()])) {
            if ($this->variables[$parameter->getName()]->preference instanceof AbstractLifecycle) {
                return $this->variables[$parameter->getName()]->preference->instantiate([]);
            }

            if (false === is_string($this->variables[$parameter->getName()]->preference)) {
                return $this->variables[$parameter->getName()]->preference;
            }

            return $this->create($this->variables[$parameter->getName()]->preference, $nesting);
        }

        return $this->parent->instantiateParameter($parameter, $nesting);
    }

    private function determineContext($class)

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

    {
        foreach ($this->contexts as $type => $context) {
            if (true === $this->repository()->isSupertype($class, $type)) {
                return $context;
            }
        }

        return $this;
    }

    private function invoke($instance, $method, $arguments)
    {
        call_user_func_array([$instance, $method], $arguments);
    }

    private function preferFrom($candidates)

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

    {
        foreach ($this->registry as $preference) {
            if (true === $preference->isOneOf($candidates)) {
                return $preference;
            }
        }

        return false;
    }

    private function cons($head, $tail)
    {
        array_unshift($tail, $head);

        return $tail;
    }

    public function repository()

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

    {
        return $this->parent->repository();
    }
}