Webrouse\AssetMacro\AssetMacro

Complexity

Total Complexity

34

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	11

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	install()	0	5	1
A	macroAsset()	0	21	4
C	generateAssetPath()	0	60	17
C	getAssetVersion()	0	28	8
B	autodetectVersions()	0	25	4

<?php

namespace Webrouse\AssetMacro;

use Latte;
use Latte\Macros\MacroSet;
use Nette\Utils\Json;
use Nette\Utils\Strings;
use Webrouse\AssetMacro\Exceptions\AssetVersionNotFound;
use Webrouse\AssetMacro\Exceptions\DirNotFoundException;
use Webrouse\AssetMacro\Exceptions\FileNotFoundException;
use Webrouse\AssetMacro\Exceptions\InvalidArgumentException;
use Webrouse\AssetMacro\Exceptions\InvalidVariableException;

class AssetMacro extends MacroSet
{
	const VERSIONS_AUTODETECT = 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);
		$argsCount = $args === '' ? 0 : (substr_count($args, ',') + 1);

		// Validate arguments count
		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.");
		}

		$content =
			self::class . '::generateAssetPath(' .
			'%node.array, ' .
			'$basePath, ' .
			'$template->global->' . self::CONFIG_PROVIDER . ')';

		return $writer->write('echo %escape(' . $content . ')');
	}

	/**
	 * @param array $args
	 * @param string $basePath
	 * @param array $config
	 * @return string
	 */
	public static function generateAssetPath(array $args, $basePath, $config)
	{
		// Arguments
		$relativePath = $args[0];
		$format = isset($args[1]) ? $args[1] : "%url%";
		$needed = isset($args[2]) ? $args[2] : TRUE;

		// Validate arguments
		if (!is_string($relativePath)) {
			throw new InvalidArgumentException(sprintf("Asset macro: Invalid type of the first argument. Required string. Given %s.", gettype($relativePath)));
		}
		if (!is_string($format)) {
			throw new InvalidArgumentException(sprintf("Asset macro: Invalid type of the second argument. Required string. Given %s.", gettype($format)));
		}
		if (!is_bool($needed)) {
			throw new InvalidArgumentException(sprintf("Asset macro: Invalid type of the third argument. Required boolean. Given %s.", gettype($needed)));
		}

		// Validate paths
		$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) {
			if ($needed) {
				$msg = sprintf("Asset '%s' not found.", $relativePath);
				if ($config['missingAsset'] === 'exception') {
					throw new FileNotFoundException($msg);
				} elseif ($config['missingAsset'] === 'notice') {
					trigger_error($msg, E_USER_NOTICE);
				}
			}
			return '';
		}

		// Get asset version
		$versions = $config['versions'];
		if ($versions === self::VERSIONS_AUTODETECT) {
			$versions = self::autodetectVersions($absolutePath, $wwwDir, $config['autodetectPaths']);
		}
		$version = self::getAssetVersion($versions, $absolutePath, $config);

		// Generate output according format argument
		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 'version':
					return $version;
				case 'basePath':
					return $basePath;
				case 'dir':
					return dirname($relativePath);
				case 'file':
					return basename($relativePath);
				default:
					throw new InvalidVariableException(sprintf("Asset macro: Invalid variable '%s' in format '%s'. Use one of allowed variables: %%url%%, %%version%%, %%basePath%%, %%dir%%, %%file%%.", $matches[1], $format));
			}
		});
	}

	/**
	 * @param mixed $assetsVersions
	 * @param string $absolutePath
	 * @param array $config
	 * @return mixed|string
	 */
	private static function getAssetVersion($assetsVersions, $absolutePath, array $config)
	{
		// Versions can be array or path to JSON file
		if (!is_array($assetsVersions)) {
			if (!file_exists($assetsVersions)) {
				throw new FileNotFoundException(sprintf("Asset versions 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);
		switch ($config['missingVersion']) {
			case 'exception':
				throw new AssetVersionNotFound($msg);
			case 'notice':

There must be a comment when fall-through is intentional in a non-empty case body

				trigger_error($msg, E_USER_NOTICE);
			case 'ignore':
		}

		return 'unknown';
	}


	/**
	 * @param string $absolutePath
	 * @param string $wwwDir
	 * @param array $paths
	 * @return 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 FileNotFoundException(
			sprintf("None of the version files (%s) can be found in '%s' and parent directories up to www dir '%s'. " .
				"Create one of these files or set 'versions' in configuration.",
				implode(', ', $paths),
				dirname($absolutePath),
				$wwwDir
			)
		);
	}
}