wp-advads 1.0.33 → 1.0.35

package/src/utilities/filesystem.js

@@ -1,7 +1,6 @@
 /**
  * External dependencies
  */
-import chalk from 'chalk';
 import logSymbols from 'log-symbols';
 import template from 'lodash/template.js';
 
@@ -9,12 +8,13 @@ import template from 'lodash/template.js';
  * Node dependencies
  */
 import path from 'path';
-import fs from 'fs-extra';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
 
 /**
  * Internal Dependencies
  */
-import { msgSuccessOnSameLine, onSameLine, write } from './formatting.js'
+import { msgErrorTitle, msgSuccessOnSameLine, onSameLine, write } from './formatting.js'
 
 let projectRoot = null
 
@@ -32,32 +32,26 @@ export function getProjectRoot(startDir = process.cwd()) {
 		return projectRoot;
 	}
 
-	projectRoot = startDir;
+	let dir = startDir;
 
-	while (projectRoot !== path.parse(projectRoot).root) {
-		const possibleRootFile = path.join(projectRoot, 'wp.advads');
-		if (fs.existsSync(possibleRootFile)) {
+	while (dir !== path.parse(dir).root) {
+		if (fs.existsSync(path.join(dir, 'wp.advads'))) {
+			projectRoot = dir;
 			return projectRoot;
 		}
 
-		// Move up one directory level
-		projectRoot = path.dirname(projectRoot);
-  }
+		dir = path.dirname(dir);
+	}
 
-  throw new Error('Project root not found. Make sure there is a wp.advads file in the root directory.');
+	projectRoot = null;
+	throw new Error('Project root not found. Make sure there is a wp.advads file in the root directory.');
 }
 
 /**
- * Retrieves the path to the template folder.
- *
- * This function uses `createRequire` to resolve the path to the `../../template` directory
- * relative to the current module's URL and removes the `/index.js` part from the resolved path.
- *
  * @returns {string} The path to the template folder.
  */
 export function getTemplateFolder() {
-    const dirname = path.dirname(import.meta.url.replace('file://', ''))
-    return path.join(dirname, '../../template')
+	return path.join( path.dirname( fileURLToPath( import.meta.url ) ), '../../template' )
 }
 
 /**
@@ -87,21 +81,22 @@ export function compileTemplate( filename, data ) {
 }
 
 /**
- * Deletes a specified file if it exists.
+ * Compile a template and write it, or print the shared scaffold failure.
  *
- * @param {string} name - The name of the file to be deleted.
- * @param {string} file - The path to the file to be deleted.
- *
- * @returns {void}
+ * @param {string} folder
+ * @param {string} filename
+ * @param {string} templateFile Path under template/
+ * @param {Object} data
+ * @param {boolean} force
  */
-export function deleteFile(name, file) {
-    if ( ! fs.existsSync(file) ) {
-        console.log( `${logSymbols.error} ${chalk.red(`${name} file not found!`)}` )
-        return
-    }
-
-    fs.rmSync(file)
-    console.log( `${logSymbols.success} ${chalk.dim(`${name} deleted!`)}` )
+export function writeFromTemplate( folder, filename, templateFile, data, force = false ) {
+	try {
+		const content = compileTemplate( getTemplateFile( templateFile ), data )
+		writeFile( folder, filename, content, force )
+	} catch ( err ) {
+		msgErrorTitle( 'We failed!!!' )
+		throw err
+	}
 }
 
 /**
@@ -120,7 +115,7 @@ export function updateFileContent(fileName, messages, next, callback) {
     fs.readFile(fileName, (err, buffer) => {
         if ( null !== err ) {
             onSameLine(`${logSymbols.error} ${messages.failed}`)
-            return next()
+            return next(err)
         }
 
         const content = callback(buffer.toString())
@@ -128,7 +123,7 @@ export function updateFileContent(fileName, messages, next, callback) {
         fs.writeFile(fileName, content, (err) => {
             if ( null !== err ) {
                 onSameLine(`${logSymbols.error} ${messages.failed}`)
-                return next()
+                return next(err)
             }
 
             onSameLine(`${logSymbols.success} ${messages.updated}`)
@@ -137,12 +132,38 @@ export function updateFileContent(fileName, messages, next, callback) {
     })
 }
 
-export function writeFile(folder, filename, content) {
+function assertInsideProject( target ) {
+	if ( String( target ).includes( '\0' ) ) {
+		throw new Error( 'Invalid path' )
+	}
+
+	const root = path.resolve( getProjectRoot() )
+	const resolved = path.resolve( target )
+	const relative = path.relative( root, resolved )
+
+	if ( relative.startsWith( `..${path.sep}` ) || relative === '..' || path.isAbsolute( relative ) ) {
+		throw new Error( 'Path escapes project root' )
+	}
+}
+
+export function writeFile(folder, filename, content, force = false) {
+	if ( String( filename ).includes( '\0' ) ) {
+		throw new Error( 'Invalid path' )
+	}
+
+	assertInsideProject( folder )
+	assertInsideProject( path.join( folder, filename ) )
+
+	const target = path.join( folder, filename )
+	if ( ! force && fs.existsSync( target ) ) {
+		throw new Error( `File exists: ${target}` )
+	}
+
 	write('Creating directories!!');
-	fs.ensureDirSync(folder);
+	fs.mkdirSync(folder, { recursive: true });
 	msgSuccessOnSameLine('Directories created successfully');
 
 	write('Creating file!!');
-	fs.writeFileSync(path.join(folder, filename), content);
+	fs.writeFileSync(target, content);
 	msgSuccessOnSameLine('File created successfully');
 }

package/src/utilities/flow.js

@@ -0,0 +1,21 @@
+/**
+ * Run callback-style steps in order. `next(err)` if any step fails.
+ *
+ * @param {Function[]} steps Each step is `(done) => void`
+ * @param {Function} next
+ */
+export function runSteps( steps, next ) {
+	;( async () => {
+		for ( const step of steps ) {
+			await new Promise( ( resolve, reject ) => {
+				step( ( err ) => {
+					if ( err ) {
+						reject( err )
+					} else {
+						resolve()
+					}
+				} )
+			} )
+		}
+	} )().then( () => next() ).catch( ( err ) => next( err ) )
+}

package/src/utilities/formatting.js

@@ -28,6 +28,10 @@ export function onNewLine(text) {
     console.log(text)
 }
 
+function canRewriteStdout() {
+	return Boolean( process.stdout.isTTY && ! process.env.NODE_TEST_CONTEXT )
+}
+
 /**
  * Print text on same line by clearing buffer.
  *
@@ -36,9 +40,9 @@ export function onNewLine(text) {
  * @returns {void}
  */
 export function onSameLine(text) {
-	if (process.stdout.clearLine) {
-		process.stdout.clearLine(); // Clear the current line
-		process.stdout.cursorTo(0);  // Move the cursor to the start of the line
+	if ( canRewriteStdout() && process.stdout.clearLine ) {
+		process.stdout.clearLine();
+		process.stdout.cursorTo(0);
 	}
 
     console.log(text)
@@ -118,5 +122,10 @@ export function msgErrorTitle(msg) {
  * @returns {void}
  */
 export function write(text) {
-	process.stdout.write(text)
+	if ( canRewriteStdout() ) {
+		process.stdout.write(text)
+		return
+	}
+
+	console.log(text)
 }

package/src/utilities/index.js

@@ -1,6 +1,6 @@
 export * from './filesystem.js'
+export * from './flow.js'
 export * from './formatting.js'
-export * from './semver.js'
 export * from './settings.js'
 export * from './shell.js'
 export * from './misc.js'

package/src/utilities/misc.js

@@ -1,12 +1,7 @@
-/**
- * External Dependencies
- */
-import capitalize from 'lodash/capitalize.js';
-
 export function filenameToHeading(filename) {
 	filename = filename.replace('.php', '');
 	filename = filename.replace('.js', '');
 	filename = filename.replace(/-/g, ' ');
 
-	return capitalize(filename);
+	return filename.charAt(0).toUpperCase() + filename.slice(1).toLowerCase();
 }

package/src/utilities/settings.js

@@ -1,9 +1,3 @@
-/**
- * External dependencies
- */
-import get from 'lodash/get.js'
-import set from 'lodash/set.js'
-
 /**
  * Node dependencies
  */
@@ -18,6 +12,14 @@ import { write } from './formatting.js'
 
 let settings = null
 
+function configPath() {
+	try {
+		return path.join( getProjectRoot(), 'wp.advads' )
+	} catch {
+		return path.join( process.cwd(), 'wp.advads' )
+	}
+}
+
 /**
  * Checks if the configuration file exists at the specified path.
  *
@@ -25,8 +27,7 @@ let settings = null
  */
 export function configFileExists() {
 	try {
-		const configPath = path.join(getProjectRoot(), 'wp.advads')
-		return fs.existsSync(configPath);
+		return fs.existsSync( configPath() );
 	} catch (err) {
 		return false;
 	}
@@ -39,8 +40,7 @@ export function configFileExists() {
  */
 export function readConfigFile() {
 	try {
-		const configPath = path.join(getProjectRoot(), 'wp.advads')
-		const data = fs.readFileSync(configPath, 'utf-8');
+		const data = fs.readFileSync( configPath(), 'utf-8' );
 		return JSON.parse(data);
 	} catch (err) {
 		return {};
@@ -55,9 +55,8 @@ export function readConfigFile() {
 export function saveConfig(data) {
 	write('Saving config file...');
 	try {
-		const savePath = path.join(process.cwd(), 'wp.advads')
 		const jsonData = JSON.stringify(data, null, 2);
-		fs.writeFileSync(savePath, jsonData);
+		fs.writeFileSync( configPath(), jsonData );
 		settings = data;
 	} catch (err) {
 		write('Error writing config file:', err);
@@ -82,7 +81,7 @@ export function getSetting(key = 'all', defaultVal = '') {
 		return settings;
 	}
 
-	return get( settings, key, defaultVal );
+	return getPath( settings, key, defaultVal );
 }
 
 export function updateSetting(key, value) {
@@ -90,6 +89,27 @@ export function updateSetting(key, value) {
 		settings = readConfigFile();
 	}
 
-	settings = set(settings, key, value);
+	settings = setPath(settings, key, value);
 	saveConfig(settings);
 }
+
+function getPath( object, key, defaultVal ) {
+	const value = String( key ).split( '.' ).reduce( ( cur, part ) => cur?.[ part ], object )
+	return value === undefined ? defaultVal : value
+}
+
+function setPath( object, key, value ) {
+	const parts = String( key ).split( '.' )
+	let cur = object
+
+	for ( let i = 0; i < parts.length - 1; i++ ) {
+		const part = parts[ i ]
+		if ( cur[ part ] == null || typeof cur[ part ] !== 'object' ) {
+			cur[ part ] = {}
+		}
+		cur = cur[ part ]
+	}
+
+	cur[ parts[ parts.length - 1 ] ] = value
+	return object
+}

package/src/utilities/shell.js

@@ -1,7 +1,7 @@
 /**
  * Node dependencies
  */
-import { exec, spawn } from 'node:child_process'
+import { spawn } from 'node:child_process'
 
 /**
  * Internal Dependencies
@@ -19,10 +19,20 @@ import { onSameLine } from './formatting.js'
  */
 export function runCommand( command, args, callback ) {
     const commandSpawn = spawn( command, args, {
-        shell: true,
-        stdio: [ 'inherit' ]
+        shell: false,
+        stdio: [ 'inherit', 'pipe', 'pipe' ]
     } )
 
+    let finished = false
+    const done = ( err ) => {
+        if ( finished ) {
+            return
+        }
+
+        finished = true
+        callback( err )
+    }
+
     commandSpawn.stdout.on( 'data', (data) => {
         onSameLine(data.toString())
     })
@@ -31,23 +41,65 @@ export function runCommand( command, args, callback ) {
         onSameLine(data.toString().replace('\n','').replace('\r','').trim())
     })
 
+    commandSpawn.on( 'error', done )
+
     commandSpawn.on( 'close', (code) => {
-        callback()
+        if ( code !== 0 ) {
+            done( new Error( `Command failed with exit code ${code}` ) )
+            return
+        }
+
+        done()
     })
 }
 
 /**
  * Execute a command in the terminal.
  *
- * @param {string} command Command to execute
+ * @param {string|string[]} command Command to execute, or argv array
  * @param {Function} callback Callback function
+ * @param {Object} options cwd/env for spawn
  *
  * @returns {void}
  */
 export function execCommand( command, callback, options = {} ) {
-	if ('string' !== typeof command) {
-		command = command.join(' ')
+	const spawnOpts = {
+		cwd: options.cwd,
+		env: options.env,
+		stdio: [ 'ignore', 'pipe', 'pipe' ],
 	}
 
-    exec( command, options, (error, stdout, stderr) => callback(stdout, error, stderr) )
+	const child = Array.isArray( command )
+		? spawn( command[0], command.slice( 1 ), { ...spawnOpts, shell: false } )
+		: spawn( command, { ...spawnOpts, shell: true } )
+
+	let stdout = ''
+	let stderr = ''
+	let finished = false
+	const done = ( error ) => {
+		if ( finished ) {
+			return
+		}
+
+		finished = true
+		callback( stdout, error, stderr )
+	}
+
+	child.stdout.on( 'data', ( data ) => {
+		const text = data.toString()
+		stdout += text
+		onSameLine( text )
+	} )
+
+	child.stderr.on( 'data', ( data ) => {
+		const text = data.toString()
+		stderr += text
+		onSameLine( text.replace( '\n', '' ).replace( '\r', '' ).trim() )
+	} )
+
+	child.on( 'error', done )
+
+	child.on( 'close', ( code ) => {
+		done( code ? new Error( `Command failed with exit code ${code}` ) : null )
+	} )
 }

package/template/files/class-singleton.php

@@ -33,4 +33,9 @@ class {{className}} {
 
 		return $instance;
 	}
+
+	/**
+	 * Constructor.
+	 */
+	private function __construct() {}
 }

package/template/files/javascript.js

@@ -6,8 +6,6 @@
  * @author      {{author.name}} <{{author.email}}>
  * @description {{description}}
  */
-import jquery from 'jquery';
-
 export default function() {
 	// Code goes here...
 }

package/template/files/view.php

@@ -9,3 +9,5 @@
  */
 
 defined( 'ABSPATH' ) || exit;
+
+// Escape output: esc_html(), esc_attr(), esc_url(). Do not echo untrusted data raw.

package/test/build.test.js

@@ -0,0 +1,168 @@
+/**
+ * TASK-002 / TASK-020: build waterfall must stop on composer / resource / rmSync failure.
+ * Resource build uses package.json scripts.build when present.
+ * Run with --experimental-test-module-mocks
+ */
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { mock, test, before, beforeEach } from 'node:test'
+import fs from 'node:fs'
+
+const execCalls = []
+let execImpl = ( cmd, cb ) => cb( '', null, '' )
+let potCalled = false
+
+mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
+	exports: {
+		execCommand( cmd, cb, options = {} ) {
+			execCalls.push( { cmd, options } )
+			execImpl( cmd, cb, options )
+		},
+		runCommand() {},
+	},
+} )
+
+mock.module( import.meta.resolve( '../src/commands/wp-pot.js' ), {
+	exports: {
+		default( next ) {
+			potCalled = true
+			next()
+		},
+	},
+} )
+
+const { default: wpBuild } = await import( '../src/commands/build.js' )
+const { pluginData } = await import( '../src/commands/release.js' )
+
+function runBuild() {
+	return new Promise( ( resolve ) => {
+		wpBuild( ( err ) => resolve( err ) )
+	} )
+}
+
+async function withPackage( pkg, run ) {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-build-' ) )
+	await writeFile( join( dir, 'package.json' ), JSON.stringify( pkg ) )
+	const cwd = process.cwd()
+	process.chdir( dir )
+	try {
+		return await run()
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+}
+
+before( () => {
+	mock.method( fs, 'rmSync', () => {} )
+} )
+
+beforeEach( () => {
+	execCalls.length = 0
+	potCalled = false
+	execImpl = ( cmd, cb ) => cb( '', null, '' )
+	fs.rmSync.mock.mockImplementation( () => {} )
+	pluginData.commitMessages = []
+} )
+
+test( 'composer install error stops the build before dump and pot', async () => {
+	execImpl = ( cmd, cb ) => {
+		if ( String( cmd ).includes( 'composer install' ) ) {
+			cb( '', new Error( 'install failed' ), 'install exploded' )
+			return
+		}
+		cb( '', null, '' )
+	}
+
+	const err = await runBuild()
+
+	assert.ok( err, 'expected the build callback to receive an error' )
+	assert.equal( potCalled, false )
+	assert.equal(
+		execCalls.some( ( call ) => call.cmd === 'composer dump' ),
+		false
+	)
+} )
+
+test( 'npm run build error stops the build before pot', async () => {
+	await withPackage( { scripts: { build: 'mix --production' } }, async () => {
+		execImpl = ( cmd, cb ) => {
+			if ( String( cmd ).includes( 'npm run build' ) ) {
+				cb( '', new Error( 'build failed' ), 'mix exploded' )
+				return
+			}
+			cb( '', null, '' )
+		}
+
+		const err = await runBuild()
+
+		assert.ok( err )
+		assert.equal( potCalled, false )
+	} )
+} )
+
+test( 'resource build runs npm run build instead of wp-scripts', async () => {
+	await withPackage( { scripts: { build: 'mix --production' } }, async () => {
+		await runBuild()
+
+		assert.equal(
+			execCalls.some( ( call ) => String( call.cmd ).includes( 'wp-scripts' ) ),
+			false
+		)
+		assert.equal(
+			execCalls.some( ( call ) => call.cmd === 'npm run build' ),
+			true
+		)
+	} )
+} )
+
+test( 'resource build is skipped when package.json has no build script', async () => {
+	await withPackage( { scripts: { start: 'node x' } }, async () => {
+		await runBuild()
+
+		assert.equal(
+			execCalls.some( ( call ) => String( call.cmd ).includes( 'wp-scripts' ) ),
+			false
+		)
+		assert.equal(
+			execCalls.some( ( call ) => String( call.cmd ).includes( 'npm run build' ) ),
+			false
+		)
+		assert.equal( potCalled, true )
+	} )
+} )
+
+test( 'composer dump receives COMPOSER_VENDOR_DIR packages', async () => {
+	await runBuild()
+
+	const dump = execCalls.find( ( call ) => call.cmd === 'composer dump' )
+	assert.ok( dump, 'expected composer dump to run' )
+	assert.equal( dump.options.env.COMPOSER_VENDOR_DIR, 'packages' )
+} )
+
+test( 'rmSync failure stops the build before composer', async () => {
+	fs.rmSync.mock.mockImplementation( () => {
+		throw new Error( 'EACCES' )
+	} )
+
+	const err = await runBuild()
+
+	assert.ok( err )
+	assert.equal( execCalls.length, 0 )
+	assert.equal( potCalled, false )
+} )
+
+test( 'standalone build does not mutate pluginData.commitMessages', async () => {
+	await runBuild()
+	assert.equal( pluginData.commitMessages.length, 0 )
+} )
+
+test( 'build appends messages to an optional sink', async () => {
+	const sink = []
+	await new Promise( ( resolve ) => {
+		wpBuild( () => resolve(), sink )
+	} )
+	assert.ok( sink.includes( 'update 3rd party dependencies' ) )
+} )

package/test/changelog-locales.test.js

@@ -0,0 +1,49 @@
+/**
+ * TASK-012: changelog lists git files from glotpress.destination, not pluginData.
+ * Run with --test-isolation=none --experimental-test-module-mocks
+ */
+import assert from 'node:assert/strict'
+import { mkdir } from 'node:fs/promises'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { mock, test } from 'node:test'
+
+const execCalls = []
+
+mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
+	exports: {
+		execCommand( cmd, cb ) {
+			execCalls.push( cmd )
+			cb( 'languages/myplugin-de_DE.po\n', null, '' )
+		},
+		runCommand() {},
+	},
+} )
+
+const { pluginData } = await import( '../src/commands/release.js' )
+const { default: updateChangelog } = await import( '../src/commands/release/changelog.js' )
+
+test( 'updateLocalesChangelog uses glotpress.destination instead of unset pluginData.glotpress', async () => {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-changelog-' ) )
+	const cwd = process.cwd()
+	process.chdir( dir )
+	await mkdir( join( dir, '.changelog' ) )
+
+	pluginData.semver = { preRelease: true, getNextVersionString: () => '1.2.3' }
+	pluginData.locales = { 'languages/myplugin-de_DE.po': 'German' }
+	delete pluginData.glotpress
+	execCalls.length = 0
+
+	try {
+		const err = await new Promise( ( resolve ) => {
+			updateChangelog( ( error ) => resolve( error ) )
+		} )
+
+		assert.equal( err, undefined )
+		assert.deepEqual( execCalls[ 0 ], [ 'git', 'ls-files', '--', './languages/' ] )
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+} )