wp-advads 1.0.7 → 1.0.9

package/src/commands/release/composer.js

@@ -0,0 +1,37 @@
+/**
+ * External Dependencies
+ */
+import fs from 'fs';
+import logSymbols from 'log-symbols'
+
+/**
+ * Internal Dependencies
+ */
+import { pluginData } from './index.js';
+import { heading, execCommand, onSameLine } from "../../utilities/index.js"
+
+/**
+ * Execute routine
+ */
+export function updateComposer(next) {
+    heading('Updating composer')
+
+    process.stderr.write('Dumping....')
+
+    if (fs.existsSync('./vendor')) {
+        fs.rmSync('./vendor', { recursive: true, force: true });
+    }
+
+    if (fs.existsSync('./packages')) {
+        fs.rmSync('./packages', { recursive: true, force: true });
+    }
+
+    execCommand('composer install -o -a -n --no-dev --no-scripts', function() {
+        fs.renameSync('./vendor', './packages')
+        execCommand('composer install --no-scripts', function() {
+            pluginData.commitMessages.push('update: 3rd party dependecies and composer dump-autoloader')
+            onSameLine(`${logSymbols.success} composer updated`)
+            next()
+        })
+    })
+}

package/src/commands/release/git.js

@@ -0,0 +1,119 @@
+/**
+ * External Dependencies
+ */
+import logSymbols from 'log-symbols'
+
+/**
+ * Internal Dependencies
+ */
+import { pluginData } from './index.js';
+import { execCommand, onSameLine } from "../../utilities/index.js"
+
+
+/**
+ * Get latest tag from GitHub
+ */
+export function getLatestTag() {
+    return new Promise((resolve, reject) => {
+        try {
+            execCommand('git rev-list --tags --max-count=1', function(tags) {
+                execCommand( 'git describe --tags ' + tags.trim(), function(version) {
+                    resolve(version.trim())
+                } )
+            })
+        }
+        catch (err) {
+            reject(err)
+        }
+    })
+}
+
+/**
+ * Check if user has permission to write to repo
+ */
+export function hasPermission(next) {
+    const message = 'Checking github write permission'
+
+    process.stdout.write(`${message}....`)
+
+    execCommand('git push --dry-run', function(result, error, stderr) {
+        if (stderr.includes('error:') || stderr.includes('fatal:')) {
+            onSameLine(`${logSymbols.error} ${message}`)
+            return next(true)
+        }
+
+        onSameLine(`${logSymbols.success} ${message}`)
+        next()
+    })
+}
+
+/**
+ * Fetch remote changes
+ */
+export function gitFetch(next) {
+    const message = 'Fetching remote changes'
+
+    process.stdout.write(`${message}....`)
+
+    execCommand('git fetch', function(result, error, stderr) {
+        if (stderr.includes('error:') || stderr.includes('fatal:')) {
+            onSameLine(`${logSymbols.error} ${message}`)
+            return next(true)
+        }
+
+        onSameLine(`${logSymbols.success} Remote changes fetched`)
+        next()
+    })
+}
+
+/**
+ * Verify if the tag already exists or not
+ */
+export function verifyNextVersion(next) {
+    const message = 'Verifying next version'
+    const version = pluginData.semver.getNextVersionString()
+    const tag = 'refs/tags/v' + version
+
+    process.stdout.write(`${message}....`)
+
+    execCommand(`git rev-parse ${tag}`, function(result, error, stderr) {
+        if (null === error) {
+            onSameLine(`${logSymbols.error} Version tag: v${version} already exists.`)
+            return next(true)
+        }
+
+        onSameLine(`${logSymbols.success} Version tag verified`)
+        next()
+    })
+}
+
+/**
+ * Get current branch name
+ */
+export function getCurrentBranchName(next) {
+    execCommand('git rev-parse --abbrev-ref HEAD', function(result) {
+        pluginData.gitCurrentBranch = result.trim()
+        next()
+    })
+}
+
+/**
+ * Create new branch with the release version
+ */
+export function createReleaseBranch(next) {
+    const message = 'Creating release branch'
+    const version = pluginData.semver.getNextVersionString()
+    process.stdout.write(`${message}....`)
+
+    execCommand(`git checkout -b release/v${version}`, function(result, error, stderr) {
+        if (stderr.includes('fatal:') && stderr.includes('already exists')) {
+            onSameLine(`${logSymbols.error} Branch named: release/v${version} already exists.`)
+            return next(true)
+        }
+
+        execCommand(`git push --set-upstream origin release/v${version}`, function(result) {
+            onSameLine(`${logSymbols.success} Release branch created`)
+            next()
+        })
+    })
+}

package/src/commands/release/github.js

@@ -0,0 +1,62 @@
+/**
+ * External Dependencies
+ */
+import { waterfall } from 'async'
+import logSymbols from 'log-symbols'
+
+/**
+ * Internal Dependencies
+ */
+import { execCommand, heading, onSameLine } from "../../utilities/index.js"
+import {
+    hasPermission,
+    gitFetch,
+    verifyNextVersion,
+    getCurrentBranchName,
+    createReleaseBranch
+} from './git.js'
+import { pluginData } from './index.js'
+
+/**
+ * Execute routine
+ */
+export function githubPreTasks(next) {
+    heading('Github operations')
+
+    waterfall(
+        [
+            hasPermission,
+            gitFetch,
+            verifyNextVersion,
+            getCurrentBranchName,
+            createReleaseBranch
+        ],
+        ( err, results ) => {
+            if(err) {
+                return next(true)
+            }
+            next()
+        }
+    )
+}
+
+/**
+ * Execute routine
+ */
+export function githubFinalTasks(next) {
+    heading('Github operations')
+
+    process.stdout.write('Committing to GitHub...')
+
+    const version = pluginData.semver.getNextVersionString()
+    const message = pluginData.commitMessages.join('\n')
+
+    execCommand('git add .', function() {
+        execCommand(`git commit --no-verify -m 'bump version to ${version}' -m '${message}'`, function(result, err, stderr) {
+            execCommand('git push', function() {
+                onSameLine(`${logSymbols.success} Git commit successful`)
+                next()
+            })
+        })
+    })
+}

package/src/commands/release/index.js

@@ -8,62 +8,58 @@ import logSymbols from 'log-symbols'
 /**
  * Internal Dependencies
  */
-import { heading, runCommand } from "../../helpers.js"
+import prompts from './prompts.js'
+import { heading } from "../../utilities/index.js"
+import { wpPot, updateTranslations } from './translations.js'
+import { updateChangelog } from './changelog.js'
+import { getSemVer } from './semver.js'
+import { githubPreTasks, githubFinalTasks } from './github.js'
+import { updateComposer } from './composer.js'
+import { updateVersionNumber } from './change-version.js'
 
-async function getPackage() {
-    const rootPath = process.cwd()
-    const { default: data } = await import( rootPath + '/package.json', { assert: { type: "json" } });
-
-    return data
+export const pluginData = {
+    commitMessages: [],
+    changelogChanges: false
 }
 
-function wpPot( next ) {
-    const rootPath = process.cwd()
-    const { wpPot = {} } = getPackage()
-    const {output, file, domain, exclude = [] } = wpPot
-
-    heading('Creating POT file...')
+function getPackage( next ) {
+    (async () => {
+        const rootPath = process.cwd()
+        const { default: data } = await import( rootPath + '/package.json', { assert: { type: "json" } });
 
-    try {
-        exclude.push(".github")
-        exclude.push("vendor")
-        exclude.push("tools")
-        runCommand( 'wp', [ 'i18n', 'make-pot', rootPath, `${rootPath}${output}${file} --domain=${domain} --exclude=${exclude.join(',')}` ], next )
+        return data
+    })().then((data) => {
+        pluginData.glotpress = data.glotpress
+        pluginData.wpPot = data.wpPot
 
-        console.log( logSymbols.success + ' Done' )
-    } catch {
-        console.log( logSymbols.error + ' Error' )
-    }
+        next()
+    })
 }
 
-function updateTranslations( next ) {
-    heading('Downloading translations')
-    runCommand( 'npm', [ 'run', 'translations' ], next )
-    console.log( logSymbols.success + ' Done' )
-}
-
-export function execute(args) {
+export default function(args) {
     heading('Releasing the plugin...')
     console.log('')
-
-    const {
-        potOnly = false,
-        translationsOnly = false
-    } = args
-
-    const falls = []
-
-    if (potOnly) {
-        falls.push(wpPot)
-    }
-
-    if (translationsOnly) {
-        falls.push(updateTranslations)
-    }
-
     waterfall(
-        falls,
+        [
+            prompts,
+            getPackage,
+            getSemVer,
+            githubPreTasks,
+            updateComposer,
+            wpPot,
+            updateTranslations,
+            updateVersionNumber,
+            updateChangelog,
+            githubFinalTasks
+        ],
         ( err, results ) => {
+            if (err) {
+                console.log('');
+                console.log( `${logSymbols.error} ${chalk.bold.red(`We failed somewhere! Work hard mate...`)}` )
+                return
+            }
+
+            console.log('');
             console.log( `${logSymbols.success} ${chalk.bold.green(`All done!`)}` )
         }
     )

package/src/commands/release/prompts.js

@@ -0,0 +1,59 @@
+/**
+ * External dependencies
+ */
+import inquirer from 'inquirer'
+
+/**
+ * Internal Dependencies
+ */
+import { pluginData } from './index.js';
+
+/**
+ * Execute routine
+ */
+export default ( next ) => {
+    const questions = [
+        {
+            type: 'list',
+            name: 'version',
+            message: 'Select version type',
+            default: 'patch',
+            choices: [
+                { value: 'major', name: 'Major' },
+                { value: 'minor', name: 'Minor' },
+                { value: 'patch', name: 'Patch' },
+            ]
+        },
+        {
+            type: 'confirm',
+            name: 'preRelease',
+            message: 'Is this a Pre-Release',
+            default: false
+        },
+        {
+            type: 'list',
+            name: 'preVersion',
+            message: 'Select pre-releae version type',
+            default: 'patch',
+            choices: [
+                { value: 'alpha', name: 'Alpha' },
+                { value: 'beta', name: 'Beta' },
+                { value: 'rc', name: 'Release Candidate' },
+            ],
+            when: (ans) => ans.preRelease
+        },
+    ]
+
+    inquirer.prompt( questions )
+        .then( ( answers ) => {
+
+            if (answers.preRelease) {
+                answers.preRelease = answers.preVersion
+                delete answers.preVersion
+            }
+
+            pluginData.answers = answers
+
+            next()
+        } )
+}

package/src/commands/release/semver.js

@@ -0,0 +1,198 @@
+/**
+ * External Dependencies
+ */
+import chalk from 'chalk'
+import logSymbols from 'log-symbols'
+
+/**
+ * Internal Dependencies
+ */
+import { pluginData } from './index.js';
+import { getLatestTag } from './git.js'
+import { heading, onSameLine } from "../../utilities/index.js"
+
+const VERSION_NAMES = [ 'major', 'minor', 'patch' ]
+const PRE_RELEASE_NAMES = [ 'alpha', 'beta', 'rc' ]
+
+/**
+ * Semantic version generator
+ */
+class SemVer {
+    constructor(baseVersion, increment, preRelease) {
+        this.baseVersion = baseVersion
+        this.increment = increment
+        this.preRelease = preRelease
+        this.nextVersion = false
+        this.versionString = undefined
+
+        if ( ! VERSION_NAMES.includes(increment) ) {
+            console.log(`${logSymbols.error} ${chalk.bold.red(`Failed!`)} Please supply next release by specifying one of ${VERSION_NAMES.join(', ')}.`)
+            throw new Error('failed')
+        }
+
+        if ( preRelease && ! PRE_RELEASE_NAMES.includes(preRelease) ) {
+            console.log(`${logSymbols.error} ${chalk.bold.red(`Failed!`)} Please supply the pre-release version by specifying one of ${PRE_RELEASE_NAMES.join(', ')}.`)
+            throw new Error('failed')
+        }
+
+        this.parseVersion()
+        this.setupNextVersion()
+    }
+
+    parseVersion() {
+        const regex = new RegExp('(?<major>\\d+)\\.(?<minor>\\d+)\\.(?<patch>\\d+)(?:-(?<pre>alpha|beta|rc))?(?:\\.(?<pre_count>\\d+))?', 'gm')
+        this.baseVersion = { ...regex.exec(this.baseVersion).groups }
+
+        this.baseVersion.major = parseInt(this.baseVersion.major)
+        this.baseVersion.minor = parseInt(this.baseVersion.minor)
+        this.baseVersion.patch = parseInt(this.baseVersion.patch)
+        this.baseVersion.pre = undefined === this.baseVersion.pre ? false : this.baseVersion.pre
+        this.baseVersion.pre_count = undefined === this.baseVersion.pre_count ? false : this.baseVersion.pre_count
+    }
+
+    getNextVersion() {
+        return this.nextVersion
+    }
+
+    getNextVersionString() {
+        if (undefined !== this.versionString) {
+            return this.versionString
+        }
+
+        this.versionString = `${this.nextVersion.major}.${this.nextVersion.minor}.${this.nextVersion.patch}`
+
+        if (this.preRelease && this.nextVersion.pre && this.nextVersion.pre_count) {
+            this.versionString += `-${this.nextVersion.pre}.${this.nextVersion.pre_count}`
+        }
+
+        return this.versionString;
+    }
+
+    getLatestMinor() {
+        if (this.nextVersion.patch === 0) {
+            return this.getNextVersionString();
+        }
+
+        const latestMinor = {...this.nextVersion}
+        latestMinor.patch = 0
+
+        return `${this.nextVersion.major}.${this.nextVersion.minor}.${this.nextVersion.patch}`
+    }
+
+    setupNextVersion() {
+        this.nextVersion = { ...this.baseVersion }
+
+        // we're on a pre-release and creating a pre-release
+        if (this.preRelease && this.baseVersion.pre) {
+            return this.createPreReleaseFromPreRelease()
+        }
+
+        // we're on a pre-release and creating a proper release
+        if (!this.preRelease && this.baseVersion.pre) {
+            return this.createReleaseFromPreRelease()
+        }
+
+        // we're on a release and creating a pre-release.
+        if (this.preRelease) {
+            this.incrementVersion();
+            this.nextVersion.pre       = this.preRelease;
+            this.nextVersion.pre_count = 1;
+
+            return
+        }
+
+        // we're on a release and creating a release.
+        this.incrementVersion()
+    }
+
+    incrementVersion() {
+        this.nextVersion[this.increment] = this.nextVersion[this.increment] + 1
+        if (this.increment !== 'patch') {
+            this.nextVersion.patch = 0
+            if (this.increment !== 'minor') {
+                this.nextVersion.minor = 0
+            }
+        }
+    }
+
+    createPreReleaseFromPreRelease() {
+        let increment = 'patch'
+        if (this.baseVersion.patch === 0) {
+            increment = this.baseVersion.minor ? 'major' : 'minor'
+        }
+
+        if (this.increment !== increment) {
+            this.incrementVersion()
+        }
+
+        if (this.baseVersion.pre === this.preRelease) {
+            this.nextVersion.pre_count = this.baseVersion.pre_count
+                ? 2
+                : this.baseVersion.pre_count + 1
+        } else {
+            this.nextVersion.pre       = this.preRelease
+            this.nextVersion.pre_count = 1
+        }
+
+        this.checkPreReleaseLogic()
+    }
+
+    createReleaseFromPreRelease() {
+        // we're on a pre-release and creating a release.
+        if (
+            (this.increment === 'patch' && this.baseVersion.patch === 0)
+            || (this.increment === 'minor' && this.baseVersion.patch !== 0)
+        ) {
+            this.incrementVersion();
+        } else if (
+            this.increment === 'major'
+            && (this.baseVersion.minor !== 0 || this.baseVersion.patch !== 0)
+        ) {
+            this.nextVersion.patch = 0;
+            this.incrementVersion();
+        }
+
+        this.nextVersion.pre = false
+        this.nextVersion.pre_count = false
+    }
+
+    /**
+     * we can't create pre-releases from existing pre-releases, unless they haven't changed the version number.
+     */
+    checkPreReleaseLogic() {
+        if (
+            isset(this.baseVersion.pre)
+            && (
+                this.nextVersion[this.increment] !== this.baseVersion[this.increment]
+                || this.nextVersion[this.increment] === 0
+            )
+        ) {
+            console.log(`${logSymbols.error} ${chalk.bold.red(`Failed!`)} We can't create a release based on a non-existent version.`)
+            throw new Error('failed')
+        }
+    }
+}
+
+/**
+ * Execute routine
+ */
+export function getSemVer(next) {
+    heading('Calculating next version')
+
+    process.stdout.write('Fetching latest version from github....')
+    getLatestTag().then((baseVersion) => {
+        onSameLine(`${logSymbols.success} Latest version on Github: ${baseVersion}`)
+
+        try {
+            const { version = 'patch', preRelease = false } = pluginData.answers
+            const semver = new SemVer(baseVersion, version, preRelease)
+            pluginData.semver = semver
+
+            console.log( `${logSymbols.success} Next version: v${semver.getNextVersionString()}`)
+            next()
+        }
+        catch (err) {
+            return next(true)
+        }
+    })
+}

package/src/commands/release/translations.js

@@ -0,0 +1,66 @@
+/**
+ * External Dependencies
+ */
+import logSymbols from 'log-symbols'
+
+/**
+ * Internal Dependencies
+ */
+import { pluginData } from './index.js'
+import { heading, execCommand } from "../../utilities/index.js"
+
+/**
+ * Execute routine to generate POT files
+ */
+export function wpPot( next ) {
+    const rootPath = process.cwd()
+    const { wpPot = {} } = pluginData
+    const {output, file, domain, exclude = [] } = wpPot
+
+    heading('Creating POT file')
+
+    try {
+        exclude.push(".github")
+        exclude.push(".husky")
+        exclude.push(".wordpress-org")
+        exclude.push("node_modules")
+        exclude.push("tools")
+        exclude.push("vendor")
+        execCommand(
+            [ 'wp', 'i18n', 'make-pot', rootPath, `${rootPath}${output}${file} --domain=${domain} --exclude=${exclude.join(',')}` ].join(' '),
+            () => {
+                pluginData.commitMessages.push('update: POT file')
+                console.log( logSymbols.success + ' POT file successfully generated!' )
+                next()
+            }
+        )
+    } catch {
+        throw new Error( logSymbols.error + ' Error' )
+    }
+}
+
+/**
+ * Execute routine to download translations from GlotPress
+ */
+export function updateTranslations( next ) {
+    heading('Downloading translations from glotpress')
+
+    execCommand( 'npm run translations -- --no-console', function(locales) {
+        locales = locales.split('\n').slice(4).slice(0,-1)
+        console.log( logSymbols.success + ` Downloaded ${locales.length} files successfully` )
+
+        if (locales.length > 0) {
+            pluginData.commitMessages.push('add: Download translation from GlotPress')
+        }
+
+        const newLocales = {}
+        locales.map((locale) => {
+            const data = locale.split('=')
+            newLocales[ data[0] ] = data[1]
+        })
+
+        pluginData.locales = newLocales
+
+        next()
+    })
+}