ElkArte\Helper\SiteCombiner

Complexity

Total Complexity

70

Size/Duplication

Total Lines	558
Duplicated Lines	0 %

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	_isStale()	0	14	4
A	_combineFiles()	0	43	6
A	_addSpare()	0	5	2
A	_addFile()	0	22	4
A	_validRequest()	0	10	2
A	_buildName()	0	20	3
A	_validDestination()	0	3	2
C	site_js_combine()	0	59	12
A	getSpares()	0	3	1
A	cssMinify()	0	8	1
B	site_js_minify()	0	41	7
B	site_css_minify()	0	39	7
A	_removeHives()	0	14	3
B	site_css_combine()	0	46	8
A	jsMinify()	0	6	3
A	removeJsHives()	0	3	1
A	_saveFiles()	0	10	2
A	removeCssHives()	0	3	1

<?php

/**
 * Used to combine CSS and JS files in to a single compressed file
 *
 * @package   ElkArte Forum
 * @copyright ElkArte Forum contributors
 * @license   BSD http://opensource.org/licenses/BSD-3-Clause (see accompanying LICENSE.txt file)
 *
 * @version 2.0 Beta 1
 */

namespace ElkArte\Helper;

use Wikimedia\Minify\JavaScriptMinifier;

The type Wikimedia\Minify\JavaScriptMinifier was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Used to combine CSS or JS files in to a single file
 *
 * What it does:
 *
 * - Checks if the files have changed, and if so, rebuilds the amalgamation
 * - Calls minification classes to reduce size of CSS and JS files, saving bandwidth
 */
class SiteCombiner
{
	/** @var array Holds all the files contents that we have joined in to one */
	private $_combine_files = [];

	/** @var string Holds the file name of our newly created file */
	private $_archive_name;

	/** @var string Holds the file names of the files in the compilation */
	private $_archive_filenames;

	/** @var string Holds the comment line to add at the start of the compressed compilation */
	private $_archive_header;

	/** @var string Holds the file data of the combined files */
	private $_cache = [];

	/** @var string Holds the file data of pre minimized files */
	private $_min_cache = [];

	/** @var string Holds the minified data of the combined files */
	private $_minified_cache;

	/** @var string The stale parameter added to the url */
	private $_archive_stale = CACHE_STALE;

	/** @var bool The parameter to indicate if minification should be run */
	private $_minify;

	/** @var string[] All files that was not possible to combine */
	private $_spares = [];

	/** @var \ElkArte\Helper\FileFunctions */
	private $fileFunc;

	/**
	 * Nothing much to do but start
	 *
	 * @param string $_archive_dir
	 * @param string $_archive_url
	 * @param bool $minimize
	 */
	public function __construct(private $_archive_dir, private $_archive_url, $minimize = true)
	{
		$this->_minify = $minimize ?? true;
		$this->fileFunc = FileFunctions::instance();
	}

	/**
	 * Combine JavaScript files in to a single file to save requests
	 *
	 * @param array $files array created by loadJavascriptFile() function
	 * @param bool $do_deferred true combines files with deferred tag, false combine other
	 *
	 * @return bool|string
	 */
	public function site_js_combine($files, $do_deferred)
	{
		if (!$this->_validRequest($files))
		{
			// Anything is spare
			$this->_addSpare($files);

			return false;
		}

		// Get the filenames and last modified time for this batch
		foreach ($files as $id => $file)
		{
			$load = (!$do_deferred && empty($file['options']['defer'])) || ($do_deferred && !empty($file['options']['defer']));

			// Get the ones that we would load locally, so we can merge them
			if (!$load)
			{
				continue;
			}

			if (!empty($file['options']['local']) && $this->_addFile($file['options']))
			{
				continue;
			}

			$this->_addSpare([$id => $file]);
		}

		// Nothing to combine
		if (count($this->_combine_files) === 0)
		{
			return true;
		}

		// Create an archive name
		$this->_buildName('.js');

		// No archive file, or a stale one, creates a new compilation
		if ($this->_isStale())
		{
			// Our buddies will be needed for this to work.
			require_once(SUBSDIR . '/Package.subs.php');

			$this->_archive_header = "/*!\n * " . $this->_archive_filenames . "\n */\n";
			$this->_combineFiles('js');

			// Minify, or not, these files
			$this->_minified_cache = $this->_minify ? $this->jsMinify($this->_cache) : trim($this->_cache);

			// Combined any pre minimized + our string
			$this->_minified_cache = $this->_min_cache . "\n" . $this->_minified_cache;

			// And save them for future users
			$this->_saveFiles();
		}

		// Return the name for inclusion in the output
		return $this->_archive_url . '/' . $this->_archive_name . $this->_archive_stale;
	}

	/**
	 * Checks if directory exists/writable and we have files
	 *
	 * @param $files
	 * @return bool
	 */
	private function _validRequest($files): bool
	{
		// No files or missing we are done
		if (empty($files))
		{
			return false;
		}

		// Directory not writable then we are done
		return $this->_validDestination();
	}

	/**
	 * Tests if the destination directory exists and is writable
	 *
	 * @return bool
	 */
	protected function _validDestination(): bool
	{
		return $this->fileFunc->isDir($this->_archive_dir) && $this->fileFunc->isWritable($this->_archive_dir);
	}

	/**
	 * Adds files to the spare list
	 *
	 * @param array $files
	 */
	protected function _addSpare($files): void
	{
		foreach ($files as $id => $file)
		{
			$this->_spares[$id] = $file;
		}
	}

	/**
	 * Add all the file parameters to the $_combine_files array
	 *
	 * What it does:
	 *
	 * - If the file has a 'stale' option defined, it will be added to the
	 *   $_stales array as well to be used later
	 * - Tags any files that are pre-minimized by filename matching .min.js
	 *
	 * @param string[] $options An array with all the passed file options:
	 * - dir
	 * - basename
	 * - file
	 * - url
	 * - stale (optional)
	 *
	 * @return bool
	 */
	private function _addFile($options): bool
	{
		if (!isset($options['dir']))
		{
			return false;
		}

		$filename = $options['dir'] . $options['basename'];
		if (!$this->fileFunc->fileExists($filename))
		{
			return false;
		}

		$this->_combine_files[$options['basename']] = [
			'file' => $filename,
			'basename' => $options['basename'],
			'url' => $options['url'],
			'filemtime' => filemtime($filename),
			'minimized' => strpos($options['basename'], '.min.js') || str_contains($options['basename'], '.min.css'),
		];

		return true;
	}

	/**
	 * Creates a new archive name
	 *
	 * @param string $type - should be one of '.js' or '.css'
	 */
	private function _buildName($type): void
	{
		global $settings;

		// Create this groups archive name
		$this->_archive_filenames = '';
		foreach ($this->_combine_files as $file)
		{
			$this->_archive_filenames .= $file['basename'] . ' ';
		}

		// Add in the actual theme url to make the sha1 unique to this hive
		$this->_archive_filenames = $settings['actual_theme_url'] . '/' . trim($this->_archive_filenames);
		$this->_archive_name = 'hive-' . sha1($this->_archive_filenames) . $type;

		// Create a cache stale for this hive ?x12345
		if (!empty($this->_combine_files))
		{
			$stale = max(array_column($this->_combine_files, 'filemtime'));
			$this->_archive_stale = '?x' . $stale;
		}
	}

	/**
	 * Determines if the existing combined file is stale
	 *
	 * - If any date of the files that make up the archive is newer than the archive, it's considered stale
	 */
	private function _isStale(): bool
	{
		// If any files in the archive are newer than the archive file itself, then the archive is stale
		$filemtime = $this->fileFunc->fileExists($this->_archive_dir . '/' . $this->_archive_name) ? filemtime($this->_archive_dir . '/' . $this->_archive_name) : 0;

		foreach ($this->_combine_files as $file)
		{
			if ($file['filemtime'] > $filemtime)
			{
				return true;
			}
		}

		return false;
	}

	/**
	 * Reads each files contents in to the _combine_files array
	 *
	 * What it does:
	 *
	 * - For each file, loads its contents in to the content key
	 * - If the file is CSS will convert some common relative links to the
	 * location of the hive
	 *
	 * @param string $type one of CSS or JS
	 */
	private function _combineFiles($type): void
	{
		// Remove any old cache file(s)
		$this->fileFunc->delete($this->_archive_dir . '/' . $this->_archive_name);
		$this->fileFunc->delete($this->_archive_dir . '/' . $this->_archive_name . '.gz');

		$_cache = [];
		$_min_cache = [];

		// Read in all the data so we can process
		foreach ($this->_combine_files as $key => $file)
		{
			if (!$this->fileFunc->fileExists($file['file']))
			{
				continue;
			}

			$tempfile = trim(file_get_contents($file['file']));
			$tempfile = (str_ends_with($tempfile, '}()')) ? $tempfile . ';' : $tempfile;
			$this->_combine_files[$key]['content'] = $tempfile;

			// CSS needs relative locations converted for the moved hive to work
			// @todo needs to be smarter, based on "new" cache location
			if ($type === 'css')
			{
				$tempfile = str_replace(['../../images', '../../webfonts', '../../scripts'], [$file['url'] . '/images', $file['url'] . '/webfonts', $file['url'] . '/scripts'], $tempfile);
			}

			// Add the file to the correct array for processing
			if ($file['minimized'] === false)
			{
				$_cache[] = $tempfile;
			}
			else
			{
				$_min_cache[] = $tempfile;
			}
		}

		// Build out our combined file strings
		$this->_cache = implode("\n", $_cache);
		$this->_min_cache = implode("\n", $_min_cache);
		unset($_cache, $_min_cache);
	}

	/**
	 * Takes a js file and compresses it to save space
	 *
	 * What it does:
	 *
	 * - Use JavaScriptMinifier
	 * - Failing that will return original uncompressed file
	 */
	public function jsMinify($js)
	{
		$fetch_data = JavaScriptMinifier::minify($js);

		// If we have nothing to return, use the original data
		return ($fetch_data === false || trim($fetch_data) === '') ? $this->_cache : $fetch_data;
	}

	/**
	 * Save a compilation file
	 */
	private function _saveFiles(): void
	{
		// Add in the file header if available
		if (!empty($this->_archive_header))
		{
			$this->_minified_cache = $this->_archive_header . $this->_minified_cache;
		}

		// Save the hive, or a nest, or a conglomeration. Like it was grown
		file_put_contents($this->_archive_dir . '/' . $this->_archive_name, $this->_minified_cache, LOCK_EX);
	}

	/**
	 * Minify individual javascript files
	 *
	 * @param array $files array created by loadJavascriptFile() function
	 *
	 * @return array
	 */
	public function site_js_minify($files): array
	{
		if (!$this->_validRequest($files))
		{
			return $files;
		}

		// Build the cache filename, check for changes, minify when requested
		require_once(SUBSDIR . '/Package.subs.php');
		foreach ($files as $id => $file)
		{
			// Clean start
			$this->_combine_files = [];
			$file['options']['minurl'] = $file['filename'];

			// Skip the ones that we would not load locally
			if (empty($file['options']['local']) || !$this->_addFile($file['options']))
			{
				continue;
			}

			// Get a file cache name and modification data
			$this->_buildName('.js');

			// Fresh version required?
			if ($this->_isStale())
			{
				$this->_combineFiles('js');

				$this->_minified_cache = empty($this->_min_cache) ? trim($this->jsMinify($this->_cache)) : $this->_min_cache;

				$this->_saveFiles();
			}

			$file['options']['minurl'] = $this->_archive_url . '/' . $this->_archive_name . $this->_archive_stale;
			$files[$id]['options'] = $file['options'];
			$files[$id]['filename'] = $file['options']['minurl'];
		}

		// Return the array for inclusion in the output
		return $files;
	}

	/**
	 * Combine CSS files in to a single file
	 *
	 * @param string[] $files
	 *
	 * @return bool|string
	 */
	public function site_css_combine($files)
	{
		if (!$this->_validRequest($files))
		{
			// Everything is spare
			$this->_addSpare($files);

			return false;
		}

		// Get the filenames and last modified time for this batch
		foreach ($files as $id => $file)
		{
			// Get the ones that we would load locally so we can merge them
			if (empty($file['options']['local']) || !$this->_addFile($file['options']))
			{
				$this->_addSpare([$id => $file]);
			}
		}

		// Nothing to do so return
		if (count($this->_combine_files) === 0)
		{
			return true;
		}

		// Create the CSS archive name
		$this->_buildName('.css');

		// No file, or a stale one, so we create a new CSS compilation
		if ($this->_isStale())
		{
			$this->_archive_header = "/*\n *" . $this->_archive_filenames . "\n */\n";
			$this->_combineFiles('css');

			// Compress CSS
			$this->_minified_cache = $this->_minify ? $this->cssMinify($this->_cache) : trim($this->_cache);

			// Combine in any pre minimized CSS files to our string
			$this->_minified_cache .= "\n" . $this->_min_cache;

			$this->_saveFiles();
		}

		// Return the name
		return $this->_archive_url . '/' . $this->_archive_name . $this->_archive_stale;
	}

	/**
	 * Takes a CSS file and compresses it to save space
	 *
	 * What it does:
	 *
	 * - Applies fast whitespace and comment removal
	 *
	 * @param string $css data to minify
	 * @return string Minified CSS data
	 */
	public function cssMinify(string $css = ''): string
	{
		// Simple fast whitespace and comment removal from Wikimedia CSSMin.php
		return trim(
			str_replace(
				[ '; ', ': ', ' {', '{ ', ', ', '} ', ';}', '( ', ' )', '[ ', ' ]' ],
				[ ';', ':', '{', '{', ',', '}', '}', '(', ')', '[', ']' ],
				preg_replace( [ '/\s+/', '/\/\*.*?\*\//s' ], [ ' ', '' ], $css )
			)
		);
	}

	/**
	 * Minify individual CSS files
	 *
	 * @param array $files array created by loadJavascriptFile() function
	 *
	 * @return array
	 */
	public function site_css_minify($files): array
	{
		if (!$this->_validRequest($files))
		{
			return $files;
		}

		// Build the cache filename, check for changes, minify when needed
		foreach ($files as $id => $file)
		{
			// Clean start
			$this->_combine_files = [];
			$file['options']['minurl'] = $file['filename'];

			// Skip the ones that we would not load locally
			if (empty($file['options']['local']) || !$this->_addFile($file['options']))
			{
				continue;
			}

			// Get a file cache name and modification data
			$this->_buildName('.css');

			// Fresh version required?
			if ($this->_isStale())
			{
				$this->_combineFiles('css');
				$this->_minified_cache = empty($this->_min_cache) ? trim($this->cssMinify($this->_cache)) : $this->_min_cache;

				$this->_saveFiles();
			}

			$file['options']['minurl'] = $this->_archive_url . '/' . $this->_archive_name . $this->_archive_stale;
			$files[$id]['options'] = $file['options'];
			$files[$id]['filename'] = $file['options']['minurl'];
		}

		// Return the array for inclusion in the output
		return $files;
	}

	/**
	 * Returns the info of the files that were not combined
	 *
	 * @return string[]
	 */
	public function getSpares(): array
	{
		return $this->_spares;
	}

	/**
	 * Deletes the CSS hives from the cache.
	 */
	public function removeCssHives(): bool
	{
		return $this->_removeHives('css');
	}

	/**
	 * Deletes hives from the cache based on extension.
	 *
	 * @param string $ext
	 *
	 * @return bool
	 */
	protected function _removeHives($ext): bool
	{
		$path = $this->_archive_dir . '/hive-*.' . $ext;

		$glob = new \GlobIterator($path, \FilesystemIterator::SKIP_DOTS);
		$fileFunc = FileFunctions::instance();
		$return = true;

		foreach ($glob as $file)
		{
			$return = $return && $fileFunc->delete($file->getPathname());
		}

		return $return;
	}

	/**
	 * Deletes the JS hives from the cache.
	 */
	public function removeJsHives(): bool
	{
		return $this->_removeHives('js');
	}
}