wp-advads 1.0.7 → 1.0.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "wp-advads",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Create a Advanced Ads wordPress plugin eco system.",
   "author": {
     "name": "Shakeeb Ahmed",

package/src/app.js

@@ -4,26 +4,25 @@
  * External dependencies
  */
 import chalk from 'chalk'
-import { waterfall } from 'async'
-import logSymbols from 'log-symbols'
 
 /**
  * Internal Dependencies
  */
-import { getCommand } from './helpers.js'
-import { execute as backupCommand } from './commands/backup/index.js'
-import { execute as helpCommand } from './commands/help/index.js'
-import { execute as releaseCommand } from './commands/release/index.js'
-import { execute as setupCommand } from './commands/setup/index.js'
+import { getCommand } from './utilities/index.js'
 import packageDetails from '../package.json' assert { type: "json" }
 
+/**
+ * Commands
+ */
+import * as commands from './commands/index.js'
+
 /**
  * App
  */
 async function app() {
     console.log(
         [
-            chalk.hex('#FADC00').inverse.bold('Advanced Ads WordPress Plugin Scaffolding'),
+            chalk.hex('#FADC00').inverse.bold('Advanced Ads WordPress Plugin Toolkit'),
             chalk.white( 'v' + packageDetails.version ),
             chalk.dim( 'by Shakeeb Ahmed' )
         ].join(" ")
@@ -32,34 +31,24 @@ async function app() {
 
     const { command, args } = getCommand()
     if ( 'help' === command ) {
-        helpCommand()
+        commands.help()
     }
 
     if ( 'backup' === command ) {
-        backupCommand()
+        commands.backup()
     }
 
-    if ( 'setup' === command ) {
-        setupCommand()
+    if ( 'make:file' === command ) {
+        commands.makeFile(args)
     }
 
-    if ( 'release' === command ) {
-        releaseCommand(args)
+    if ( 'make:plugin' === command ) {
+        commands.setupPlugin(args)
     }
 
-    // if ( 'make:file' === command ) {
-    //     waterfall(
-    //         [
-    //             function( next ) {
-    //                 next(null, args)
-    //             },
-    //             createFile,
-    //         ],
-    //         ( err, results ) => {
-    //             console.log( `${logSymbols.success} ${chalk.bold.green(`All done!`)}` )
-    //         }
-    //     )
-    // }
+    if ( 'make:release' === command ) {
+        commands.release(args)
+    }
 }
 
 app()

package/src/commands/backup/index.js

@@ -1,18 +1,16 @@
 /**
  * External Dependencies
  */
-import chalk from 'chalk'
 import { waterfall } from 'async'
-import logSymbols from 'log-symbols'
 
 /**
  * Internal Dependencies
  */
-import { heading, getCurrentFolder, backupFile, deleteFile } from "../../helpers.js"
+import { heading, getCurrentFolder, backupFile, deleteFile, msgErrorTitle, msgSuccessTitle } from "../../utilities/index.js"
 
 function backupFiles(next) {
     backupFile('Pre commit hook', getCurrentFolder() + '/.git/hooks/pre-commit')
-    next(null)
+    next()
 }
 
 function deleteFiles(next) {
@@ -26,11 +24,11 @@ function deleteFiles(next) {
     deleteFile('Package json', getCurrentFolder() + '/package.json')
     deleteFile('Package local', getCurrentFolder() + '/package.local.json')
 
-    next(null)
+    next()
 }
 
 
-export function execute() {
+export default function() {
     heading('Doing backup now...')
     console.log('');
 
@@ -40,7 +38,13 @@ export function execute() {
            deleteFiles
         ],
         ( err, results ) => {
-            console.log( `${logSymbols.success} ${chalk.bold.green(`All done!`)}` )
+            console.log('');
+			if (err) {
+				msgErrorTitle('We failed!!!')
+				return
+			}
+
+            msgSuccessTitle('All done!')
         }
     )
 }

package/src/commands/file/create-file.js

@@ -0,0 +1,96 @@
+/**
+ * External dependencies
+ */
+import fs from 'fs-extra'
+import Handlebars from 'handlebars'
+import { series, eachSeries } from 'async'
+
+/**
+ * Internal dependencies
+ */
+import { getSettings, getRootFolder, getTemplateFolder, runCommand } from "../../utilities/index.js"
+
+class CreateFile {
+    run( args, callback ) {
+        const { file, singleton = false } = args
+        const namespace = file.split('\\')
+
+        this.template = getTemplateFolder()
+
+        // Settings
+        this.settings = getSettings()
+        this.settings.namespace = ''
+        this.settings.className = namespace.pop()
+        this.settings.heading = file
+            .replace(/\\/g, ' ')
+            .replace(/_/g, ' ')
+
+        // Filename
+        this.fileName = this.settings.className
+            .toLowerCase()
+            .replace(/_/g, '-')
+        this.fileName = `class-${this.fileName}.php`
+
+        // Folder
+        this.folder = getRootFolder() + '/includes/'
+
+        // Files
+        this.files =[ singleton ? '/file-singleton.php' : '/file.php' ]
+
+        if (namespace.length > 0) {
+            this.settings.namespace = '\\' + namespace.join('\\')
+            this.folder = this.folder + namespace.join('/').toLowerCase() + '/'
+        }
+
+        series(
+            [
+                this.directories,
+                this.prepareFiles,
+                (next) => {
+                    runCommand( 'composer', [ 'dump' ], next )
+                },
+            ],
+            ( err, results ) => {
+                callback()
+            }
+        )
+    }
+
+    directories = ( next ) => {
+        console.log( 'Creating directories!!' )
+        this.dirs = [
+            // Root
+            this.folder,
+        ]
+
+        eachSeries( this.dirs, ( dir, nextDir ) => {
+            fs.ensureDir( dir ).then( nextDir )
+        }, () => {
+            next()
+        } )
+    }
+
+    prepareFiles = ( next ) => {
+        console.log( 'Preparing plugin files!!' )
+        const template = this.template + '/make'
+
+        eachSeries( this.files, ( file, nextFile ) => {
+            this.renderFile( template + file, this.folder + this.fileName, nextFile )
+        }, () => {
+            next()
+        } )
+    }
+
+    renderFile = ( src, dest, next ) => {
+        const content = fs.readFileSync( src, 'utf8' )
+        const template = Handlebars.compile( content )
+        const rendered = template( this.settings )
+
+        fs.outputFile( dest, rendered ).then( next )
+    }
+}
+
+export default ( fileName, next ) => {
+    const generator = new CreateFile()
+    generator.run( fileName, next )
+}

package/src/commands/file/index.js

@@ -0,0 +1,29 @@
+/**
+ * External Dependencies
+ */
+import chalk from 'chalk'
+import { waterfall } from 'async'
+import logSymbols from 'log-symbols'
+
+/**
+ * Internal Dependencies
+ */
+import { heading } from "../../utilities/index.js"
+import createFile from './create-file.js'
+
+export default function(args) {
+    heading('Scaffoling plugin...')
+    console.log('');
+
+    waterfall(
+        [
+            function( next ) {
+                next(null, args)
+            },
+            createFile,
+        ],
+        ( err, results ) => {
+            console.log( `${logSymbols.success} ${chalk.bold.green(`All done!`)}` )
+        }
+    )
+}

package/src/commands/help/index.js

@@ -1,9 +1,16 @@
-import { heading, onNewLine } from "../../helpers.js"
+/**
+ * Internal Dependencies
+ */
+import { heading, onNewLine } from "../../utilities/index.js"
 
-export function execute() {
+export default function() {
     heading('Help Command Menu')
     onNewLine('List of commands')
     console.log('    npx wp-advads backup');
-    console.log('    npx wp-advads setup');
-    console.log('    npx wp-advads release');
+    console.log('    npx wp-advads make:plugin');
+    console.log('    npx wp-advads make:plugin --folder=my-awesome-plugin');
+    console.log('    npx wp-advads make:file --file="Dashboard"');
+    console.log('    npx wp-advads make:file --file="Admin\\Report\\Dashboard"');
+	console.log('    npx wp-advads make:file --file="Admin\\Report\\Dashboard" --singleton');
+    console.log('    npx wp-advads make:release');
 }

package/src/commands/index.js

@@ -0,0 +1,5 @@
+export { default as backup } from './backup/index.js'
+export { default as makeFile } from './file/index.js'
+export { default as help } from './help/index.js'
+export { default as release } from './release/index.js'
+export { default as setupPlugin } from './setup/index.js'

package/src/commands/release/change-version.js

@@ -0,0 +1,124 @@
+/**
+ * External Dependencies
+ */
+import fs from 'fs'
+import path from 'path'
+import logSymbols from 'log-symbols'
+import { forEach, waterfall } from 'async'
+
+/**
+ * Internal Dependencies
+ */
+import { pluginData } from './index.js'
+import { heading, onSameLine, updateFileContent } from "../../utilities/index.js"
+
+/**
+ * Update version in readme.txt file
+ *
+ * @example Stable tag: {version}
+ */
+function updateReadme(next) {
+    updateFileContent(
+        './readme.txt',
+        {
+            updating: 'Updating readme file',
+            failed: 'Failed to update Readme file',
+            updated: 'Readme file updated successfully',
+        },
+        next,
+        (content) => {
+            let regex = new RegExp('^(?<prefix>Stable tag:\\h*)(?<version>(.*))$', 'mi')
+            regex = regex.exec(content)
+
+            if (null !== regex) {
+                regex = regex.groups
+                content = content.replace(`${regex.prefix}${regex.version}`, `${regex.prefix} ${pluginData.semver.getNextVersionString()}`)
+                pluginData.commitMessages.push('update: version in readme.txt')
+            }
+
+            return content
+        }
+    )
+}
+
+/**
+ * Update version in plugin PHP files at root level
+ *
+ * @example * Version: {version}
+ * @example * define( 'AA_VERSION', '{version}' );
+ */
+function updatePluginFiles(next) {
+    process.stdout.write( 'Updating plugin files' )
+
+    fs.readdir('./', (err, files) => {
+        if ( null !== err ) {
+            onSameLine(`${logSymbols.error} Unable to fetch PHP files`)
+            return next(true)
+        }
+
+        forEach(files, (fileName, nextFile) => {
+            if ( '.php' === path.extname(fileName) && 'index.php' !== fileName ) {
+                updateFileContent(
+                    fileName,
+                    {
+                        updating: `Updating ${fileName}`,
+                        failed: `Failed to update ${fileName}`,
+                        updated: `${fileName} updated successfully`,
+                    },
+                    nextFile,
+                    (content) => {
+                        let update = false
+                        const version = pluginData.semver.getNextVersionString()
+                        let versionRe = new RegExp('^(?<prefix>(?:[ \\t]*<\\?php)?[ \\t\\/*#@]*Version: +)(?<version>.*)$', 'mi')
+                        let constantRe = new RegExp('^(?<opening>(?:[ \\t])?define.*[\\\'"].*_VERSION[\\\'"],.*[\\\'"])(?<version>.*)(?<closing>[\\\'"].*)$', 'mi')
+
+                        versionRe = versionRe.exec(content)
+                        if (null !== versionRe) {
+                            update = true
+                            versionRe = versionRe.groups
+                            content = content.replace(`${versionRe.prefix}${versionRe.version}`, `${versionRe.prefix}${version}`)
+                        }
+
+                        constantRe = constantRe.exec(content)
+                        if (null !== constantRe) {
+                            update = true
+                            constantRe = constantRe.groups
+                            content = content.replace(
+                                `${constantRe.opening}${constantRe.version}${constantRe.closing}`,
+                                `${constantRe.opening}${version}${constantRe.closing}`,
+                            )
+                        }
+
+                        if(update) {
+                            pluginData.commitMessages.push('update: version in ' + fileName)
+                        }
+
+                        return content
+                    }
+                )
+            } else {
+                nextFile()
+            }
+        }, () => next())
+    })
+}
+
+/**
+ * Execute routine
+ */
+export function updateVersionNumber(next) {
+    heading('Updating files for new version')
+
+    const flow = []
+
+    if (!pluginData.semver.preRelease) {
+        flow.push(updateReadme)
+    }
+
+    flow.push(updatePluginFiles)
+
+    waterfall(
+        flow,
+        () => next()
+    )
+}

package/src/commands/release/changelog.js

@@ -0,0 +1,259 @@
+/**
+ * External Dependencies
+ */
+import fs from 'fs';
+import logSymbols from 'log-symbols'
+import { forEach, waterfall } from 'async'
+
+/**
+ * Internal Dependencies
+ */
+import { pluginData } from './index.js';
+import { heading, execCommand, onSameLine, updateFileContent } from "../../utilities/index.js"
+
+const LOCALES_CHANGELOG = {
+    updated: {
+        file: 'improvement-102',
+        message: 'update %s translations'
+    },
+    added: {
+        file: 'improvement-101',
+        message: 'add %s translations'
+    }
+}
+
+/**
+ * Join list of languages
+ *
+ * @param {Array} list List of languages downloaded
+ *
+ * @returns {Array}
+ */
+function naturalLanguageJoin(list) {
+    const last = list.pop()
+
+    if ( list.length > 0 ) {
+        return `${list.join(', ')} and ${last}`
+    }
+
+    return last
+}
+
+/**
+ * Loop through downloaded locales and categorize them as added or updated
+ *
+ * @param {Array} locales Locales downloaded from GlotPress
+ * @param {Array} files   Files currently in branch
+ *
+ * @returns {Array}
+ */
+function loopLocales( locales, files ) {
+    const changes = { updated: [], added: [] }
+    const localeFiles = Object.keys(locales)
+
+    localeFiles.map( (locale) => {
+        const action = files.includes(locale) ? 'updated' : 'added'
+        changes[ action ].push(locales[ locale ])
+    })
+
+    changes.added = [... new Set(changes.added)].sort()
+    changes.updated = [... new Set(changes.updated)].sort()
+
+    return changes
+}
+
+/**
+ * Write changes to file in .changelog folder
+ *
+ * @param {String} type    Type of log
+ * @param {Array}  changes List of changes
+ *
+ * @returns {void}
+ */
+function writeLocalesChangelog(type, changes) {
+    if ( changes.length < 1 ) {
+        return
+    }
+
+    const message = LOCALES_CHANGELOG[type].message.replace('%s', naturalLanguageJoin(changes))
+
+    if (!fs.existsSync('./.changelog')) {
+        fs.mkdirSync('./.changelog');
+    }
+
+    fs.writeFileSync(
+        `./.changelog/${LOCALES_CHANGELOG[type].file}`,
+        message
+    )
+}
+
+/**
+ * Update changelog for locales
+ */
+function updateLocalesChangelog(next) {
+    const { glotpress = {} } = pluginData
+
+    process.stdout.write('Generating translations changelog...')
+
+    execCommand('git ls-files ' + glotpress.destination, function(result) {
+        const files = result.split('\n').slice(0,-1)
+        const changes = loopLocales(pluginData.locales, files)
+
+        writeLocalesChangelog('added', changes.added)
+        writeLocalesChangelog('updated', changes.updated)
+
+        onSameLine( `${logSymbols.success} Translations changelog added` )
+        next()
+    })
+}
+
+/**
+ * Generate changelog entries from .changelog files
+ */
+function generateEntries(next) {
+    process.stdout.write('Generating changelog entries...')
+
+    const changes = {
+        fix: [],
+        feature: [],
+        improvement: [],
+    }
+
+    const labels = {
+        fix: 'Fix',
+        feature: 'Feature',
+        improvement: 'Improvement',
+    }
+    const allowed = Object.keys(labels)
+
+    fs.readdir('./.changelog', (err, files) => {
+        if ( null !== err ) {
+            onSameLine(`${logSymbols.error} Unable to find .changelog directory`)
+            return next(true)
+        }
+
+        forEach(files.sort(), (fileName, nextFile) => {
+            const parts = fileName.split('-')
+
+            if (allowed.includes(parts[0])) {
+                const content = fs.readFileSync(`./.changelog/${fileName}`)
+
+                changes[ parts[0] ].push(
+                    `- ${labels[parts[0]]}: ${content.toString().trim()}`
+                )
+            }
+
+            nextFile()
+        }, () => {
+            const currentDate = new Date();
+            const options = { year: 'numeric', month: 'long', day: 'numeric' };
+            pluginData.changelogChanges = [
+                ...changes['feature'],
+                ...changes['improvement'],
+                ...changes['fix'],
+            ]
+
+            pluginData.changelogChanges = pluginData.changelogChanges.length > 0
+                ? [
+                    `= ${pluginData.semver.getNextVersionString()} (${currentDate.toLocaleDateString('en', options)}) =`,
+                    '',
+                    ...pluginData.changelogChanges
+                ] : false
+
+            onSameLine(`${logSymbols.success} Changelog entries generated successfully`)
+            next()
+        })
+    })
+}
+
+function writeToChangelog(next) {
+    updateFileContent(
+        './changelog.txt',
+        {
+            updating: 'Updating changelog file...',
+            failed: 'Failed to update changelog file',
+            updated: 'Changelog file updated'
+        },
+        next,
+        (content) => {
+            if(false !== pluginData.changelogChanges && !content.includes(`= ${pluginData.semver.getNextVersionString()}`)) {
+                content = content
+                    .replace(
+                        '== Changelog ==',
+                        [
+                            '== Changelog ==',
+                            '',
+                            ...pluginData.changelogChanges
+                        ].join('\n')
+                    )
+
+                pluginData.commitMessages.push('update: add change log to changelog.txt')
+            }
+
+            return content
+        }
+    )
+}
+
+function writeToReadme(next) {
+    updateFileContent(
+        './readme.txt',
+        {
+            updating: 'Updating readme file...',
+            failed: 'Failed to update readme file',
+            updated: 'Readme file updated'
+        },
+        next,
+        (content) => {
+            if(false !== pluginData.changelogChanges && !content.includes(`= ${pluginData.semver.getNextVersionString()}`)) {
+                content = content
+                    .replace(
+                        '== Changelog ==',
+                        [
+                            '== Changelog ==',
+                            '',
+                            ...pluginData.changelogChanges
+                        ].join('\n')
+                    )
+
+                pluginData.commitMessages.push('update: add change log to readme.txt')
+            }
+
+            return content
+        }
+    )
+}
+
+function cleanChangelogDirectory(next) {
+    process.stderr.write('Cleaning changelog directory....')
+
+    const folder = './.changelog'
+
+    if (fs.existsSync(folder)) {
+        fs.rmSync(folder, { recursive: true, force: true })
+        fs.mkdirSync(folder)
+    }
+
+    onSameLine(`${logSymbols.success} Changelog directory cleaned`)
+    next()
+}
+
+/**
+ * Execute routine
+ */
+export function updateChangelog(next) {
+    heading('Creating changelog')
+
+    const flow = [
+        updateLocalesChangelog,
+        generateEntries
+    ]
+
+    if (!pluginData.semver.preRelease) {
+        flow.push(writeToChangelog)
+        flow.push(writeToReadme)
+        flow.push(cleanChangelogDirectory)
+    }
+
+    waterfall( flow, () => next() )
+}