Webrouse\AssetMacro\AssetMacro

Complexity

Total Complexity

38

Size/Duplication

Total Lines	249
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	install()	0	5	1
B	macroAsset()	0	22	4
C	generateAssetPath()	0	43	8
C	processArguments()	0	44	8
B	processPaths()	0	21	6
C	getAssetVersion()	0	28	7
B	autodetectVersions()	0	25	4

<?php

namespace Webrouse\AssetMacro;

use Latte;
use Latte\Macros\MacroSet;
use Nette\Utils\Json;
use Nette\Utils\Strings;
use Tracy\Debugger;
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.word, ' .
			'%node.array, ' .
			'$basePath, ' .
			'$template->global->' . self::CONFIG_PROVIDER . ')';

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


	/**
	 * @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
		$version = self::getAssetVersion(
			$config['versions'] === self::VERSIONS_AUTODETECT ?
				self::autodetectVersions($absolutePath, $wwwDir, $config['autodetectPaths']) :
				$config['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:
						$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)
	{
		$relativePath = $path;

		// Format argument
		$format = '%url%';
		if (isset($args['format'])) {
			$format = $args['format'];

		} elseif (isset($args[0])) {
			$format = $args[0];
		}

		// Needed argument
		$needed = TRUE;
		if (isset($args['needed'])) {
			$needed = $args['needed'];

		} elseif (isset($args[1])) {
			$needed = $args[1];
		}

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

		return [$relativePath, $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) {
			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 [$relativePath, $absolutePath, $wwwDir];
	}


	/**
	 * @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':
				trigger_error($msg, E_USER_NOTICE);
				// no break
			default:
				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
			)
		);
	}

}