sdc-build-wp 4.9.0 → 4.9.2

package/.phpcs.xml

@@ -1,35 +1,60 @@
 <?xml version="1.0"?>
 <ruleset name="SDCBuildWPStandard">
 	<description>sdc-build-wp coding standard</description>
-
+	<arg name="error-severity" value="1"/>
+	<arg name="warning-severity" value="1"/>
+	<arg name="extensions" value="php"/>
+	<arg name="colors"/>
+	<arg name="parallel" value="8"/>
 	<rule ref="Generic.Arrays.ArrayIndent">
 		<properties>
 			<property name="indent" value="2" />
 		</properties>
 	</rule>
+	<rule ref="Generic.Arrays.DisallowLongArraySyntax"/>
+	<rule ref="Generic.WhiteSpace.LanguageConstructSpacing"/>
+	<rule ref="Generic.WhiteSpace.ScopeIndent">
+		<properties>
+			<property name="exact" value="true" />
+			<property name="indent" value="2"/>
+		</properties>
+	</rule>
+	<rule ref="Generic.WhiteSpace.ArbitraryParenthesesSpacing"/>
+	<rule ref="Generic.WhiteSpace.DisallowTabIndent"/>
 	<rule ref="Generic.CodeAnalysis.EmptyPHPStatement"/>
+	<rule ref="Generic.CodeAnalysis.EmptyStatement"/>
 	<rule ref="Generic.CodeAnalysis.UnusedFunctionParameter"/>
+	<rule ref="Generic.CodeAnalysis.UselessOverridingMethod"/>
 	<rule ref="Generic.Formatting.SpaceAfterCast"/>
 	<rule ref="Generic.Formatting.SpaceAfterNot">
-    <properties>
-      <property name="spacing" value="0" />
-    </properties>
+		<properties>
+			<property name="spacing" value="0" />
+		</properties>
 	</rule>
+	<rule ref="Generic.Formatting.DisallowMultipleStatements"/>
 	<rule ref="Generic.Functions.OpeningFunctionBraceKernighanRitchie">
-    <properties>
+		<properties>
 			<property name="checkFunctions" value="false" />
 			<property name="checkClosures" value="true" />
-    </properties>
+		</properties>
 	</rule>
+	<rule ref="Generic.Functions.FunctionCallArgumentSpacing"/>
 	<rule ref="Generic.NamingConventions.UpperCaseConstantName"/>
-	<rule ref="Generic.WhiteSpace.ArbitraryParenthesesSpacing"/>
+	<rule ref="Generic.NamingConventions.CamelCapsFunctionName"/>
 	<rule ref="Generic.PHP.DisallowAlternativePHPTags"/>
 	<rule ref="Generic.PHP.DisallowShortOpenTag"/>
-	<rule ref="Generic.WhiteSpace.LanguageConstructSpacing"/>
-	<rule ref="Generic.WhiteSpace.ScopeIndent">
+	<rule ref="Generic.PHP.LowerCaseConstant"/>
+	<rule ref="Generic.PHP.LowerCaseKeyword"/>
+	<rule ref="Generic.PHP.LowerCaseType"/>
+	<rule ref="Generic.PHP.DeprecatedFunctions"/>
+	<rule ref="Generic.PHP.ForbiddenFunctions">
 		<properties>
-			<property name="exact" value="true" />
-			<property name="indent" value="2"/>
+			<property name="forbiddenFunctions" type="array">
+				<element key="eval" value="null"/>
+				<element key="create_function" value="null"/>
+				<element key="var_dump" value="null"/>
+				<element key="print_r" value="null"/>
+			</property>
 		</properties>
 	</rule>
 	<rule ref="PEAR.Files.IncludingFile.BracketsNotRequired"/>
@@ -38,18 +63,20 @@
 	<rule ref="PEAR.NamingConventions.ValidClassName"/>
 	<rule ref="Squiz.ControlStructures.ForEachLoopDeclaration"/>
 	<rule ref="Squiz.ControlStructures.ForLoopDeclaration"/>
+	<rule ref="Squiz.ControlStructures.ControlSignature"/>
 	<rule ref="Squiz.Strings.ConcatenationSpacing">
-    <properties>
-      <property name="spacing" value="1" />
-    </properties>
+		<properties>
+			<property name="spacing" value="1" />
+		</properties>
 	</rule>
 	<rule ref="Squiz.Strings.DoubleQuoteUsage.NotRequired"/>
 	<rule ref="Squiz.WhiteSpace.FunctionSpacing">
-    <properties>
-      <property name="spacing" value="1" />
-    </properties>
+		<properties>
+			<property name="spacing" value="1" />
+		</properties>
 	</rule>
 	<rule ref="Squiz.WhiteSpace.SemicolonSpacing"/>
 	<rule ref="Squiz.WhiteSpace.SuperfluousWhitespace"/>
-
+	<rule ref="Squiz.WhiteSpace.LogicalOperatorSpacing"/>
+	<rule ref="Squiz.WhiteSpace.LanguageConstructSpacing"/>
 </ruleset>

package/README.md

@@ -10,7 +10,7 @@ sdc-build-wp --help
 
 ## Caching
 
-sdc-build-wp includes intelligent build caching to speed up subsequent builds by only rebuilding files that have changed or whose dependencies have changed.
+Caching speeds up subsequent builds by only rebuilding files that have changed or whose dependencies have changed.
 
 ```sh
 sdc-build-wp --no-cache        # Disable caching for this build

package/lib/components/base.js

@@ -36,11 +36,12 @@ class BaseComponent {
 			itemLabel: null,
 			timerStart: this.timer,
 			timerEnd: performance.now(),
+			skipTimer: false,
 			cached: false
 		}, options);
 
 		const cacheIndicator = options.cached ? ' (cached)' : '';
-		this.log('success', `${options.verb}${options.itemLabel ? ` ${options.itemLabel}` : ''}${cacheIndicator} in ${Math.round(options.timerEnd - options.timerStart)}ms`);
+		this.log('success', `${options.verb}${options.itemLabel ? ` ${options.itemLabel}` : ''}${cacheIndicator}${options.skipTimer ? '' : ` in ${Math.round(options.timerEnd - options.timerStart)}ms`}`);
 	}
 	async shouldSkipBuild(inputFile, outputFile, dependencies = []) {
 		if (!this.useCache || !this.project.components.cache || !this.project.components.cache.manifest?.entries) {

package/lib/components/blocks.js

@@ -1,8 +1,9 @@
 import { fileURLToPath } from 'url';
 import BaseComponent from './base.js';
-import { stat } from 'fs/promises';
+import { stat, readFile } from 'fs/promises';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { createHash } from 'crypto';
 
 export default class BlocksComponent extends BaseComponent {
 
@@ -23,6 +24,66 @@ export default class BlocksComponent extends BaseComponent {
 		// }
 		await this.process();
 	}
+	async getBlockDependencies(blockPath) {
+		const dependencies = [];
+		const srcPath = `${blockPath}/src`;
+
+		try {
+			const srcFiles = await Array.fromAsync(
+				this.glob(`${srcPath}/**/*`)
+			);
+
+			dependencies.push(...srcFiles);
+
+			for (const file of srcFiles) {
+				if (/\.(js|jsx|ts|tsx)$/.test(file)) {
+					const jsDependencies = this.utils.getAllJSDependencies(file);
+					dependencies.push(...jsDependencies);
+				} else if (/\.(scss|sass)$/.test(file)) {
+					const scssDependencies = this.utils.getImportedSASSFiles(file);
+					dependencies.push(...scssDependencies);
+				}
+			}
+
+			const uniqueDependencies = [...new Set(dependencies)];
+			const existingDependencies = [];
+
+			for (const dep of uniqueDependencies) {
+				try {
+					await stat(dep);
+					existingDependencies.push(dep);
+				} catch (error) {
+					// File doesn't exist, skip it
+				}
+			}
+
+			return existingDependencies;
+		} catch (error) {
+			this.log('warn', `Failed to get dependencies for block ${blockPath}: ${error.message}`);
+			return [];
+		}
+	}
+
+	async getCurrentFileHash(filePath) {
+		try {
+			const content = await readFile(filePath);
+			return createHash('sha256').update(content).digest('hex');
+		} catch (error) {
+			return null;
+		}
+	}
+
+	async buildOutputExists(buildPath) {
+		try {
+			await stat(buildPath);
+			const buildFiles = await Array.fromAsync(
+				this.glob(`${buildPath}/**/*`)
+			);
+			return buildFiles.length > 0;
+		} catch (error) {
+			return false;
+		}
+	}
 
 	async build(entry, options) {
 		options = Object.assign({}, {}, options);
@@ -50,6 +111,26 @@ export default class BlocksComponent extends BaseComponent {
 			this.log('error', `Failed building ${entry} blocks - no block.json found.`);
 			return false;
 		}
+
+		const dependencies = await this.getBlockDependencies(entry);
+		const buildOutputDir = `${entry}/build`;
+		const cacheOutputFile = `${buildOutputDir}/index.js`;
+
+		const shouldSkip = await this.shouldSkipBuild(workingBlockJson, cacheOutputFile, dependencies);
+		const buildExists = await this.buildOutputExists(buildOutputDir);
+
+		if (shouldSkip && buildExists) {
+			this.end({
+				itemLabel: entryLabel,
+				cached: true,
+				timerStart: timerStart,
+				timerEnd: performance.now()
+			});
+			return true;
+		}
+
+		this.clearHashCache([workingBlockJson, ...dependencies]);
+
 		try {
 			const cmds = [
 				`${this.project.path}/node_modules/@wordpress/scripts/bin/wp-scripts.js`,
@@ -72,6 +153,8 @@ export default class BlocksComponent extends BaseComponent {
 			if (stderr && stderr.trim()) {
 				this.log('warn', `Build warnings for ${entryLabel}: ${stderr.trim()}`);
 			}
+
+			await this.updateBuildCache(workingBlockJson, cacheOutputFile, dependencies);
 		} catch (error) {
 			console.error(error.stdout || error.stderr || error.message);
 			this.log('error', `Failed building ${entryLabel} block - See above error.`);
@@ -100,37 +183,113 @@ export default class BlocksComponent extends BaseComponent {
 		const debounceTimers = new Map();
 		const DEBOUNCE_DELAY = 500;
 
-		this.watcher = this.chokidar.watch(watchPaths, {
+		const dependencyMap = new Map();
+		const updateDependencyMap = async () => {
+			dependencyMap.clear();
+			for (const block of this.globs) {
+				try {
+					const dependencies = await this.getBlockDependencies(block);
+					dependencyMap.set(block, dependencies);
+				} catch (error) {
+					this.log('warn', `Failed to get dependencies for block ${block}: ${error.message}`);
+					dependencyMap.set(block, []);
+				}
+			}
+		};
+
+		updateDependencyMap();
+		const dependencyWatchPaths = [
+			`${this.project.path}/${this.project.paths.src.src}/**/*`,
+			`${this.project.path}/blocks/**/src/**/*`,
+			...watchPaths
+		];
+
+		this.watcher = this.chokidar.watch(dependencyWatchPaths, {
 			...this.project.chokidarOpts
 		}).on('all', async (event, path) => {
 			if (!this.project.isRunning) { return; }
 			if (['unlink', 'unlinkDir'].includes(event)) { return; }
 
-			const block = this.globs.find(blockPath => path.startsWith(`${blockPath}/src`));
-			if (!block) { return; }
-			if (debounceTimers.has(block)) {
-				clearTimeout(debounceTimers.get(block));
+			const directBlock = this.globs.find(blockPath => path.startsWith(`${blockPath}/src`));
+
+			let contentChanged = false;
+			if (this.project.components.cache) {
+				const oldHash = this.project.components.cache.hashCache.get(path);
+				const newHash = await this.getCurrentFileHash(path);
+				if (oldHash !== newHash) {
+					contentChanged = true;
+					if (newHash) {
+						this.project.components.cache.hashCache.set(path, newHash);
+					}
+				}
+			} else {
+				contentChanged = true;
+			}
+			if (!contentChanged) {
+				this.end({
+					itemLabel: directBlock ? directBlock.replace(this.project.path, '') : 'a block',
+					cached: true,
+					skipTimer: true
+				});
+				return;
 			}
-			debounceTimers.set(block, setTimeout(async () => {
-				if (buildQueue.has(block)) { return; }
+
+			const affectedBlocks = new Set();
+
+			if (directBlock) {
+				affectedBlocks.add(directBlock);
 				try {
-					buildQueue.add(block);
-					this.project.components.server.server.notify('Building...', 10000);
-					if (path.endsWith('.js')) {
-						if (!this.project.components.scripts.isBuilding) {
-							this.project.components.scripts.lint(path).catch(lintError => {
-								this.log('warn', `Linting failed for ${path}: ${lintError.message}`);
-							});
-						}
-					}
-					await this.process(block);
+					const dependencies = await this.getBlockDependencies(directBlock);
+					dependencyMap.set(directBlock, dependencies);
 				} catch (error) {
-					this.log('error', `Failed to process block ${block}: ${error.message}`);
-				} finally {
-					buildQueue.delete(block);
-					debounceTimers.delete(block);
+					this.log('warn', `Failed to update dependencies for block ${directBlock}: ${error.message}`);
+				}
+			}
+			for (const [block, dependencies] of dependencyMap) {
+				if (dependencies.includes(path)) {
+					affectedBlocks.add(block);
+				}
+			}
+
+			if (affectedBlocks.size === 0 && !directBlock) {
+				await updateDependencyMap();
+				for (const [block, dependencies] of dependencyMap) {
+					if (dependencies.includes(path)) {
+						affectedBlocks.add(block);
+					}
 				}
-			}, DEBOUNCE_DELAY));
+			}
+
+			if (affectedBlocks.size > 0 && this.project.components.cache) {
+				this.project.components.cache.hashCache.delete(path);
+				await this.project.components.cache.invalidateFile(path);
+			}
+
+			for (const block of affectedBlocks) {
+				if (debounceTimers.has(block)) {
+					clearTimeout(debounceTimers.get(block));
+				}
+				debounceTimers.set(block, setTimeout(async () => {
+					if (buildQueue.has(block)) { return; }
+					try {
+						buildQueue.add(block);
+						this.project.components.server.server.notify('Building...', 10000);
+						if (path.endsWith('.js')) {
+							if (!this.project.components.scripts.isBuilding) {
+								this.project.components.scripts.lint(path).catch(lintError => {
+									this.log('warn', `Linting failed for ${path}: ${lintError.message}`);
+								});
+							}
+						}
+						await this.process(block);
+					} catch (error) {
+						this.log('error', `Failed to process block ${block}: ${error.message}`);
+					} finally {
+						buildQueue.delete(block);
+						debounceTimers.delete(block);
+					}
+				}, DEBOUNCE_DELAY));
+			}
 		});
 	}
 

package/lib/components/php.js

@@ -18,6 +18,24 @@ export default class PHPComponent extends BaseComponent {
 		// await this.process(null, { lintType: 'warn' }); // this errors "Fatal error: Allowed memory size"
 	}
 
+	async checkSyntax(entry) {
+		try {
+			let execPromise = promisify(exec);
+			const { stdout, stderr } = await execPromise(`php -l "${entry}"`, {
+				cwd: this.path.resolve(this.path.dirname(fileURLToPath(import.meta.url)), '../../')
+			});
+		} catch (error) {
+			if (error.stderr.includes('command not found')) {
+				this.log('warn', 'PHP syntax checker not found. Skipping syntax check.');
+				return true;
+			}
+			console.error(error.stderr.replace(this.project.path, ''));
+			this.log('error', `Failed to validate ${entry.replace(this.project.path, '')} - See above error.`);
+			return false;
+		}
+		return true;
+	}
+
 	async build(entry, options) {
 		options = Object.assign({}, {
 			lintType: 'fix'
@@ -25,25 +43,37 @@ export default class PHPComponent extends BaseComponent {
 		let entryLabel = `all PHP files`;
 
 		this.start();
-		let workingLintBin = 'phpcbf';
-		if (options.lintType == 'warn') {
-			workingLintBin = 'phpcs';
-		}
+
 		let phpFiles = '.';
 		let additionalFlags = '';
+		let filesToValidate = this.globs;
+
 		if (entry) {
-			phpFiles = entry;
 			entryLabel = entry.replace(this.project.path, '');
+			filesToValidate = [entry];
+			phpFiles = entry;
 		} else {
 			additionalFlags += ' -d memory_limit=2G'; // FIXME: this doesn't solve error issue "Fatal error: Allowed memory size"
 		}
+
+		let syntaxErrors = false;
+		for (const phpFile of filesToValidate) {
+			const syntaxValid = await this.checkSyntax(phpFile);
+			if (!syntaxValid) {
+				syntaxErrors = true;
+			}
+		}
+		if (syntaxErrors) {
+			return false;
+		}
+
+		let workingLintBin = 'phpcbf';
+		if (options.lintType == 'warn') {
+			workingLintBin = 'phpcs';
+		}
 		try {
 			const cmds = [
 				`vendor/bin/${workingLintBin}`,
-				`--parallel=5`,
-				`--error-severity=1`,
-				`--warning-severity=1`,
-				`--colors`,
 				`--basepath=${this.project.path}`,
 				phpFiles,
 				additionalFlags
@@ -66,10 +96,6 @@ export default class PHPComponent extends BaseComponent {
 				console.error(error.stderr?.length ? error.stderr : error.stdout);
 				this.log('error', `Failed linting ${entryLabel.replace(this.project.path, '')} - See above error.`);
 				return false;
-			} else {
-				if (error.stdout?.length) {
-					console.log(error.stdout);
-				}
 			}
 		}
 		if (this.project.components.server?.server) {

package/lib/components/server.js

@@ -20,6 +20,7 @@ export default class ServerComponent extends BaseComponent {
 			this.watchedFiles.push(`**/*.php`);
 		}
 		this.ignoredFiles = [
+			`.sdc-build-wp/cache/**`,
 			`node_modules/**`,
 			`vendor/**/*`,
 			`**/*.map`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sdc-build-wp",
-	"version": "4.9.0",
+	"version": "4.9.2",
 	"description": "Custom WordPress build process.",
 	"engines": {
 		"node": ">=22"