@tangelo/tangelo-configuration-toolkit 1.10.3 → 1.11.0

package/index.js

@@ -5,10 +5,10 @@ String.prototype.toFws = function(){
 };
 
 
-const findUp    = require('find-up');
-const fs        = require('fs-extra');
-const {getPath} = require('global-modules-path');
-const path      = require('path');
+const {execSync}  = require('child_process');
+const findUp      = require('find-up');
+const fs          = require('fs-extra');
+const path        = require('path');
 
 const execGitCommand = require('./src/lib/exec-git-command');
 
@@ -57,12 +57,17 @@ _paths.repoconfig = path.join(_paths.repo, appname+'-repoconfig.json');
 _paths.apply = process.cwd().replace(_paths.repo, '').substr(1);
 
 
-global._appdata  = fs.readJsonSync(_paths.appdata, {throws: false}) || {};
+global._appdata = fs.readJsonSync(_paths.appdata, {throws: false}) || {};
+_appdata._update = (data) => Object.assign(_appdata, data, {_changed: true});
+if (!_appdata.npmPath) {
+  _appdata._update({npmPath: execSync('npm config get prefix', {encoding: 'UTF-8'}).replace(/\s$/, '')});
+}
+
 global._packages = {
   TCT: {name: '@tangelo/tangelo-configuration-toolkit', version: require('./package.json')?.version},
   FDT: {name: '@fontoxml/fontoxml-development-tools'}
 }
-_packages.FDT.version = fs.readJsonSync(`${getPath(_packages.FDT.name)}/package.json`, {throws: false})?.version;
+_packages.FDT.version = fs.readJsonSync(path.join(_appdata.npmPath, 'node_modules', _packages.FDT.name, 'package.json'), {throws: false})?.version;
 
 try { global._appconfig = _paths.appconfig && fs.readJsonSync(_paths.appconfig) || {}; }
 catch({message}) { _error('Error in '+message); }
@@ -71,29 +76,27 @@ _appconfig.sharedConfigPath = path.resolve(_paths.appconfig || '', '..', _appcon
 _appconfig.shared           = fs.readJsonSync(_appconfig.sharedConfigPath, {throws: false}) || {};
 
 
-global._commit = {
-  branch: execGitCommand('rev-parse --abbrev-ref HEAD', _paths.repo),
-  hash: execGitCommand('rev-parse HEAD', _paths.repo),
-  date: execGitCommand('log -1 --format=%cd --date=iso-strict', _paths.repo)
-};
-_commit.lastDateRemote = execGitCommand('log -1 --format=%cd --date=iso-strict origin/'+_commit.branch,_paths.repo);
-
-global._tdiCommit = {
-  hash: execGitCommand('rev-parse HEAD', path.join(_paths.repo, _paths.tdi)),
-  after (commitHash) {
-    return execGitCommand(`merge-base --is-ancestor ${commitHash} ${this.hash}`, path.join(_paths.repo, _paths.tdi), 0);
-  },
-  fontoVersions: [ // latest commits first
-    {commitHash: 'e599766', regex: /^7\.1[45]\./},
-    {commitHash: '77b8ea9', regex: /^7\.14\./}, // 7.14.x
-    {commitHash: '8066c44', regex: /^7\.13\./}, // 7.13.x
-    {commitHash: 'a2b2d4e', regex: /^7\.12\./}  // 7.12.x
-  ],
-  stopUsingRepoconfigFile: '1f12bff' // release/5.1 10-05-2021
+global._git = {
+  user: execGitCommand(`config --get user.email`, _paths.repo),
+  commitLocal: execGitCommand(`log -1 --format=%D;%H;%cd --date=iso-strict`, _paths.repo, ['branch', 'hash', 'date']),
+  commitLocalTdi: {
+    ...execGitCommand(`log -1 --format=%D;%H;%cd --date=short`, path.join(_paths.repo, _paths.tdi),['tags', 'hash', 'date']),
+    after (commitHash) {
+      return execGitCommand(`merge-base --is-ancestor ${commitHash} ${this.hash}`, path.join(_paths.repo, _paths.tdi), null, 0);
+    },
+    fontoVersions: [ // latest commits first
+      {commitHash: 'e599766', regex: /^7\.1[45]\./},
+      {commitHash: '77b8ea9', regex: /^7\.14\./}, // 7.14.x
+      {commitHash: '8066c44', regex: /^7\.13\./}, // 7.13.x
+      {commitHash: 'a2b2d4e', regex: /^7\.12\./}  // 7.12.x
+    ],
+    stopUsingRepoconfigFile: '1f12bff' // release/5.1 10-05-2021
+  }
 };
+_git.commitRemote = execGitCommand('log -1 --format=%cd --date=iso-strict origin/'+_git.commitLocal.branch, _paths.repo, ['date']);
 
 
-if (_tdiCommit.after(_tdiCommit.stopUsingRepoconfigFile)) {
+if (_git.commitLocalTdi.after(_git.commitLocalTdi.stopUsingRepoconfigFile)) {
   global._repoconfig = require('./src/lib/get-repoconfig')();
 }
 else {
@@ -111,4 +114,19 @@ global._isPre42 = fs.existsSync(path.join(_paths.repo, _paths.tdi, 'create_new_p
 global._isPre51 = !fs.existsSync(path.join(_paths.repo, _paths.tdi, 'src')); // folder changed in 5.1 (check new folder because old one could still exist after branch switch)
 
 
+
+process.on('beforeExit', () => {
+  _write(); // print empty line before and after update check
+
+  require('./src/lib/package-update-check')();
+
+  if (_appdata._changed) {
+    delete _appdata._update;
+    delete _appdata._changed;
+    fs.writeJsonSync(_paths.appdata, _appdata, {spaces: 2});
+  }
+
+});
+
+
 require('./src/cli.js')();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangelo/tangelo-configuration-toolkit",
-  "version": "1.10.3",
+  "version": "1.11.0",
   "description": "Tangelo Configuration Toolkit is a command-line toolkit which offers support for developing a Tangelo configuration.",
   "bin": {
     "tct": "bin/index.js",
@@ -21,11 +21,11 @@
     "@babel/preset-env": "^7.16.11",
     "cli-spinner": "^0.2.10",
     "compare-versions": "^4.1.1",
+    "console-table-printer": "^2.11.1",
     "del": "^6.0.0",
     "event-stream": "^4.0.1",
     "find-up": "^5.0.0",
     "fs-extra": "^10.0.0",
-    "global-modules-path": "^2.3.1",
     "globby": "^6.1.0",
     "gulp": "^4.0.2",
     "gulp-babel": "^8.0.0",

package/src/cli.js

@@ -1,26 +1,6 @@
-const {compare} = require('compare-versions');
-const exec  = require('util').promisify(require('child_process').exec);
-const fs    = require('fs-extra');
 const yargs = require('yargs');
 
 
-const updateAppdata = (data) => Object.assign(_appdata, data, {_changed: true});
-
-const checkForPackageUpdate = (package) => (
-  exec(`npm view -g ${_packages[package].name} version`)
-  .then(r => {
-    const versionAvailable = r.stdout.match(/([\d/.]+)/)[1];
-    if (!_packages[package].version) _warn(`${package} is not installed! Run ` + `npm i -g ${_packages[package].name}`.white);
-    else if (compare(_packages[package].version, versionAvailable, '<')) {
-      updateAppdata({[`updateCheck${package}`]: {executed: new Date(), versionAvailable}});
-      return versionAvailable;
-    }
-    else updateAppdata({[`updateCheck${package}`]: {executed: new Date()}});
-  })
-  .catch(e => _warn(`Failed checking latest version of ${package}.`))
-);
-
-
 module.exports = function cli () {
 
   _write();
@@ -45,7 +25,7 @@ module.exports = function cli () {
       init: {alias: 'i', desc: 'Create repository content structure', conflicts: ['p', 's', 'c']},
       project: {alias: 'p', desc: 'Create project configuration', conflicts: ['i', 's', 'c']},
       symlinks: {alias: 's', desc: 'Recreate symlinks to TDI', conflicts: ['p', 'i', 'c']},
-      config: {alias: 'c', desc: 'Create repo-config file', conflicts: ['p', 'i', 's'], hidden: _tdiCommit.after(_tdiCommit.stopUsingRepoconfigFile)},
+      config: {alias: 'c', desc: 'Create repo-config file', conflicts: ['p', 'i', 's'], hidden: _git.commitLocalTdi.after(_git.commitLocalTdi.stopUsingRepoconfigFile)},
       oxygen: {alias: 'x', desc: 'Create or update oXygen project file (.xpr)', conflicts: ['p', 'i', 'c']}
     },
     handler: require('./modules/build')
@@ -112,6 +92,15 @@ module.exports = function cli () {
       remove: {alias: 'r', desc: 'Remove project configuration', conflicts: ['i', 'c', 'g']}
     },
     handler: require('./modules/sql')
+  }).command({
+    command: 'versions',
+    aliases: ['v'],
+    desc: 'Show version information',
+    builder: {
+      find: {alias: 'f', desc: `Find all version information          [choices: "sort-project"(default),"sort-type"]`},
+      server: {alias: 's', desc: 'Pass server name (set in config file)', default: _appconfig.defaultServer}
+    },
+    handler: require('./modules/version')
   })
   .recommendCommands()
   .option('config', {alias: 'c', desc: 'Show loaded appconfig', global: false})
@@ -143,34 +132,4 @@ module.exports = function cli () {
 
   }
 
-
-  let checkUpdatesDone = false;
-
-  process.on('beforeExit', () => {
-    _write(); // print empty line before and after update check
-
-    if (!checkUpdatesDone) { // check if updatecheck has ran before because async calls below trigger beforeExit again
-      checkUpdatesDone = true;
-
-      ['TCT', 'FDT'].forEach(p => {
-        const updateMsg = (va) => `| Update ${p} to ${va} | ` + `npm i -g ${_packages[p].name}`.white;
-        const {versionAvailable} = _appdata[`updateCheck${p}`] || {};
-
-        if (new Date() - new Date(_appdata[`updateCheck${p}`]?.executed || 0) > 1000*3600*24*7) { // check every week
-          checkForPackageUpdate(p).then(r => r && _warn(updateMsg(r)));
-        }
-        else if (versionAvailable) {
-          if (compare(_packages[p].version, versionAvailable, '<')) _warn(updateMsg(versionAvailable));
-          else updateAppdata({[`updateCheck${p}`]: {executed: new Date()}});
-        }
-      });
-    }
-
-    if (_appdata._changed) {
-      delete _appdata._changed;
-      fs.writeJsonSync(_paths.appdata, _appdata, {spaces: 2});
-    }
-
-  });
-
 }

package/src/lib/exec-git-command.js

@@ -1,10 +1,26 @@
 const {spawnSync} = require('child_process');
 
 
-module.exports = function execGitCommand(args, path, status) {
+module.exports = function execGitCommand(args, path, returnProperties = [], expectedStatus) {
 
   const cmd = spawnSync('git', [args], {cwd: path, shell: true});
-  const res = status!=undefined ? cmd.status == status : (cmd.stdout||'').toString().trim();
-  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(res) ? new Date(res) : res;
+
+  if (expectedStatus!=undefined) return cmd.status == expectedStatus;
+
+  let retObj = (cmd.stdout||'').toString().trim().split(';');
+  if (returnProperties[0]) {
+    retObj = (
+      o = {},
+      retObj.forEach((v,i) => {
+        o[returnProperties[i]] =
+          returnProperties[i] == 'date' ? new Date(v) :
+          returnProperties[i] == 'branch' ? v.replace(/HEAD -> ([^,]+).*/, '$1') :
+          v
+        ;
+      }),
+      o
+    )
+  }
+  return retObj.length==1 ? retObj[0] : retObj;
 
 };

package/src/lib/get-repoconfig.js

@@ -2,7 +2,7 @@ const fs      = require('fs-extra');
 const globby  = require('globby');
 
 
-module.exports = function getRepoconfig(repoconfigPath) {
+module.exports = function getRepoconfig() {
 
   const repoconfig = [];
 

package/src/lib/package-update-check.js

@@ -0,0 +1,39 @@
+const {compare}   = require('compare-versions');
+const exec        = require('util').promisify(require('child_process').exec);
+
+
+const doUpdateCheck = (package) => (
+  exec(`npm view -g ${_packages[package].name} version`)
+  .then(r => {
+    const versionAvailable = r.stdout.match(/([\d/.]+)/)[1];
+    if (!_packages[package].version) _warn(`${package} is not installed! Run ` + `npm i -g ${_packages[package].name}`.white);
+    else if (compare(_packages[package].version, versionAvailable, '<')) {
+      _appdata._update({[`updateCheck${package}`]: {executed: new Date(), versionAvailable}});
+      return versionAvailable;
+    }
+    else _appdata._update({[`updateCheck${package}`]: {executed: new Date()}});
+  })
+  .catch(e => _warn(`Failed checking latest version of ${package}.`))
+);
+
+let checkUpdatesDone = false;
+
+
+module.exports = function packageUpdateCheck () {
+  if (!checkUpdatesDone) { // check if updatecheck has ran before because async calls below trigger beforeExit again
+    checkUpdatesDone = true;
+
+    ['TCT', 'FDT'].forEach(p => {
+      const updateMsg = (va) => `| Update ${p} to ${va} | ` + `npm i -g ${_packages[p].name}`.white;
+      const {versionAvailable} = _appdata[`updateCheck${p}`] || {};
+
+      if (new Date() - new Date(_appdata[`updateCheck${p}`]?.executed || 0) > 1000*3600*24*7) { // check every week
+        doUpdateCheck(p).then(r => r && _warn(updateMsg(r)));
+      }
+      else if (versionAvailable) {
+        if (compare(_packages[p].version, versionAvailable, '<')) _warn(updateMsg(versionAvailable));
+        else _appdata._update({[`updateCheck${p}`]: {executed: new Date()}});
+      }
+    });
+  }
+}

package/src/modules/build/index.js

@@ -74,7 +74,7 @@ module.exports = function build (argv) {
   }
 
   if (argv.config) {
-    if (_tdiCommit.after(_tdiCommit.stopUsingRepoconfigFile)) _error('This option only works for older repo\'s using a repoconfig file.');
+    if (_git.commitLocalTdi.after(_git.commitLocalTdi.stopUsingRepoconfigFile)) _error('This option only works for older repo\'s using a repoconfig file.');
 
 
     inquirer

package/src/modules/deploy/config.js

@@ -55,7 +55,7 @@ module.exports = {
         username: serverConfig.config.username,
         agent: process.platform=='win32' ? 'pageant' : process.env.SSH_AUTH_SOCK,
         agentForward: process.platform!='win32',
-        readyTimeout: 10000,
+        readyTimeout: 15000,
         retries: 1
       }
     };
@@ -65,8 +65,8 @@ module.exports = {
     if (ftpConfig.host && !(ftpConfig.port && ftpConfig.parallel && ftpConfig.username)) _error('Config is incomplete!');
 
     this.localTransfer  = !ftpConfig.host;
-    this.envDev         = /\.dev\.tangelo\.nl$/.test(ftpConfig.host);
     this.deliveryPack   = serverConfig.mode == 'delivery-pack';
+    this.envDev         = this.localTransfer && !this.deliveryPack || /\.dev\.tangelo\.nl$/.test(ftpConfig.host);
 
     if (this.deliveryPack) {
       const dateStr = new Date().toISOString().replace(/(.*)T(\d+):(\d+):(\d+).*/g, '$1_$2$3$4');
@@ -129,13 +129,13 @@ module.exports = {
     }
     else this.replaceStrings.push(['debugMode>true', 'debugMode>false', '**/xopus/xml/*']);
 
-    _info(`Branch: ${_commit.branch}`);
+    _info(`Branch: ${_git.commitLocal.branch}`);
     _info(`Source: ${path.join(process.cwd(), transferPattern)}`);
     _info(`Server: ${ftpConfig.host ? `${ftpConfig.host}:${ftpConfig.port}` : 'local'}`);
     _info(`Target: ${this.getRemotePath(transferPattern)}`);
     _write();
 
-    if (_commit.date < _commit.lastDateRemote) {
+    if (_git.commitLocal.date < _git.commitRemote.date) {
       _warn(`You're not deploying from the most recent git commit!\n`)
     }
   }

package/src/modules/deploy/execute.js

@@ -44,6 +44,7 @@ const remote = {
       sshI.execCommand(command[0])
       .then(result => {
         if (result.stderr) _warn(result.stderr);
+        else if (command[1] === '') _write(result.stdout);
         else _info(command[1] || command[0], true);
 
         executing--;
@@ -126,15 +127,19 @@ const transfer = (paths, lrServer) => {
   const srcset  = s.create(paths);
   const files   = [];
 
+  // local git repo must be on latest commit containing fonto changes, and fonto build files must be newer than that commit, unless that commit belongs to the current user
   const fontoPaths = {outdated: [], uptodate: []};
-  const removeOutdatedFontoBuild = g_filter(file => { // fonto build files must be newer than the last commit date containing fonto changes
+  const removeOutdatedFontoBuild = g_filter(file => {
     const prPath = 'config\\'+file.relative.replace(/fonto.+$/, '');
     if (fontoPaths.outdated.includes(prPath)) return false;
     if (fontoPaths.uptodate.includes(prPath)) return true;
     if (file.relative.match(/fonto[\\\/]dist/)) {
       const paths = `${prPath}\\fonto ${prPath}\\schema ${_paths.tdi}`; // only check paths containing fonto sources
-      const lastFontoCommitDate = execGitCommand(`log -1 --format=%cd --date=iso-strict origin/${_commit.branch} ${paths}`, _paths.repo);
-      if (fs.statSync(file.relative).mtime < lastFontoCommitDate) {
+      const lastFontoCommit = execGitCommand(`log -1 --format=%ae;%cd --date=iso-strict origin/${_git.commitLocal.branch} ${paths}`, _paths.repo, ['author', 'date']);
+      if (
+        lastFontoCommit.author != _git.user &&
+        (lastFontoCommit.date > _git.commitLocal.date || lastFontoCommit.date > fs.statSync(file.relative).mtime)
+      ) {
         fontoPaths.outdated.push(prPath);
         return false;
       }

package/src/modules/fonto/commands.js

@@ -14,9 +14,9 @@ const allowedFontoVersionRegex = () => {
   const cfvPath = path.join(_paths.repo, _paths.tdi, 'tct/fonto/compatibleVersions.json');
   if (fs.pathExistsSync(cfvPath)) return RegExp(fs.readJsonSync(cfvPath).regex);
 
-  // old way: a regex for each basecommit is stored in global._tdiCommit
-  for (const fv of _tdiCommit.fontoVersions) {
-    if (_tdiCommit.after(fv.commitHash)) return fv.regex;
+  // old way: a regex for each basecommit is stored in global._git.commitLocalTdi
+  for (const fv of _git.commitLocalTdi.fontoVersions) {
+    if (_git.commitLocalTdi.after(fv.commitHash)) return fv.regex;
   }
 };
 

package/src/modules/migrate/index.js

@@ -6,7 +6,7 @@ const path      = require('path');
 module.exports = function migrate (argv) {
   if (_isPre51) _error('This command only works when using branch release/5.1 and up.');
 
-  let filter = path.join(_paths.apply, argv.filter); // Default set filter with filter added to the command argument -f
+  let filter = path.join(_paths.apply, argv.filter).toFws(); // Default set filter with filter added to the command argument -f
 
   const scripts =
     globby
@@ -24,10 +24,17 @@ module.exports = function migrate (argv) {
       value: s
     }))
   ;
-
+  
+  // Search scriptname set in commandline in scripts and return in cmdlScript if found
+  const cmdlScript = Object.values(scripts).filter(s => s.name === `${argv.execute}`)[0];
+  if (cmdlScript) {
+    _info(`Migration: ${cmdlScript.name}`);
+  };
+  
   inquirer
   .prompt([{
-    message: 'Choose a migration: ', name: 'script', type: 'list', choices: scripts, pageSize: 5, loop: false
+    message: 'Choose a migration: ', name: 'script', type: 'list', choices: scripts, pageSize: 5, loop: false,
+    when: !(cmdlScript) // Only show choice for migration when no script is set in commandline
   },{
     message: 'Choose filter: ', name: 'filter', type: 'list', pageSize: 5, loop: false,
     choices: [{name: `- All`, value:argv.filter},{name:'- Choose active projects',value:'projects'}],
@@ -41,6 +48,11 @@ module.exports = function migrate (argv) {
     _write();
     _info(`Working folder set to: ${_paths.repo}`);
     
+    if (cmdlScript) {
+      // Set script to execute to script entered in commandline
+      a.script = cmdlScript.value;
+    }
+
     if (a.filter === 'projects' && _repoconfig.length > a.projects.length) {
       // push paths of chosen active documents to projectFolders (only if not all projects are chosen)
       const projectFolders = [];

package/src/modules/sql/index.js

@@ -37,7 +37,7 @@ const checkLog = (logFilePath, remove=true) => {
 
 module.exports = function sql (argv) {
 
-  if ((argv.install || argv.configure) && _commit.date < _commit.lastDateRemote) {
+  if ((argv.install || argv.configure) && _git.commitLocal.date < _git.commitRemote.date) {
     _warn(`You're not deploying from the most recent git commit!\n`)
   }
 

package/src/modules/version/index.js

@@ -0,0 +1,174 @@
+const {execSync}           = require('child_process');
+const fs                   = require('fs-extra');
+const globby               = require('globby');
+const path                 = require('path');
+const {Table}              = require('console-table-printer');
+const execGitCommand       = require('../../lib/exec-git-command');
+const c                    = require('../deploy/config');
+const {remote}             = require('../deploy/execute');
+
+const getGitInfo = (argv) => {
+  // Version info TDI submodule
+  
+  const branchInfo = [];
+  const gitSubmoduleInfo = new Table({
+    columns: [
+      { name: 'property', title: 'TDI - submodule', alignment: 'left'},
+      { name: 'value', alignment: 'left'}
+    ],
+  });
+  
+  // Fetch all
+  execGitCommand(`fetch -pf --all`, path.join(_paths.repo, _paths.tdi));
+
+  // Get branches containing TDI HEAD commit
+  const releaseBranches = execGitCommand(`branch --contains ${_git.commitLocalTdi.hash}`, path.join(_paths.repo, _paths.tdi)).match(/release\/[^\s]+/gsm);
+  if (releaseBranches) {
+    releaseBranches.forEach(b => {
+      // Get number of commits behind
+      const count = execGitCommand(`rev-list HEAD...origin/${b} --count`, path.join(_paths.repo, _paths.tdi));
+      // _info(`debug: [${b}]:${count}`);
+      // Push number of commits behind to branchInfo
+      branchInfo.push({name:b,commitsBehind:count});
+    });
+  }
+  
+  // Get the first possible branch; prefer release/5.1 over release/5.2:
+  const firstBranch = branchInfo.sort((a, b) => a.name > b.name ? 1 : -1)[0];
+
+  // Create table rows for TDI submodule info
+  gitSubmoduleInfo.addRow({
+    property: `Commit date (DD-MM-YYYY)`,
+    value: `${_git.commitLocalTdi.date.toLocaleDateString('nl-nl')}`
+  });
+  if (firstBranch) {
+    gitSubmoduleInfo.addRow({
+      property: `Branch`,
+      value: `${firstBranch.name}`
+    });
+    gitSubmoduleInfo.addRow({
+      property: `Commits behind`,
+      value: `${firstBranch.commitsBehind}`
+    });
+  } else {
+    gitSubmoduleInfo.addRow({
+      property: `Branch could not be determined`,
+      value: ``
+    });
+  }
+
+  // Print TDI submodule info
+  gitSubmoduleInfo.printTable();
+}
+
+const getFileExtractInfo = (argv) => {
+  // version info miscellaneous
+  const sorting = `${argv.info}`.includes(`sort-type`) ? `type` : `project`;
+  const projects = new Set;
+  const types = new Set;
+  const versionInfoConfigPath  = path.join(_paths.repo, _paths.tdi, 'tct/version/versionInfo.js');
+  const versionInfo = new Table({
+    columns: [
+      { name: 'path', alignment: 'left'},
+      { name: 'type', alignment: 'left'},
+      { name: 'version', alignment: 'left'},
+      { name: 'sort'}
+    ],
+    disabledColumns: ['sort'],
+    sort: (a, b) => a.sort.toLowerCase() > b.sort.toLowerCase() ? 1 : -1
+  });
+
+  if (fs.existsSync(versionInfoConfigPath)) {
+    const config = require(`${versionInfoConfigPath}`);
+
+    config.forEach(v => {
+      const location = path.join(_paths.repo,v.glob);
+
+      globby
+      .sync(`${location}`)
+      .forEach(f => {
+        const filePathExtract = f.match(/.*(?<path>(cmscustom|site-stylesheets)\/(?<customer>[^\/]*)\/(?<project>[^\/]*)\/.*)/);
+        const path = filePathExtract.groups.path ? filePathExtract.groups.path : '';
+        const customer = filePathExtract.groups.customer ? filePathExtract.groups.customer : '';
+        const project = filePathExtract.groups.project ? filePathExtract.groups.project : '';
+
+        const fileContent = fs.readFileSync(f).toString();
+        v.extracts.forEach(e => {
+          const extract = fileContent.match(e.regex);
+          if (extract) {
+            projects.add(project); // Store the projects where versioninfo is found
+            types.add(e.type); // Store the types for which versioninfo is found
+            versionInfo.addRow( // Create row with version information to output
+              { path: `${path}`
+              , sort: `${sorting==`project` ? project : e.type}_2${sorting==`project` ? e.type : extract.groups.version}` // Output is sorted on project or type: '_2' ensures it is rendered after the empty row and the row with the project name
+              , type: `${e.type}`
+              , version: `${extract.groups.version}`
+              }
+            );
+          }
+        });
+      })
+    });
+
+    if (sorting==`project`) {
+      /* For projects containing version information */
+      projects.forEach(p => {
+        /* Add empty row after project */
+        versionInfo.addRow(
+          { path: ``
+          , sort: `${p}_3`
+          , type: ``
+          , version: ``
+          }
+        )
+        /* Add row with project name */
+        versionInfo.addRow(
+          { path: `-- ${p}:`
+          , sort: `${p}_1`
+          , type: ``
+          , version: ``
+          }, 
+          { color: 'yellow' }
+        )
+      });
+    } else 
+    if (sorting==`type`) {
+      types.forEach(t => {
+        /* Add empty row after type */
+        versionInfo.addRow(
+          { path: ``
+          , sort: `${t}_3`
+          , type: ``
+          , version: ``
+          }
+        )
+      });
+    }
+    versionInfo.printTable();
+  } else {
+    _warn(`Version info of miscellaneous items cannot be extracted:\nCannot find required files in TDI submodule. Try updating TDI submodule.`);
+  }
+}
+
+const getServerInfo = (argv) => {
+  // Remote server info
+  // common setup
+  _write();
+  c.setServer(argv.server);
+
+  if (!c.envDev) {
+    _info(`Remote version info for '${c.server.ftpConfig.host}':\n`)
+    remote.add('sudo ~root/scripts/version.sh', '').process();
+  } else {
+    _info(`For development environments no server version information is available. Check rancher / database for this information.\nAdd the --server option with a non-dev environment to see version information for that server.`);
+  }
+}
+
+module.exports = function version (argv) {
+  _info(`Version information of this git repository\n`)
+
+  getGitInfo(argv);
+  getFileExtractInfo(argv);
+  getServerInfo(argv);
+
+};