SmartWeb\ModuleTesting\Codeception\Template\TemplateFactory

Complexity

Total Complexity

9

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	registerTemplate()	0	8	1
A	validateTemplatePath()	0	6	2
A	getTemplate()	0	4	1
A	resolveTemplate()	0	7	1
A	resolveTemplatePath()	0	4	1
A	prepareTemplatePath()	0	6	2

<?php


namespace SmartWeb\ModuleTesting\Codeception\Template;

use Illuminate\Contracts\Filesystem\FileNotFoundException;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\File;
use Illuminate\Support\Str;
use SmartWeb\ModuleTesting\Codeception\Exceptions\TemplateNotFound;


class TemplateFactory implements TemplateFactoryInterface
{
    
    /**
     * @var string[]
     */
    protected static $cachedTemplates = [];
    
    /**
     * @var array
     */
    protected static $templates = [
        'test' => [
            'unit' => self::DEFAULT_TEMPLATE_DIR . 'test/unit.tpl',
        ],
        'cest' => [
            'integration' => self::DEFAULT_TEMPLATE_DIR . 'cest/integration.tpl',
        ],
    ];
    
    /**
     * @var string
     */
    protected $templatesPath;
    
    /**
     * TemplateFactory constructor.
     *
     * @param string $templatesPath
     */
    public function __construct(string $templatesPath = self::DEFAULT_TEMPLATE_DIR)
    {
        $this->templatesPath = $templatesPath;
    }
    
    /**
     * @param string $name
     * @param string $path
     *
     * @return bool
     * @throws TemplateNotFound
     */
    public static function registerTemplate(string $name, string $path) : bool
    {
        self::validateTemplatePath($path);
        $before = static::$templates;
        Arr::set(static::$templates, $name, $path);
        
        return ($before == static::$templates);
    }
    
    /**
     * @param string $path
     *
     * @throws TemplateNotFound
     */
    protected static function validateTemplatePath(string $path)
    {
        if (!File::exists($path)) {
            throw new TemplateNotFound($path);
        }
    }
    
    /**
     * @param string $path
     *
     * @return TemplateInterface
     * @throws FileNotFoundException
     */
    public function getTemplate(string $path) : TemplateInterface
    {
        return new Template($this->resolveTemplate($path));
    }
    
    /**
     * @param string $path
     *
     * @return string
     * @throws FileNotFoundException
     */
    private function resolveTemplate(string $path) : string
    {
        $path = $this->resolveTemplatePath($path);
        self::validateTemplatePath($path);
        
        return static::$cachedTemplates[$path] = static::$cachedTemplates[$path] ?? File::get($path);
    }
    
    /**
     * @param string $path
     *
     * @return string
     */
    protected function resolveTemplatePath(string $path) : string
    {
        return Arr::get(static::$templates, $path, $this->templatesPath . $this->prepareTemplatePath($path));
    }
    
    /**
     * @param string $path
     *
     * @return string
     */
    protected function prepareTemplatePath(string $path) : string
    {
        return Str::endsWith($path, '.' . self::TEMPLATE_FILE_EXT)
            ? $path
            : $path . '.' . self::TEMPLATE_FILE_EXT;
    }
    
}