Webrouse\AssetMacro\AssetMacro

Complexity

Total Complexity

42

Size/Duplication

Total Lines	254
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

91.67%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	install()	0	5	1
A	macroAsset()	0	17	4
B	resolveAssetPath()	0	23	6
C	formatOutput()	0	30	7
B	processArguments()	0	13	5
A	resolveManifest()	0	21	4
B	autodetectManifest()	0	26	5
A	resolveRevision()	0	10	3
A	throwError()	0	11	4
A	normalizePath()	0	23	3

<?php

namespace Webrouse\AssetMacro;

use Latte;
use Latte\Macros\MacroSet;
use Nette\Utils\Json;
use Nette\Utils\Strings;
use Nette\Utils\Validators;
use Webrouse\AssetMacro\Exceptions\AssetNotFoundException;
use Webrouse\AssetMacro\Exceptions\AssetVersionNotFound;
use Webrouse\AssetMacro\Exceptions\DirNotFoundException;
use Webrouse\AssetMacro\Exceptions\InvalidPathException;
use Webrouse\AssetMacro\Exceptions\InvalidVariableException;
use Webrouse\AssetMacro\Exceptions\ManifestNotFoundException;


class AssetMacro extends MacroSet
{

	const CONFIG_PROVIDER = 'assetMacroConfig';


	/**
	 * @param Latte\Compiler $compiler
	 */
	public static function install(Latte\Compiler $compiler)
	{
		$me = new self($compiler);
		$me->addMacro('asset', [$me, 'macroAsset']);
	}


	/**
	 * @param Latte\MacroNode $node
	 * @param Latte\PhpWriter $writer
	 * @return string
	 * @throws Latte\CompileException
	 */
	public function macroAsset(Latte\MacroNode $node, Latte\PhpWriter $writer)
	{
		$args = trim($node->args);

		// Validate arguments count
		$argsCount = $args === '' ? 0 : (substr_count($args, ',') + 1);
		if ($argsCount === 0) {
			throw new Latte\CompileException("Asset macro requires at least one argument.");
		}
		if ($argsCount > 3) {
			throw new Latte\CompileException("Asset macro must have no more than 3 arguments.");
		}

		return $writer->write(
			'echo %escape(' . self::class . '::resolveAssetPath(' .
			'%node.word, %node.array, $basePath, $template->global->' . self::CONFIG_PROVIDER . '))');
	}

    /**
     * @param string $asset     Asset relative path
     * @param array $args       Other macro arguments
     * @param string $basePath  Base path
     * @param array $config     Macro configuration
     * @return string
     */
	public static function resolveAssetPath($asset, array $args, $basePath, array $config) {
        list($path, $format, $need) = self::processArguments($asset, $args);
	    $wwwDir = self::normalizePath($config['wwwDir']);
        $manifest = self::resolveManifest($path, $need, $wwwDir, $config);
        $revision = $manifest === NULL ? NULL : self::resolveRevision($manifest, $path, $need, $config);

        // Is revision only version (query parameter) or full path to asset?
        $isVersion = $revision === NULL || strspn($revision,"./") === 0;

        // Check if asset exists
        if ($config['existCheck'] === TRUE) {
            $ds = DIRECTORY_SEPARATOR;
            $filePath = $isVersion ? ($wwwDir . $ds . $path) : ($wwwDir . $ds . self::normalizePath($revision));
            if (! file_exists($filePath)) {
                $msg = sprintf("Asset '%s' not found.", $filePath);
                self::throwError(new AssetNotFoundException($msg), $config['missingAsset'], $need);
                return '';
            }
        }

        // Format output
        return self::formatOutput($format, $basePath, $path, $revision, $isVersion);
    }

    /**
     * @param string $format         Output format
     * @param string $basePath       Base path
     * @param string $path           Asset relative path
     * @param string|null $revision  Asset revision (version or path to file)
     * @param bool   $isVersion      Is revision only version or full path?
     * @return string
     */
    private static function formatOutput($format, $basePath, $path, $revision, $isVersion)
    {
        $revision = $revision ?: 'unknown';
        $path = $isVersion ?
            sprintf("%s?v=%s", $path, $revision) :
            $revision;

        return Strings::replace($format,
            '/%([^%]+)%/',
            function ($matches) use ($basePath, $format, $path, $revision) {
                switch ($matches[1]) {
                    case 'raw':
                        return $revision;
                    case 'basePath':
                        return $basePath;
                    case 'path':
                        return $path;
                    case 'url':
                        return sprintf("%s/%s", $basePath, $path);
                    default:
                        $msg = sprintf(
                            "Asset macro: Invalid variable '%s' in format '%s'. " .
                            "Use one of allowed variables: %%raw%%, %%basePath%%, %%path%%, %%url%%.",
                            $matches[1],
                            $format
                        );
                        throw new InvalidVariableException($msg);
                }
            });
    }

    /**
     * @param string $asset  Asset path specified in macro
     * @param array $args    Macro arguments
     * @return array
     */
    private static function processArguments($asset, array $args)
    {
        $format = isset($args['format']) ? $args['format'] : (isset($args[0]) ? $args[0] : '%url%');
        $need = isset($args['need']) ? $args['need'] : (isset($args[1]) ? $args[1] : TRUE);

        Validators::assert($asset, 'string', 'path');
        Validators::assert($format, 'string', 'format');
        Validators::assert($need, 'bool', 'need');

        $path = self::normalizePath($asset);

        return [$path, $format, $need];
    }

    /**
     * @param string $asset   Asset path specified in macro
     * @param bool $need      Fail if manifest doesn't exist?
     * @param string $wwwDir  Public www dir
     * @param array $config   Macro configuration
     * @return null|array
     */
    private static function resolveManifest($asset, $need, $wwwDir, array $config) {
        $manifest = $config['manifest'];

	    // Asset revisions specified directly in configuration
        if (is_array($manifest)) {
            return $manifest;
        }

        // Path to JSON manifest
        if (is_string($manifest)) {
            if ( ! file_exists($manifest)) {
                $msg = sprintf("Manifest file not found: '%s'.", $manifest);
                self::throwError(new ManifestNotFoundException($msg), $config['missingManifest'], $need);
                return NULL;
            }
            return Json::decode(file_get_contents($manifest), Json::FORCE_ARRAY);
        }

        // Autodetect manifest path
        return self::autodetectManifest($asset, $wwwDir, $need, $config);
    }

    /**
     * @param string $asset   Asset path specified in macro
     * @param string $wwwDir  Public www dir
     * @param bool $need      Fail if asset/manifest doesn't exist?
     * @param array $config   Macro configuration
     * @return null|array
     */
    private static function autodetectManifest($asset, $wwwDir, $need, array $config) {
        // Get asset dir, there begins search manifest
        $dir = realpath($wwwDir . DIRECTORY_SEPARATOR . dirname($asset));
        if ($dir === FALSE) {
            $msg = sprintf("Parent dir of asset '%s' not found.", $asset);
            self::throwError(new DirNotFoundException($msg), $config['missingAsset'], $need);
            return NULL;
        }

        // Autodetect manifest
        $autodetectPaths = $config['autodetect'];
        while (Strings::startsWith($dir, $wwwDir)) {
            foreach ($autodetectPaths as $path) {
                $path = $dir . DIRECTORY_SEPARATOR . $path;
                if (file_exists($path)) {
                    return Json::decode(file_get_contents($path), Json::FORCE_ARRAY);
                }
            }

            $dir = dirname($dir); // go up
        }

        $msg = sprintf("Manifest not found in: %s.", implode(', ', $autodetectPaths));
        self::throwError(new ManifestNotFoundException($msg), $config['missingManifest'], $need);
        return NULL;
    }

    /**
     * @param null|array $manifest  Array of revisions
     * @param string $path          Asset path
     * @param bool $need            Fail if revision doesn't exist?
     * @param array $config         Macro configuration
     * @return null|string
     */
    private static function resolveRevision($manifest, $path, $need, array $config) {
        $revision = isset($manifest[$path]) ? $manifest[$path] : NULL;
        
        if ($revision === NULL) {
            $msg = sprintf("Revision for asset '%s' not found in manifest.", $path);
            self::throwError(new AssetVersionNotFound($msg), $config['missingRevision'], $need);
        }
        
        return $revision;
    }


	/**
	 * @param \Exception $e
	 * @param string $action
	 * @param bool $need
	 * @throws \Exception
	 */
	private static function throwError(\Exception $e, $action = 'exception', $need = TRUE)
	{
		if ($need) {
			if ($action === 'exception') {
				throw $e;

			} elseif ($action === 'notice') {
				trigger_error($e->getMessage(), E_USER_NOTICE);
			}
		}
	}

	private static function normalizePath($path, $separator = '\\/')
    {
        // Remove any kind of unicode whitespace
        $normalized = preg_replace('#\p{C}+|^\./#u', '', $path);

        // Path remove self referring paths ("/./").
        $normalized = preg_replace('#/\.(?=/)|^\./|\./$#', '', $normalized);

        // Regex for resolving relative paths
        $regex = '#\/*[^/\.]+/\.\.#Uu';

        while (preg_match($regex, $normalized)) {
            $normalized = preg_replace($regex, '', $normalized);
        }

        if (preg_match('#/\.{2}|\.{2}/#', $normalized)) {
            throw new InvalidPathException(
                sprintf("Path is outside of the defined root, path: '%s', resolved: '%s'.", $path, $normalized)
            );
        }

        return rtrim($normalized, $separator);
    }

}