@eui/tools 5.0.0-rc.1 → 5.0.0-rc.13

package/scripts/csdr/release/package/ui.js

@@ -2,14 +2,17 @@
 
 // GLOBAL
 const path = require('path');
+const glob = require('glob');
 
 // LOCAL
 const installUtils = require('../../install/install-utils');
 const configUtils = require('../../config/config-utils');
 const auditUtils = require('../../audit/audit-utils');
+const notificationUtils = require('../../../utils/notification/notification-utils');
+const tools = require('../../../utils/tools');
 
 
-module.exports.install = (pkg, isMaster) => {
+module.exports.install = (pkg) => {
   return Promise.resolve()
 
   // FETCHING CURRENT PACKAGES & INSTALL
@@ -18,13 +21,13 @@ module.exports.install = (pkg, isMaster) => {
     const prj = configUtils.projects.getProject();
 
     // install the dependencies for current package build
-    return installUtils.buildPackage.install(prj, pkg, isMaster);
+    return installUtils.buildPackage.installPackage(prj, pkg);
   })
 
 
   // CHECK INTERNAL DEPENDENCIES
   .then(() => {
-    return installUtils.buildPackage.checkDeps(pkg);
+    return checkDeps(pkg);
   })
 
 
@@ -38,3 +41,83 @@ module.exports.install = (pkg, isMaster) => {
     throw e;
   })
 }
+
+
+const checkDeps = (pkg) => {
+  tools.logTitle('Checking package internal dependencies');
+
+  return Promise.resolve()
+   .then(() => {
+     var depsFound = [];
+     var files = glob.sync('**/*.ts', { cwd: pkg.paths.pkgLibFolder, nodir: true, follow: true, dot: true });
+     files.forEach(file => {
+       const filePath = path.join(pkg.paths.pkgLibFolder, file);
+       const fileContent = tools.getFileContent(filePath);
+       var regex = /@cc\/|@mywp\/|@opsys\/|@sfc\//gi, result, indices = [];
+       while ( (result = regex.exec(fileContent)) ) {
+           indices.push(result.index);
+       }
+       if (indices.length !== 0) {
+         // tools.logInfo(`Number of occurences found : ${indices.length}`);
+         indices.forEach((i) => {
+           const endPos = fileContent.substr(i, 40).indexOf("'");
+           const dep = fileContent.substr(i, endPos);
+           if (endPos > -1) {
+             // tools.logInfo(`dep found on : ${dep}`);
+             depsFound.push(dep);
+
+           } else {
+             tools.logInfo(`Potential wrong import detected on file : ${file}`);
+             const subContent = fileContent.substr(i, 40);
+             const detectMultiSlashes = subContent.match(/\//g);
+             if (detectMultiSlashes.length > 0) {
+               tools.logError('Multislashes on import : ');
+               console.log(subContent);
+             }
+           }
+         })
+       }
+     });
+     depsFound = tools.removeArrayDuplicates(depsFound);
+     tools.logWarning(`Dependencies found : ${depsFound.length}`);
+     console.log(depsFound);
+
+     return depsFound;
+   })
+
+   .then((depsFound) => {
+     var depsLevel;
+
+     switch(true) {
+         case (depsFound.length === 1):
+           depsLevel = 'LOW (1)';
+           break;
+         case (depsFound.length > 1 && depsFound.length <= 3):
+           depsLevel = 'MEDIUM (between 1 and 3)';
+           break;
+         case (depsFound.length > 3 && depsFound.length <= 5):
+           depsLevel = 'HIGH (between 3 and 5)';
+           break;
+         case (depsFound.length > 5):
+           depsLevel = 'VERY HIGH (>5)';
+           break;
+         default:
+           depsLevel = 'NONE';
+     }
+
+     var message = `Internal dependencies detected : ${depsFound.length} - deps level: ${depsLevel}\n`;
+     message += depsFound.join('\n');
+
+
+     return notificationUtils.package.sendPackageMessage({
+      package: pkg,
+      text: message
+     });
+   })
+
+   .catch((e) => {
+     console.log(e);
+   })
+
+ }
+

package/scripts/csdr/sync/sync-utils.js

@@ -8,6 +8,8 @@ const configUtils = require('../config/config-utils');
 
 const tools = require('../../utils/tools');
 
+const { skipPull } = tools.getArgs();
+
 module.exports.sync = () => {
   return Promise.resolve()
   .then(() => {
@@ -22,8 +24,10 @@ module.exports.sync = () => {
     tools.logSuccess();
   })
   .then(() => {
-    tools.logInfo(`Pulling root folder ...`);
-    return execa.shellSync(`git pull`, { cwd: path.join(process.cwd()), stdio: 'inherit' });
+    if (!skipPull) {
+      tools.logInfo(`Pulling root folder ...`);
+      return execa.shellSync(`git pull`, { cwd: path.join(process.cwd()), stdio: 'inherit' });
+    }
   })
   .then(() => {
     tools.logSuccess();
@@ -49,6 +53,9 @@ module.exports.sync = () => {
   .then(() => {
     return initUtils.meta.init();
   })
+  .then(() => {
+    return initUtils.processLocalEuiVersions();
+  })
   .catch((e) => {
     throw e;
   })

package/scripts/csdr/version/app-common.js

@@ -0,0 +1,32 @@
+'use strict';
+
+// externals
+const path = require('path');
+
+// local
+const tools = require('../../utils/tools');
+
+
+// fetch args
+const { dryRun } = tools.getArgs();
+
+
+module.exports.updatePackageVersion = (project, newVersion) => {
+  return Promise.resolve()
+    .then(() => {
+      const pkgJsonFile = path.join(process.cwd(), project.folder, 'package.json');
+      const pkgJson = require(pkgJsonFile);
+
+      tools.logTitle('Updating package version');
+      pkgJson.version = newVersion;
+
+      if (!dryRun) {
+        tools.writeJsonFileSync(pkgJsonFile, pkgJson);
+      }
+
+      tools.logSuccess(newVersion);
+    })
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/version/app-env-target.js

@@ -1,146 +1,14 @@
 'use strict';
 
-// externals
-const semver = require('semver');
-
 // local
 const tools = require('../../utils/tools');
 const metadataUtils = require('../metadata/metadata-utils');
 
-// fetch args
-const { dryRun } = tools.getArgs();
-
-
-const getNewVersionForDev = (versionsMetadata, envsMetadata, rootEnv) => {
-  let version;
-  const lastIntMetadata = envsMetadata[rootEnv];
-
-  if (lastIntMetadata) {
-    const rootVersion = semver.coerce(envsMetadata[rootEnv].version).raw;
-    version = semver.inc(rootVersion, 'major') + '-SNAPSHOT';
-  } else {
-    version = '1.0.0-SNAPSHOT';
-  }
-
-  tools.logInfo(`Probable new version : ${version}`);
-
-  // if no versions history is found for the current project, initial version is set
-  if (!versionsMetadata.versions) {
-    tools.logSuccess(`No historical version found : version = ${version}`);
-    version += '.0';
-
-  } else {
-    // check if the root version already exsists
-    const prevVersions = versionsMetadata.versions.filter((v) => {
-      return v.name.indexOf(version) > -1;
-    });
-
-    // do the increment over the last version found having the same root version
-    if (prevVersions.length) {
-      const lastVersion = prevVersions[prevVersions.length - 1];
-
-      if (lastVersion) {
-        tools.logInfo(`Version already found [${lastVersion.name}]`);
-        version = semver.inc(lastVersion.name, 'prerelease');
-        tools.logSuccess(`Final version : ${version}`);
-      }
-
-      // if it's a branch new DEV stream release, the snapshot is itialized
-    } else {
-      version += '.0';
-    }
-  }
-
-  return version;
-}
-
-
-const getNewVersionForEnv = (versionsMetadata, envsMetadata, rootEnv, envTarget) => {
-  let version;
-
-  tools.logInfo(`Fetching version from rootEnv: ${rootEnv} for target: ${envTarget}`);
-
-  // check if envMetadata contains data for the rootEnv
-  if (!envsMetadata[rootEnv]) {
-    throw new Error(`No metadata found for rootEnv: ${rootEnv} for envTarget build: ${envTarget}`);
-  }
-
-  // get the last DEV version from env metadata
-  const lastRootEnvVersion = envsMetadata[rootEnv].version;
-
-  tools.logInfo(`Fetched last version from ${rootEnv} : ${lastRootEnvVersion}`);
-
-  // coerce the version (X.Y.Z-SNAPSHOT will generate : X.Y.Z)
-  const rootVersion = semver.coerce(lastRootEnvVersion).raw;
-
-  // check if the root version already exists
-  const prevVersions = versionsMetadata.versions.filter((v) => {
-    return v.name.indexOf(rootVersion) > -1 && v.envTarget === envTarget;
-  });
-
-  if (prevVersions.length) {
-    const lastVersion = prevVersions[prevVersions.length - 1];
-
-    tools.logInfo(`Version already found [${lastVersion.name}]`);
-    version = semver.inc(lastVersion.name, 'prerelease');
-    tools.logInfo(`Incremented version : ${version}`);
-
-  } else {
-    version = rootVersion + '-' + envTarget + '.0';
-  }
-
-  tools.logSuccess(`Final version : ${version}`);
-
-  return version;
-}
-
-
-const getNewVersionForProd = (versionsMetadata, envsMetadata) => {
-  let version;
-
-  // get the last DEV version from env metadata
-  const lastAccVersion = envsMetadata['ACC'].version;
-
-  tools.logInfo(`Fetched last version from ACC : ${lastAccVersion}`);
+// inner modules
+const innerCommon = require('./common');
 
-  // coerce the version (X.Y.Z-INT.n will generate : X.Y.Z)
-  const rootVersion = semver.coerce(lastAccVersion).raw;
-  const tempVersion = rootVersion.split('.');
-  const rootVersionMinor = `${tempVersion[0]}.${tempVersion[1]}`;
 
-  // check if the root version already exists
-  const prevVersions = versionsMetadata.versions.filter((v) => {
-    return v.name.indexOf(rootVersionMinor) > -1 && v.envTarget === 'PROD';
-  });
-
-  if (prevVersions.length) {
-    const lastVersion = prevVersions[prevVersions.length - 1];
-
-    tools.logInfo(`Version already found [${lastVersion.name}]`);
-    version = semver.inc(lastVersion.name, 'patch');
-    tools.logInfo(`Incremented version : ${version}`);
-
-  } else {
-    version = rootVersion;
-  }
-
-  tools.logSuccess(`Final version : ${version}`);
-
-  return version;
-}
-
-
-
-
-
-
-
-
-
-// PUBLIC METHODS
-
-// for env-based build, we take the latest TST release version as the base
-const getNewVersion = (project, envTarget) => {
+module.exports.getNewVersion = (project, envTarget) => {
   let versionsMetadata;
   let envsMetadata;
 
@@ -166,10 +34,10 @@ const getNewVersion = (project, envTarget) => {
     .then(() => {
       switch(project.options.BUILD_VERSION_STRATEGY_ENVS_CYCLE) {
         case 'DEV_TST_ACC_PROD':
-          return getNewVersionDTAP(envTarget, versionsMetadata, envsMetadata);
+          return innerCommon.getNewVersionDTAP(envTarget, versionsMetadata, envsMetadata);
 
         default:
-          return getNewVersionDefault(envTarget, versionsMetadata, envsMetadata);
+          return innerCommon.getNewVersionDefault(envTarget, versionsMetadata, envsMetadata);
       }
     })
 
@@ -179,161 +47,3 @@ const getNewVersion = (project, envTarget) => {
 }
 
 
-
-
-const getNewVersionDefault = (envTarget, versionsMetadata, envsMetadata) => {
-  tools.logInfo(`Retrieve version for ${envTarget}`);
-
-  return Promise.resolve()
-    .then(() => {
-      let version;
-
-      // =====================================================================
-      // DEV target : format : X.Y.Z-SNAPSHOT.n
-      //  - where X.Y.Z is last INT release next MAJOR version
-      // =====================================================================
-
-      if (envTarget === 'DEV') {
-        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'INT');
-      }
-
-
-      // =====================================================================
-      // TST target : format : X.Y.Z-TST.n
-      //   - where X.Y.Z is the last root version of DEV env target
-      // =====================================================================
-
-      if (envTarget === 'TST') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'DEV', 'TST');
-      }
-
-
-      // =====================================================================
-      // INT target : format : X.Y.Z-INT.n
-      //   - where X.Y.Z is the last root version of TST env target
-      // =====================================================================
-
-      if (envTarget === 'INT') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'TST', 'INT');
-      }
-
-
-      // =====================================================================
-      // ACC target : format : X.Y.Z-envTarget.n
-      //   - where X.Y.Z is the last root version of INT env target
-      // =====================================================================
-
-      if (envTarget === 'ACC') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'INT', 'ACC');
-      }
-
-      // =====================================================================
-      // DLT targets : format : X.Y.Z-envTarget.n
-      //   - where X.Y.Z is the last root version of ACC env target
-      // =====================================================================
-
-      if (envTarget === 'DLT') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'ACC', 'DLT');
-      }
-
-      // =====================================================================
-      // TRN targets : format : X.Y.Z-envTarget.n
-      //   - where X.Y.Z is the last root version of PROD env target
-      // =====================================================================
-
-      if (envTarget === 'TRN') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'ACC', 'TRN');
-      }
-
-      // =====================================================================
-      // FOR PROD : format X.Y.Z(+1)
-      //   - where X.Y.Z is the last version of PROD with the same INT root
-      // =====================================================================
-
-      if (envTarget === 'PROD') {
-        version = getNewVersionForProd(versionsMetadata, envsMetadata);
-      }
-
-      // Check if version has been found, it can never be empty
-      if (!version) {
-        throw new Error(`Unable to generate version for ${envTarget}`);
-      }
-
-      return version;
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-
-
-const getNewVersionDTAP = (envTarget, versionsMetadata, envsMetadata) => {
-  tools.logInfo(`Retrieve version for ${envTarget}`);
-
-  return Promise.resolve()
-    .then(() => {
-      let version;
-
-      // =====================================================================
-      // DEV target : format : X.Y.Z-SNAPSHOT.n
-      //  - where X.Y.Z is last INT release next MAJOR version
-      // =====================================================================
-
-      if (envTarget === 'DEV') {
-        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'TST');
-      }
-
-
-      // =====================================================================
-      // TST target : format : X.Y.Z-TST.n
-      //   - where X.Y.Z is the last root version of DEV env target
-      // =====================================================================
-
-      if (envTarget === 'TST') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'DEV', 'TST');
-      }
-
-
-      // =====================================================================
-      // ACC target : format : X.Y.Z-envTarget.n
-      //   - where X.Y.Z is the last root version of INT env target
-      // =====================================================================
-
-      if (envTarget === 'ACC') {
-        version = getNewVersionForEnv(versionsMetadata, envsMetadata, 'TST', 'ACC');
-      }
-
-
-      // =====================================================================
-      // FOR PROD : format X.Y.Z(+1)
-      //   - where X.Y.Z is the last version of PROD with the same INT root
-      // =====================================================================
-
-      if (envTarget === 'PROD') {
-        version = getNewVersionForProd(versionsMetadata, envsMetadata);
-      }
-
-      // Check if version has been found, it can never be empty
-      if (!version) {
-        throw new Error(`Unable to generate version for ${envTarget}`);
-      }
-
-      return version;
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-
-
-module.exports = {
-  getNewVersion,
-  getNewVersionDefault,
-  getNewVersionDTAP,
-}

package/scripts/csdr/version/app.js

@@ -2,9 +2,7 @@
 
 const appDefault = require('./app-default');
 const appEnvTarget = require('./app-env-target');
-
-module.exports.updatePackageVersion = appDefault.updatePackageVersion;
-module.exports.getCurrentVersion = appDefault.getCurrentVersion;
+const appCommon = require('./app-common');
 
 
 module.exports.getNewVersion = (project, isSnapshot, isSupportBranch, envTarget) => {
@@ -21,3 +19,7 @@ module.exports.getNewVersion = (project, isSnapshot, isSupportBranch, envTarget)
       throw e;
     })
 }
+
+module.exports.updatePackageVersion = appCommon.updatePackageVersion;
+
+module.exports.getCurrentVersion = appCommon.getCurrentVersion;

package/scripts/csdr/version/{app-env-target.test.js → common..test.js}

@@ -1,4 +1,5 @@
-const appEnvTarget = require('./app-env-target');
+const common = require('./common');
+const { expect, assert } = require('chai');
 
 const versionsMetadata = {
   "versions": [
@@ -74,10 +75,10 @@ const envsMetadata = {
 
 describe('[CSDR-version-app-env-target] - getNewVersionDefault()', () => {
 
-  test('should fail if envTarget is empty/null/undefined', () => {
-    return appEnvTarget.getNewVersionDefault()
+  it('should fail if envTarget is empty/null/undefined', () => {
+    return common.getNewVersionDefault()
       .catch((e) => {
-        expect(e).not.toBeUndefined();
+        expect(e).not.to.be.undefined;
       })
   })
 
@@ -104,42 +105,42 @@ describe('[CSDR-version-app-env-target] - getNewVersionDefault()', () => {
   * DLT 3.0.0-DLT.0 = PROD
   */
 
-  test('version for DEV should return INT raw major + 1', () => {
-    return appEnvTarget.getNewVersionDefault('DEV', versionsMetadata, envsMetadata)
+  it('version for DEV should return INT raw major + 1', () => {
+    return common.getNewVersionDefault('DEV', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('118.0.0-SNAPSHOT.14');
+        expect(version).to.equal('118.0.0-SNAPSHOT.14');
       })
   })
 
-  test('version for TST should return DEV raw major', () => {
-    return appEnvTarget.getNewVersionDefault('TST', versionsMetadata, envsMetadata)
+  it('version for TST should return DEV raw major', () => {
+    return common.getNewVersionDefault('TST', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('118.0.0-TST.0');
+        expect(version).to.equal('118.0.0-TST.0');
       })
   })
 
-  test('version for INT should return TST raw major', () => {
-    return appEnvTarget.getNewVersionDefault('INT', versionsMetadata, envsMetadata)
+  it('version for INT should return TST raw major', () => {
+    return common.getNewVersionDefault('INT', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0-INT.0');
+        expect(version).to.equal('117.0.0-INT.0');
       })
   })
 
-  test('version for ACC should return INT raw major', () => {
-    return appEnvTarget.getNewVersionDefault('ACC', versionsMetadata, envsMetadata)
+  it('version for ACC should return INT raw major', () => {
+    return common.getNewVersionDefault('ACC', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0-ACC.0');
+        expect(version).to.equal('117.0.0-ACC.0');
       })
   })
 
-  test('version for PROD should return ACC raw major', () => {
-    return appEnvTarget.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
+  it('version for PROD should return ACC raw major', () => {
+    return common.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0');
+        expect(version).to.equal('117.0.0');
       })
   })
 
-  test('version for PROD should return ACC raw major, increment if x.0.0 already exits to next patch version x.0.1', () => {
+  it('version for PROD should return ACC raw major, increment if x.0.0 already exits to next patch version x.0.1', () => {
     const versionsMetadata = {
       "versions": [
         {
@@ -149,13 +150,13 @@ describe('[CSDR-version-app-env-target] - getNewVersionDefault()', () => {
         },
       ]
     };
-    return appEnvTarget.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
+    return common.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.1');
+        expect(version).to.equal('117.0.1');
       })
   })
 
-  test('version for PROD should return ACC raw major, increment if x.0.1 already exist to next patch version x.0.2', () => {
+  it('version for PROD should return ACC raw major, increment if x.0.1 already exist to next patch version x.0.2', () => {
     const versionsMetadata = {
       "versions": [
         {
@@ -170,23 +171,23 @@ describe('[CSDR-version-app-env-target] - getNewVersionDefault()', () => {
         }
       ]
     };
-    return appEnvTarget.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
+    return common.getNewVersionDefault('PROD', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.2');
+        expect(version).to.equal('117.0.2');
       })
   })
 
-  test('version for DLT should return ACC raw major', () => {
-    return appEnvTarget.getNewVersionDefault('DLT', versionsMetadata, envsMetadata)
+  it('version for DLT should return ACC raw major', () => {
+    return common.getNewVersionDefault('DLT', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0-DLT.0');
+        expect(version).to.equal('117.0.0-DLT.0');
       })
   })
 
-  test('version for TRN should return ACC raw major', () => {
-    return appEnvTarget.getNewVersionDefault('TRN', versionsMetadata, envsMetadata)
+  it('version for TRN should return ACC raw major', () => {
+    return common.getNewVersionDefault('TRN', versionsMetadata, envsMetadata)
       .then((version) => {
-        expect(version).toEqual('117.0.0-TRN.0');
+        expect(version).to.equal('117.0.0-TRN.0');
       })
   })