ntentan\nibii\ORMContext

Complexity

Total Complexity

13

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

87.5%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	load()	0	9	2
A	joinModels()	0	4	1
A	getModelTable()	0	4	1
A	getClassName()	0	4	1
A	getModelName()	0	3	1
A	getInstance()	0	4	2
A	getContainer()	0	3	1
A	getCache()	0	3	1
A	getDbContext()	0	3	1
A	__destruct()	0	3	1

<?php

namespace ntentan\nibii;

use ntentan\atiaa\DbContext;
use ntentan\kaikai\Cache;
use ntentan\panie\Container;

/**
 * A collection of utility methods used as helpers for loading
 * models.
 */
class ORMContext {
    
    private $container;
    private $dbContext;
    private static $instance;
    private $cache;
    
    public function __construct(Container $container) {
        $this->container = $container;
        $this->dbContext = $container->resolve(DbContext::class);
        $this->container->bind(interfaces\ModelJoinerInterface::class)
                ->to(Resolver::class);
        $this->container->bind(interfaces\TableNameResolverInterface::class)
                ->to(Resolver::class);
        $this->container->bind(interfaces\ModelClassResolverInterface::class)
                ->to(Resolver::class);
        $this->cache = $this->container->resolve(Cache::class);
        self::$instance = $this;
    }

    /**
     * A helper for loading a method described as a string.
     * @param string $path Model name as string 
     * @return \nibii\RecordWrapper
     * @throws NibiiException
     */
    public function load($path) {
        try {
            $className = $this->getClassName($path);
            return $this->container->resolve($className);
        } catch (\ntentan\panie\exceptions\ResolutionException $e) {
            throw new
            NibiiException("Failed to load model [$path]. The class [$className] could not be found. Ensure that you have properly setup class name resolutions.");
        }
    }

    /**
     * Returns a class name for junction models needed to perform joint queries.
     * @param string $classA
     * @param string $classB
     * @return string
     */
    public function joinModels($classA, $classB) {
        return$this->container->singleton(interfaces\ModelJoinerInterface::class)
            ->getJunctionClassName($classA, $classB);
    }

    /**
     * @param RecordWrapper $instance
     */
    public function getModelTable($instance) {

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

        return$this->container->singleton(interfaces\TableNameResolverInterface::class)
            ->getTableName($instance);
    }

    public function getClassName($model, $context = null) {

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

        return $this->container->singleton(interfaces\ModelClassResolverInterface::class)
            ->getModelClassName($model, $context);
    }

    /**
     * @param string $class
     */
    public function getModelName($class) {
        return $class;
    }
    
    public static function getInstance() {
        if(self::$instance === null) throw new NibiiException("A context has not yet been initialized");
        return self::$instance;
    }
    
    public function getContainer() {
        return $this->container;
    }
    
    public function getCache() {

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

        return $this->cache;
    }
    
    public function getDbContext() {

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

        return $this->dbContext;
    }
    
    public function __destruct() {
        self::$instance = null;
    }

}