CoreExecuteDelegator::helperInjector() - Code Metrics - Inspection of "Merge commit '02d90fc59e135e4c790041a36c97502de555..." - webstream-framework/WebStream - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — feature/0.7.0 ( 54b1aa...9c1bf9 )

by Ryuichi
created 2018-02-02 15:32 UTC
CoreExecuteDelegator::helperInjector() B

↳ Parent: CoreExecuteDelegator
Complexity

Conditions	6
Paths	7
Size

Total Lines	37
Code Lines	18
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	6
eloc	18
nc	7
nop	2
dl	0
loc	37
rs	8.439
c	0
b	0
f	0
<?php
namespace WebStream\Delegate;

use WebStream\Core\CoreInterface;
use WebStream\Core\CoreController;
use WebStream\Core\CoreService;
use WebStream\Core\CoreModel;
use WebStream\Core\CoreView;
use WebStream\Core\CoreHelper;
use WebStream\Cache\Driver\CacheDriverFactory;
use WebStream\Container\Container;
use WebStream\Annotation\Attributes\Filter;
use WebStream\Annotation\Attributes\Header;
use WebStream\Annotation\Attributes\Template;
use WebStream\Exception\ApplicationException;
use WebStream\Exception\SystemException;
use WebStream\Exception\DelegateException;
use WebStream\Exception\Extend\AnnotationException;
use WebStream\Exception\Extend\MethodNotFoundException;
use WebStream\Util\CommonUtils;
use Doctrine\Common\Annotations\AnnotationException as DoctrineAnnotationException;
filter:
    dependency_paths: ["lib/*"]

/**
 * CoreExecuteDelegator
 * @author Ryuichi TANAKA.
 * @since 2015/02/25
 * @version 0.4
 */
class CoreExecuteDelegator
{
    use CommonUtils;

    /**
     * @var CoreInterface インスタンス
     */
    private $instance;

    /**
     * @var CoreInterface 注入済みインスタンス
     */
    private $injectedInstance;

    /**
     * @var Container 依存コンテナ
     */
    private $container;

    /**
     * @var Logger ロガー
filter:
    dependency_paths: ["lib/*"]
     */
    private $logger;

    /**
     * @var AnnotationContainer アノテーション
filter:
    dependency_paths: ["lib/*"]
     */
    private $annotation;

    /**
     * @var array<AnnotationContainer> 例外ハンドラリスト
     */
    private $exceptionHandler;

    /**
     * constructor
     */
    public function __construct(CoreInterface $instance, Container $container)
    {
        $this->instance = $instance;
        $this->container = $container;
        $this->logger = $container->logger;
class Id
{
    public $id;

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

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
    }

    /**
     * method missing
     */
    public function __call($method, $arguments)
    {
        return $this->run($method, $arguments);
    }

    /**
     * overload getter
     */
    public function __get($name)
    {
        return $this->getInstance()->{$name};
    }

    /**
     * 処理を実行する
     * @param string メソッド名
     * @param array 引数リスト
     */

    public function run($method, $arguments = [])
    {
        // すでに注入済みのインスタンスの場合、そのまま実行
        if ($this->injectedInstance !== null) {
            return $this->execute($method, $arguments);
        }

        try {
            $result = null;
            if ($this->instance instanceof CoreController) {
                $this->controllerInjector($this->getOriginMethod($method), $arguments);
            } elseif ($this->instance instanceof CoreService) {
                $result = $this->serviceInjector($this->getOriginMethod($method), $arguments);
            } elseif ($this->instance instanceof CoreModel) {
                $result = $this->modelInjector($this->getOriginMethod($method), $arguments);
            } elseif ($this->instance instanceof CoreView) {
                $this->viewInjector($method, $arguments);
            } elseif ($this->instance instanceof CoreHelper) {
                $result = $this->helperInjector($this->getOriginMethod($method), $arguments);
            }

            return $result;
        } catch (DoctrineAnnotationException $e) {
            throw new AnnotationException($e);
        } catch (DelegateException $e) {
            // すでにデリゲート済み例外の場合はそのままスロー
            // カスタムアノテーション定義で発生する
            throw $e;
        } catch (\Exception $e) {
            $exceptionClass = get_class($e);
            switch ($exceptionClass) {
                case "Exception":
                case "LogicException":
                    $e = new ApplicationException($e->getMessage(), 500, $e);
                    break;
                case "RuntimeException":
                    $e = new SystemException($e->getMessage(), 500, $e);
                    break;
            }

            $exception = new ExceptionDelegator($this->getInstance(), $e, $method);
            $exception->inject('logger', $this->logger);

            if ($this->annotation !== null && is_array($this->annotation->exceptionHandler)) {
                $exception->setExceptionHandler($this->annotation->exceptionHandler);
            }
            $exception->raise();
        }
    }

    /**
     * オリジナルのインスタンスを返却する
     * @return CoreInterface インスタンス
     */
    public function getInstance()
    {
        return $this->injectedInstance ?: $this->instance;
    }

    /**
     * メソッドを実行する
     * @param string メソッド名
     * @param array 引数リスト
     */

    private function execute($method, $arguments)
    {
        // serviceの場合、modelの探索に行くためエラーにはしない
        if (!($this->injectedInstance instanceof CoreService) && !method_exists($this->injectedInstance, $method)) {
            $class = get_class($this->injectedInstance);
            throw new MethodNotFoundException("${class}#${method} is not defined.");
        }

        return call_user_func_array([$this->injectedInstance, $method], $arguments);
    }

    /**
     * Controllerに注入する
     * @param string メソッド名
     * @param array 引数リスト
     */

    private function controllerInjector($method, $arguments)
    {
        if (!method_exists($this->instance, $method)) {
            $this->injectedInstance = $this->instance;
            $this->instance = null;
            $class = get_class($this->instance);
            throw new MethodNotFoundException("${class}#${method} is not defined.");
        }

        $applicationInfo = $this->container->applicationInfo;


        // テンプレートキャッシュチェック
        $pageName = $this->container->coreDelegator->getPageName();
        $pageName = $this->container->coreDelegator->getPageName();
        $cacheFile = $applicationInfo->cachePrefix . $this->camel2snake($pageName) . "-" . $this->camel2snake($method);


        $factory = new CacheDriverFactory();
        $config = new Container(false);
        $config->cacheDir = $applicationInfo->applicationRoot . "/app/views/" . $applicationInfo->cacheDir;

        $config->classPrefix = "view_cache";

        $cache = $factory->create("WebStream\Cache\Driver\TemporaryFile", $config);
        $cache->inject('logger', $this->logger);
        $data = $cache->get($cacheFile);

        if ($data !== null) {
            $this->logger->debug("Template cache read success: $cacheFile.cache");
            echo $data;

            return;
        }

        $resolver = new Resolver($this->container);
        $model = $resolver->runService() ?: $resolver->runModel();

        // アノテーション注入処理は1度しか行わない
        if ($this->injectedInstance === null) {
            $annotation = $this->container->annotationDelegator->read($this->instance, $method);
            $annotation = $this->container->annotationDelegator->read($this->instance, $method);
            $annotationClosure = function ($classpath) use ($annotation) {
                if (array_key_exists($classpath, $annotation->annotationInfoList)) {
                    return $annotation->annotationInfoList[$classpath];
                }
                return null;
            };

            // @Header
            $header = $annotationClosure(Header::class);

            // $mimeType = $this->annotation->header->mimeType;

            // @Filter
            $filter = $annotationClosure(Filter::class);

            // @Template
            $template = $annotationClosure(Template::class);


            // $template = $this->annotation->template;

            // custom annotation
            // $this->instance->__customAnnotation($this->annotation->customAnnotations);

            // 各アノテーションでエラーがあった場合この時点で例外を起こす。
            // 例外発生を遅延実行させないとエラーになっていないアノテーション情報が取れない
            $exception = $annotation->exception;
            if ($exception instanceof ExceptionDelegator) {
                if ($this->annotation->exceptionHandler !== null) {
                    $this->exceptionHandler = $this->annotation->exceptionHandler;
                }
                $exception->inject('logger', $this->logger);
                $exception->setExceptionHandler($this->exceptionHandler);
                $exception->raise();
            }

            // initialize filter
            $container = $this->container;
            $container->model = $model;

            foreach ($filter->initialize as $refMethod) {
                $refMethod->invokeArgs($this->instance, [$container]);
            }

            // before filter
            foreach ($filter->before as $refMethod) {
                $refMethod->invoke($this->instance);
            }

            $this->injectedInstance = $this->instance;
            $this->execute($method, $arguments);

            // draw template
            if ($template !== null) {
                $view = $resolver->runView();
                $view->setTemplateEngine($template->engine);
                $view->draw([
                    "model" => $model,
                    "helper" => $resolver->runHelper(),
                    "mimeType" => $mimeType

                ]);

                if ($template->cacheTime !== null) {
                    $cacheFile = $applicationInfo->cachePrefix . $this->camel2snake($pageName) . "-" . $this->camel2snake($method);
                    $view->templateCache($cacheFile, ob_get_contents(), $template->cacheTime);
                }
            }

            // after filter
            foreach ($filter->after as $refMethod) {
                $refMethod->invoke($this->injectedInstance);
            }

            $this->instance = null;
        }
    }

    /**
     * Serviceに注入する
     * @param string メソッド名
     * @param array 引数リスト
     */

    private function serviceInjector($method, $arguments)
    {
        // アノテーション注入処理は1度しか行わない
        if ($this->injectedInstance === null) {
            $this->annotation = $this->container->annotationDelegator->read($this->instance, $method);


            // @Filter
            $filter = $this->annotation->filter;

            // @ExceptionHandler
            $this->exceptionHandler = $this->annotation->exceptionHandler;

            // custom annotation
            $this->instance->__customAnnotation($this->annotation->customAnnotations);

            // 各アノテーションでエラーがあった場合この時点で例外を起こす。
            // 例外発生を遅延実行させないとエラーになっていないアノテーション情報が取れない
            $exception = $this->annotation->exception;
            if ($exception instanceof ExceptionDelegator) {
                if ($this->annotation->exceptionHandler !== null) {
                    $this->exceptionHandler = $this->annotation->exceptionHandler;
                }
                $exception->inject('logger', $this->logger);
                $exception->setExceptionHandler($this->exceptionHandler);
                $exception->raise();
            }

            foreach ($filter->initialize as $refMethod) {
                $refMethod->invokeArgs($this->instance, [$this->container]);
            }

            $this->injectedInstance = $this->instance;
            $this->instance = null;
        }

        return $this->execute($method, $arguments);
    }

    /**
     * Modelに注入する
     * @param string メソッド名
     * @param array 引数リスト
     */

    private function modelInjector($method, $arguments)
    {
        // アノテーション注入処理は1度しか行わない
        if ($this->injectedInstance === null) {
            $this->annotation = $this->container->annotationDelegator->read($this->instance, $method);


            // @Filter
            $filter = $this->annotation->filter;

            // custom annotation
            $this->instance->__customAnnotation($this->annotation->customAnnotations);

            if ($this->exceptionHandler === null) {

                $this->exceptionHandler = $this->annotation->exceptionHandler;
            }

            // 各アノテーションでエラーがあった場合この時点で例外を起こす。
            // 例外発生を遅延実行させないとエラーになっていないアノテーション情報が取れない
            $exception = $this->annotation->exception;
            if ($exception instanceof ExceptionDelegator) {
                if ($this->annotation->exceptionHandler !== null) {
                    $this->exceptionHandler = $this->annotation->exceptionHandler;
                }
                $exception->inject('logger', $this->logger);
                $exception->setExceptionHandler($this->annotation->exceptionHandler);
                $exception->raise();
            }

            $initializeContainer = new Container(false);
            $initializeContainer->connectionContainerList = $this->annotation->database;

            $initializeContainer->queryAnnotations = $this->annotation->query;


            foreach ($filter->initialize as $refMethod) {
                $refMethod->invokeArgs($this->instance, [$initializeContainer]);
            }

            $this->injectedInstance = $this->instance;
            $this->instance = null;
        }

        return $this->execute($method, $arguments);
    }

    /**
     * Viewに注入する
     * @param string メソッド名
     * @param array 引数リスト
     */

    private function viewInjector($method, $arguments)
    {
        // アノテーション注入処理は1度しか行わない
        if ($this->injectedInstance === null) {
            $this->annotation = $this->container->annotationDelegator->read($this->instance, $method);


            // @Filter
            $filter = $this->annotation->filter;

            // 各アノテーションでエラーがあった場合この時点で例外を起こす。
            // 例外発生を遅延実行させないとエラーになっていないアノテーション情報が取れない
            $exception = $this->annotation->exception;
            if ($exception instanceof ExceptionDelegator) {
                $exception->inject('logger', $this->logger);
                $exception->raise();
            }

            foreach ($filter->initialize as $refMethod) {
                $refMethod->invokeArgs($this->instance, [$this->container]);
            }

            $this->injectedInstance = $this->instance;
            $this->instance = null;
        }

        $this->execute($method, $arguments);
    }

    /**
     * Helperに注入する
     * @param string メソッド名
     * @param array 引数リスト
     */

    private function helperInjector($method, $arguments)
    {
        // アノテーション注入処理は1度しか行わない
        if ($this->injectedInstance === null) {
            $this->annotation = $this->container->annotationDelegator->read($this->instance, $method);


            // @Filter
            $filter = $this->annotation->filter;

            // custom annotation
            $this->instance->__customAnnotation($this->annotation->customAnnotations);

            if ($this->exceptionHandler === null) {

                $this->exceptionHandler = $this->annotation->exceptionHandler;
            }

            // 各アノテーションでエラーがあった場合この時点で例外を起こす。
            // 例外発生を遅延実行させないとエラーになっていないアノテーション情報が取れない
            $exception = $this->annotation->exception;
            if ($exception instanceof ExceptionDelegator) {
                if ($this->annotation->exceptionHandler !== null) {
                    $this->exceptionHandler = $this->annotation->exceptionHandler;
                }
                $exception->inject('logger', $this->logger);
                $exception->setExceptionHandler($this->annotation->exceptionHandler);
                $exception->raise();
            }

            foreach ($filter->initialize as $refMethod) {
                $refMethod->invokeArgs($this->instance, [$this->container]);
            }

            $this->injectedInstance = $this->instance;
            $this->instance = null;
        }

        return $this->execute($method, $arguments);
    }

    /**
     * 実メソッド名を返却する
     * @param  stirng $method エイリアスメソッド名
filter:
    dependency_paths: ["lib/*"]
     * @return stirng 実メソッド名
     */
    private function getOriginMethod($method)
    {
        // 実メソッドが定義済みの場合、エイリアスメソッド参照はしない
        if (method_exists($this->instance, $method)) {
            return $method;
        }

        $annotation = $this->container->annotationDelegator->read($this->instance, $method, "WebStream\Annotation\Attributes\Alias");


        $originMethod = null;
        foreach ($annotation->alias as $alias) {
            if ($originMethod !== null && $alias->{$method} !== null) {
                throw new AnnotationException("Alias method of the same name is defined: $method");
            }
            if ($alias->{$method} !== null) {
                $originMethod = $alias->{$method};
            }
        }

        if ($originMethod !== null) {
            $class = get_class($this->instance);
            $this->logger->debug("Alias method found. Transfer from ${class}#${method} to ${class}#${originMethod}.");
        } else {
            $originMethod = $method;
        }

        return $originMethod;
    }
}

webstream-framework / WebStream

Push — feature/0.7.0 ( 54b1aa...9c1bf9 )

CoreExecuteDelegator::helperInjector() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
