wp-advads 1.0.31 → 1.0.34

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 } )
+	}
+} )

package/test/class.test.js

@@ -0,0 +1,47 @@
+/**
+ * TASK-008: class -i must still win when --heading is also set.
+ */
+import assert from 'node:assert/strict'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { mock, test } from 'node:test'
+
+const runCalls = []
+
+mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
+	exports: {
+		execCommand() {},
+		runCommand( ...args ) {
+			runCalls.push( args )
+		},
+	},
+} )
+
+const { default: classFile } = await import( '../src/commands/class.js' )
+
+test( 'class command uses the initializer template when heading and -i are both set', async () => {
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-class-' ) )
+	const cwd = process.cwd()
+	process.chdir( dir )
+
+	try {
+		await writeFile( join( dir, 'wp.advads' ), JSON.stringify( {
+			paths: { php: 'includes' },
+			wp: { version: '1.0.0' },
+			misc: { package: 'AdvancedAds' },
+			author: { name: 'Test', email: 'test@example.com' },
+		} ) )
+
+		classFile( 'Foo_Bar', { heading: 'Class Heading', i: true } )
+
+		const php = await readFile( join( dir, 'includes', 'class-foo-bar.php' ), 'utf8' )
+		assert.match( php, /Initializer_Interface/ )
+		assert.match( php, /Class Heading/ )
+		assert.doesNotMatch( php, /\{\{/ )
+		assert.equal( runCalls.length, 0 )
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+} )

package/test/compile-templates.test.js

@@ -0,0 +1,70 @@
+/**
+ * TASK-033 / TASK-058: stubs compile; view/update use init config plus command fields.
+ */
+import assert from 'node:assert/strict'
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { compileTemplate, getTemplateFolder } from '../src/utilities/filesystem.js'
+
+const fixture = {
+	heading: 'Heading',
+	description: 'Description',
+	className: 'Foo_Bar',
+	namespace: '',
+	prefix: 'advads',
+	version: '1_2_3',
+	wp: { version: '1.0.0' },
+	misc: { package: 'AdvancedAds', prefix: 'advads' },
+	author: { name: 'Test', email: 'test@example.com' },
+}
+
+const initShape = {
+	wp: { version: '1.0.0', description: 'Plugin description' },
+	misc: { package: 'AdvancedAds', prefix: 'advads' },
+	author: { name: 'Test', email: 'test@example.com' },
+}
+
+test( 'every template/files stub compiles without leftover placeholders', () => {
+	const dir = join( getTemplateFolder(), 'files' )
+	const files = readdirSync( dir ).filter( ( file ) => ! file.startsWith( '.' ) )
+
+	assert.ok( files.includes( 'view.php' ) )
+	assert.ok( files.includes( 'update.php' ) )
+
+	for ( const file of files ) {
+		const out = compileTemplate( join( dir, file ), fixture )
+		assert.doesNotMatch( out, /\{\{/, file )
+	}
+} )
+
+test( 'view.php does not compile from init config without a description field', () => {
+	assert.throws(
+		() => compileTemplate( join( getTemplateFolder(), 'files/view.php' ), {
+			...initShape,
+			heading: 'Sidebar template file',
+		} ),
+		/description/i
+	)
+} )
+
+test( 'view and update compile from init config plus command fields', () => {
+	const dir = join( getTemplateFolder(), 'files' )
+
+	const view = compileTemplate( join( dir, 'view.php' ), {
+		...initShape,
+		heading: 'Sidebar template file',
+		description: 'Sidebar template file',
+	} )
+	assert.doesNotMatch( view, /\{\{/ )
+
+	const update = compileTemplate( join( dir, 'update.php' ), {
+		...initShape,
+		heading: 'Update routine for version 1.2.3',
+		description: 'Update routine for version 1.2.3',
+		prefix: initShape.misc.prefix,
+		version: '1_2_3',
+	} )
+	assert.doesNotMatch( update, /\{\{/ )
+	assert.match( update, /function advads_upgrade_1_2_3/ )
+} )

package/test/deps-hygiene.test.js

@@ -0,0 +1,46 @@
+/**
+ * TASK-043 / 044 / 048 / 049 / 050: ignore junk, no jquery stub, lodash only for template, no async pkg, no deleteFile.
+ */
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { test } from 'node:test'
+
+test( 'gitignore ignores .DS_Store', () => {
+	const gitignore = readFileSync( new URL( '../.gitignore', import.meta.url ), 'utf8' )
+	assert.match( gitignore, /^\.DS_Store$/m )
+} )
+
+test( 'javascript stub does not import jquery', () => {
+	const js = readFileSync( new URL( '../template/files/javascript.js', import.meta.url ), 'utf8' )
+	assert.doesNotMatch( js, /jquery/i )
+} )
+
+test( 'lodash is only used for template compile', () => {
+	const pkg = JSON.parse( readFileSync( new URL( '../package.json', import.meta.url ), 'utf8' ) )
+	assert.ok( pkg.dependencies.lodash )
+	assert.doesNotMatch( readFileSync( new URL( '../src/utilities/settings.js', import.meta.url ), 'utf8' ), /lodash/ )
+	assert.doesNotMatch( readFileSync( new URL( '../src/utilities/misc.js', import.meta.url ), 'utf8' ), /lodash/ )
+	assert.doesNotMatch( readFileSync( new URL( '../src/commands/init.js', import.meta.url ), 'utf8' ), /lodash/ )
+	assert.match( readFileSync( new URL( '../src/utilities/filesystem.js', import.meta.url ), 'utf8' ), /lodash\/template/ )
+} )
+
+test( 'package.json does not depend on async', () => {
+	const pkg = JSON.parse( readFileSync( new URL( '../package.json', import.meta.url ), 'utf8' ) )
+	assert.equal( pkg.dependencies.async, undefined )
+} )
+
+test( 'filesystem does not export deleteFile', () => {
+	const src = readFileSync( new URL( '../src/utilities/filesystem.js', import.meta.url ), 'utf8' )
+	assert.doesNotMatch( src, /deleteFile/ )
+} )
+
+test( 'scaffold commands share writeFromTemplate', () => {
+	assert.match( readFileSync( new URL( '../src/utilities/filesystem.js', import.meta.url ), 'utf8' ), /export function writeFromTemplate/ )
+	for ( const file of [ 'css.js', 'javascript.js', 'views.js', 'class.js', 'updates.js' ] ) {
+		assert.match(
+			readFileSync( new URL( `../src/commands/${file}`, import.meta.url ), 'utf8' ),
+			/writeFromTemplate/,
+			file
+		)
+	}
+} )

package/test/engines.test.js

@@ -0,0 +1,11 @@
+/**
+ * TASK-042: npm should warn on Node older than 18.
+ */
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { test } from 'node:test'
+
+test( 'package.json engines.node is >=18', () => {
+	const pkg = JSON.parse( readFileSync( new URL( '../package.json', import.meta.url ), 'utf8' ) )
+	assert.equal( pkg.engines?.node, '>=18' )
+} )

package/test/get-latest-tag.test.js

@@ -0,0 +1,51 @@
+/**
+ * TASK-054: getLatestTag must treat execCommand error; only "No names found" falls back.
+ */
+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 } from 'node:test'
+
+let execImpl = ( cmd, cb ) => cb( '', null, '' )
+
+mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
+	exports: {
+		execCommand( cmd, cb ) {
+			execImpl( cmd, cb )
+		},
+		runCommand() {},
+	},
+} )
+
+const { getLatestTag } = await import( '../src/commands/release/git.js' )
+
+test( 'getLatestTag rejects when git describe errors', async () => {
+	execImpl = ( cmd, cb ) => cb( '', new Error( 'failed' ), 'fatal: not a git repository' )
+
+	await assert.rejects( getLatestTag() )
+} )
+
+test( 'getLatestTag uses the described tag when git succeeds', async () => {
+	execImpl = ( cmd, cb ) => cb( 'v1.2.3\n', null, '' )
+
+	assert.equal( await getLatestTag(), '1.2.3' )
+} )
+
+test( 'getLatestTag falls back to wp.version when there are no tags', async () => {
+	execImpl = ( cmd, cb ) => {
+		cb( '', new Error( 'failed' ), 'fatal: No names found, cannot describe anything.' )
+	}
+
+	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-tag-' ) )
+	const cwd = process.cwd()
+	await writeFile( join( dir, 'wp.advads' ), JSON.stringify( { wp: { version: '3.4.5' } } ) )
+	process.chdir( dir )
+
+	try {
+		assert.equal( await getLatestTag(), '3.4.5' )
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+} )

package/test/git-precheck.test.js

@@ -0,0 +1,44 @@
+/**
+ * TASK-055: hasPermission / gitFetch must treat error first and not crash on non-string stderr.
+ */
+import assert from 'node:assert/strict'
+import { mock, test } from 'node:test'
+
+let execImpl = ( cmd, cb ) => cb( '', null, '' )
+
+mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
+	exports: {
+		execCommand( cmd, cb ) {
+			execImpl( cmd, cb )
+		},
+		runCommand() {},
+	},
+} )
+
+const { hasPermission, gitFetch } = await import( '../src/commands/release/git.js' )
+
+function run( fn ) {
+	return new Promise( ( resolve, reject ) => {
+		try {
+			fn( ( err ) => resolve( err ) )
+		} catch ( err ) {
+			reject( err )
+		}
+	} )
+}
+
+test( 'hasPermission fails closed when error is set and stderr is missing', async () => {
+	execImpl = ( cmd, cb ) => cb( '', new Error( 'spawn failed' ), undefined )
+
+	const err = await run( hasPermission )
+
+	assert.ok( err )
+} )
+
+test( 'gitFetch fails closed when error is set and stderr is empty', async () => {
+	execImpl = ( cmd, cb ) => cb( '', new Error( 'spawn failed' ), '' )
+
+	const err = await run( gitFetch )
+
+	assert.ok( err )
+} )