Webrouse\AssetMacro\AssetMacro

Complexity

Total Complexity

37

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	install()	0	5	1
A	macroAsset()	0	17	4
A	generateAssetPath()	0	20	4
C	formatOutput()	0	29	7
B	processArguments()	0	11	5
A	processPaths()	0	14	3
B	getAssetVersion()	0	22	5
B	autodetectVersions()	0	23	4
A	throwError()	0	9	4

<?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\ManifestNotFoundException;
use Webrouse\AssetMacro\Exceptions\InvalidVariableException;


class AssetMacro extends MacroSet
{

	const REV_MANIFEST_AUTO = NULL;

	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 . '::generateAssetPath(' .
			'%node.word, %node.array, $basePath, $template->global->' . self::CONFIG_PROVIDER . '))');
	}


	/**
	 * @param string $path
	 * @param array $args
	 * @param string $basePath
	 * @param array $config
	 * @return string
	 */
	public static function generateAssetPath($path, array $args, $basePath, $config)
	{
		list($relativePath, $format, $needed) = self::processArguments($path, $args);
		list($relativePath, $absolutePath, $wwwDir) = self::processPaths($relativePath, $needed, $config);
		if ($absolutePath === FALSE) {
			return '';
		}

		// Get asset version
        try {
            $versions = $config['revManifest'] ?:
                self::autodetectVersions($absolutePath, $wwwDir, $config['autodetect']);
            $version = self::getAssetVersion($versions, $absolutePath, $needed, $config);
        } catch(ManifestNotFoundException $e) {
		    self::throwError($e, $config['missingManifest'], $needed);
            $version = 'unknown';
        }

		return self::formatOutput($format, $basePath, $relativePath, $version);
	}


	/**
	 * Generate output according given format
	 * @param string $format
	 * @param string $basePath
	 * @param string $relativePath
	 * @param string $version
	 * @return string
	 */
	private static function formatOutput($format, $basePath, $relativePath, $version)
	{
		return Strings::replace($format,
			'/%([^%]+)%/',
			function ($matches) use ($basePath, $format, $relativePath, $version) {
				switch ($matches[1]) {
					case 'url':
						return sprintf("%s/%s?v=%s", $basePath, $relativePath, $version);
                    case 'path':
                        return sprintf("%s/%s", $basePath, $relativePath);
					case 'version':
						return $version;
					case 'basePath':
						return $basePath;
					case 'dir':
						return dirname($relativePath);
					case 'file':
						return basename($relativePath);
					default:
						$msg = sprintf(
							"Asset macro: Invalid variable '%s' in format '%s'. " .
							"Use one of allowed variables: %%url%%, %%version%%, %%basePath%%, %%dir%%, %%file%%.",
							$matches[1],
							$format
						);
						throw new InvalidVariableException($msg);
				}
			});
	}


	/**
	 * @param string $path
	 * @param array $args
	 * @return array
	 */
	private static function processArguments($path, array $args)
	{
		$format = isset($args['format']) ? $args['format'] : (isset($args[0]) ? $args[0] : '%url%');
		$needed = isset($args['needed']) ? $args['needed'] : (isset($args[1]) ? $args[1] : TRUE);

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

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


	/**
	 * @param $relativePath
	 * @param $needed
	 * @param array $config
	 * @return array
	 */
	private static function processPaths($relativePath, $needed, array $config)
	{
		$relativePath = ltrim($relativePath, '\\/');
		if (($wwwDir = realpath($config['wwwDir'])) === FALSE) {
			throw new DirNotFoundException(sprintf("Www dir '%s' not found.", $config['wwwDir']));
		}

		if (($absolutePath = realpath($wwwDir . DIRECTORY_SEPARATOR . $relativePath)) === FALSE) {
            $msg = sprintf("Asset '%s' not found.", $relativePath);
            self::throwError(new AssetNotFoundException($msg), $config['missingAsset'], $needed);
		}

		return [$relativePath, $absolutePath, $wwwDir];
	}


	/**
	 * @param mixed $assetsVersions
	 * @param string $absolutePath
     * @param bool $needed
	 * @param array $config
	 * @return mixed|string
	 */
	private static function getAssetVersion($assetsVersions, $absolutePath, $needed, array $config)
	{
		// Versions can be array or path to JSON file
		if ( ! is_array($assetsVersions)) {
			if ( ! file_exists($assetsVersions)) {
				throw new ManifestNotFoundException(sprintf("Revision manifest file not found: '%s'.", $assetsVersions));
			}
			$assetsVersions = Json::decode(file_get_contents($assetsVersions), Json::FORCE_ARRAY);
		}

		foreach ($assetsVersions as $path => $hash) {
			// Test if path from version file (may be relative) is in asset path
			if (Strings::endsWith($absolutePath, $path)) {
				return $hash;
			}
		}

		$msg = sprintf("Asset macro: version of asset '%s' not found.", $absolutePath);
        self::throwError(new AssetVersionNotFound($msg), $config['missingVersion'], $needed);

        return 'unknown';
	}


    /**
     * @param $absolutePath
     * @param $wwwDir
     * @param array $paths
     * @return mixed|string
     */
	private static function autodetectVersions($absolutePath, $wwwDir, array $paths)
	{
		// Iterate over parent directories (stop in www dir)
		$dir = dirname($absolutePath);
		while (Strings::startsWith($dir, $wwwDir)) {
			foreach ($paths as $path) {
				$path = $dir . DIRECTORY_SEPARATOR . $path;
				if (file_exists($path)) {
					return $path;
				}
			}

			// Get parent directory
			$dir = dirname($dir);
		}

		throw new ManifestNotFoundException(
			sprintf("Rev. manifest not found in expected paths: (%s)." .
				"Create one of these files or set 'revManifest' in configuration.",
				implode(', ', $paths)
			)
		);
	}

    /**
     * @param \Exception $e
     * @param string $action
     * @param bool $needed
     * @throws \Exception
     */
	private static function throwError(\Exception $e, $action = 'exception', $needed = TRUE) {
        if ($needed) {
            if ($action === 'exception') {
                throw $e;
            } elseif ($action === 'notice') {
                trigger_error($e->getMessage(), E_USER_NOTICE);
            }
        }
    }

}