feat(*): add keep and set prerelease option to version command (#493)

Signed-off-by: Simon Stone <[email protected]>

Author: Simon Stone

packages/concerto-cli/index.js

@@ -226,20 +226,38 @@ require('yargs')
     })
     .command('version <release>', 'modify the version of one or more model files', yargs => {
         yargs.demandOption(['model'], 'Please provide Concerto model(s)');
+        yargs.positional('release', {
+            describe: 'the new version, or a release to use when incrementing the existing version',
+            type: 'string',
+            choices: [
+                'keep',
+                'major',
+                'minor',
+                'patch',
+                'premajor',
+                'preminor',
+                'prepatch',
+                'prerelease'
+            ]
+        });
         yargs.option('model', {
             alias: 'models',
             describe: 'array of concerto model files',
             type: 'string',
             array: true
         });
+        yargs.option('prerelease', {
+            describe: 'set the specified pre-release version',
+            type: 'string'
+        });
     }, argv => {
         const modelFiles = argv.model.flatMap(model => {
             if (glob.hasMagic(model)) {
                 return glob.sync(model);
             }
             return model;
         });
-        return Commands.version(argv.release, modelFiles)
+        return Commands.version(argv.release, modelFiles, argv.prerelease)
             .then((result) => {
                 if (result) {
                     Logger.info(result);

packages/concerto-cli/lib/commands.js

@@ -281,12 +281,13 @@ class Commands {
      *
      * @param {string} release the release, major/minor/patch, or a semantic version
      * @param {string[]} modelFiles the list of model file paths
+     * @param {string} [prerelease] the pre-release version to set
      */
-    static async version(release, modelFiles) {
+    static async version(release, modelFiles, prerelease) {
         const updatedModelFiles = [];
         for (const modelFile of modelFiles) {
             const resolvedModelFile = path.resolve(modelFile);
-            const updatedModelFile = await Commands.versionModelFile(release, resolvedModelFile);
+            const updatedModelFile = await Commands.versionModelFile(release, resolvedModelFile, prerelease);
             updatedModelFiles.push(updatedModelFile);
         }
         Commands.updateImportsForUpdatedModelFiles(updatedModelFiles);
@@ -324,16 +325,17 @@ class Commands {
      *
      * @param {string} release the release, major/minor/patch, or a semantic version
      * @param {string} modelFile the model file path
+     * @param {string} [prerelease] the pre-release version to set
      * @private
      */
-    static async versionModelFile(release, modelFile) {
+    static async versionModelFile(release, modelFile, prerelease) {
         const data = fs.readFileSync(modelFile, 'utf-8');
         const isMetaModel = Commands.isJSON(data);
         if (isMetaModel) {
-            return Commands.versionMetaModelFile(release, modelFile, data);
+            return Commands.versionMetaModelFile(release, modelFile, data, prerelease);
 
         } else {
-            return Commands.versionCtoModelFile(release, modelFile, data);
+            return Commands.versionCtoModelFile(release, modelFile, data, prerelease);
         }
     }
 
@@ -419,13 +421,14 @@ class Commands {
      * @param {string} release the release, major/minor/patch, or a semantic version
      * @param {string} modelFile the model file path
      * @param {string} data the model file data
+     * @param {string} [prerelease] the pre-release version to set
      * @private
      */
-    static async versionMetaModelFile(release, modelFile, data) {
+    static async versionMetaModelFile(release, modelFile, data, prerelease) {
         const metamodel = JSON.parse(data);
         const currentNamespace = metamodel.namespace;
         const [namespace, currentVersion] = currentNamespace.split('@');
-        const newVersion = Commands.calculateNewVersion(release, currentVersion);
+        const newVersion = Commands.calculateNewVersion(release, currentVersion, prerelease);
         const newNamespace = [namespace, newVersion].join('@');
         metamodel.namespace = newNamespace;
         const newData = JSON.stringify(metamodel, null, 2);
@@ -447,13 +450,14 @@ class Commands {
      * @param {string} release the release, major/minor/patch, or a semantic version
      * @param {string} modelFile the model file path
      * @param {string} data the model file data
+     * @param {string} [prerelease] the pre-release version to set
      * @private
      */
-    static async versionCtoModelFile(release, modelFile, data) {
+    static async versionCtoModelFile(release, modelFile, data, prerelease) {
         const metamodel = Parser.parse(data);
         const currentNamespace = metamodel.namespace;
         const [namespace, currentVersion] = currentNamespace.split('@');
-        const newVersion = Commands.calculateNewVersion(release, currentVersion);
+        const newVersion = Commands.calculateNewVersion(release, currentVersion, prerelease);
         const newNamespace = [namespace, newVersion].join('@');
         const newData = data.replace(/(namespace\s+)(\S+)/, (match, keyword) => {
             return `${keyword}${newNamespace}`;
@@ -475,20 +479,30 @@ class Commands {
      *
      * @param {string} release the release, major/minor/patch, or a semantic version
      * @param {string} currentVersion the current version
+     * @param {string} [prerelease] the pre-release version to set
      * @returns {string} the new version
      * @private
      */
-    static calculateNewVersion(release, currentVersion) {
+    static calculateNewVersion(release, currentVersion, prerelease) {
         if (semver.valid(release)) {
             return release;
         } else if (!semver.valid(currentVersion)) {
             throw new Error(`invalid current version "${currentVersion}"`);
         }
-        const newVersion = semver.inc(currentVersion, release);
-        if (!newVersion) {
-            throw new Error(`invalid release "${release}"`);
+        const result = semver.parse(currentVersion);
+        if (release !== 'keep') {
+            try {
+                result.inc(release);
+            } catch (error) {
+                throw new Error(`invalid release "${release}"`);
+            }
+        }
+        if (prerelease) {
+            result.prerelease = prerelease.split('.');
+            return result.format();
+        } else {
+            return result.toString();
         }
-        return newVersion;
     }
 
     /**

packages/concerto-cli/test/cli.js

@@ -297,20 +297,21 @@ describe('concerto-cli', () => {
             { name: 'minor', release: 'minor', expectedNamespace: '[email protected]' },
             { name: 'major', release: 'major', expectedNamespace: '[email protected]' },
             { name: 'explicit', release: '4.5.6', expectedNamespace: '[email protected]' },
-            { name: 'prerelease', release: '5.6.7-pr.3472381', expectedNamespace: '[email protected]' }
+            { name: 'prerelease', release: '5.6.7-pr.3472381', expectedNamespace: '[email protected]' },
+            { name: 'keep-and-set-prerelease', release: 'keep', prerelease: 'pr.1234567', expectedNamespace: '[email protected]' }
         ];
 
-        tests.forEach(({ name, release, expectedNamespace }) => {
+        tests.forEach(({ name, release, prerelease, expectedNamespace }) => {
 
             it(`should patch bump a cto file [${name}]`, async () => {
-                await Commands.version(release, [ctoPath]);
+                await Commands.version(release, [ctoPath], prerelease);
                 const cto = fs.readFileSync(ctoPath, 'utf-8');
                 const metamodel = Parser.parse(cto);
                 metamodel.namespace.should.equal(expectedNamespace);
             });
 
             it(`should patch bump a metamodel file [${name}]`, async () => {
-                await Commands.version(release, [metamodelPath]);
+                await Commands.version(release, [metamodelPath], prerelease);
                 const metamodel = JSON.parse(fs.readFileSync(metamodelPath, 'utf-8'));
                 metamodel.namespace.should.equal(expectedNamespace);
             });