@dry-software/cmake-js 7.3.0

package/lib/dist.js

@@ -0,0 +1,176 @@
+'use strict'
+const environment = require('./environment')
+const path = require('path')
+const urljoin = require('url-join')
+const fs = require('fs-extra')
+const CMLog = require('./cmLog')
+const TargetOptions = require('./targetOptions')
+const runtimePaths = require('./runtimePaths')
+const Downloader = require('./downloader')
+const os = require('os')
+
+function testSum(sums, sum, fPath) {
+	const serverSum = sums.find(function (s) {
+		return s.getPath === fPath
+	})
+	if (serverSum && serverSum.sum === sum) {
+		return
+	}
+	throw new Error("SHA sum of file '" + fPath + "' mismatch!")
+}
+
+class Dist {
+	get internalPath() {
+		const cacheDirectory = '.cmake-js'
+		const runtimeArchDirectory = this.targetOptions.runtime + '-' + this.targetOptions.arch
+		const runtimeVersionDirectory = 'v' + this.targetOptions.runtimeVersion
+
+		return (
+			this.options.runtimeDirectory ||
+			path.join(os.homedir(), cacheDirectory, runtimeArchDirectory, runtimeVersionDirectory)
+		)
+	}
+	get externalPath() {
+		return runtimePaths.get(this.targetOptions).externalPath
+	}
+	get downloaded() {
+		let headers = false
+		let libs = true
+		let stat = getStat(this.internalPath)
+		if (stat.isDirectory()) {
+			if (this.headerOnly) {
+				stat = getStat(path.join(this.internalPath, 'include/node/node.h'))
+				headers = stat.isFile()
+			} else {
+				stat = getStat(path.join(this.internalPath, 'src/node.h'))
+				if (stat.isFile()) {
+					stat = getStat(path.join(this.internalPath, 'deps/v8/include/v8.h'))
+					headers = stat.isFile()
+				}
+			}
+			if (environment.isWin) {
+				for (const libPath of this.winLibs) {
+					stat = getStat(libPath)
+					libs = libs && stat.isFile()
+				}
+			}
+		}
+		return headers && libs
+
+		function getStat(path) {
+			try {
+				return fs.statSync(path)
+			} catch (e) {
+				return {
+					isFile: () => false,
+					isDirectory: () => false,
+				}
+			}
+		}
+	}
+	get winLibs() {
+		const libs = runtimePaths.get(this.targetOptions).winLibs
+		const result = []
+		for (const lib of libs) {
+			result.push(path.join(this.internalPath, lib.dir, lib.name))
+		}
+		return result
+	}
+	get headerOnly() {
+		return runtimePaths.get(this.targetOptions).headerOnly
+	}
+
+	constructor(options) {
+		this.options = options || {}
+		this.log = new CMLog(this.options)
+		this.targetOptions = new TargetOptions(this.options)
+		this.downloader = new Downloader(this.options)
+	}
+
+	async ensureDownloaded() {
+		if (!this.downloaded) {
+			await this.download()
+		}
+	}
+	async download() {
+		const log = this.log
+		log.info('DIST', 'Downloading distribution files to: ' + this.internalPath)
+		await fs.ensureDir(this.internalPath)
+		const sums = await this._downloadShaSums()
+		await Promise.all([this._downloadLibs(sums), this._downloadTar(sums)])
+	}
+	async _downloadShaSums() {
+		if (this.targetOptions.runtime === 'node') {
+			const sumUrl = urljoin(this.externalPath, 'SHASUMS256.txt')
+			const log = this.log
+			log.http('DIST', '\t- ' + sumUrl)
+			return (await this.downloader.downloadString(sumUrl))
+				.split('\n')
+				.map(function (line) {
+					const parts = line.split(/\s+/)
+					return {
+						getPath: parts[1],
+						sum: parts[0],
+					}
+				})
+				.filter(function (i) {
+					return i.getPath && i.sum
+				})
+		} else {
+			return null
+		}
+	}
+	async _downloadTar(sums) {
+		const log = this.log
+		const self = this
+		const tarLocalPath = runtimePaths.get(self.targetOptions).tarPath
+		const tarUrl = urljoin(self.externalPath, tarLocalPath)
+		log.http('DIST', '\t- ' + tarUrl)
+
+		const sum = await this.downloader.downloadTgz(tarUrl, {
+			hash: sums ? 'sha256' : null,
+			cwd: self.internalPath,
+			strip: 1,
+			filter: function (entryPath) {
+				if (entryPath === self.internalPath) {
+					return true
+				}
+				const ext = path.extname(entryPath)
+				return ext && ext.toLowerCase() === '.h'
+			},
+		})
+
+		if (sums) {
+			testSum(sums, sum, tarLocalPath)
+		}
+	}
+	async _downloadLibs(sums) {
+		const log = this.log
+		const self = this
+		if (!environment.isWin) {
+			return
+		}
+
+		const paths = runtimePaths.get(self.targetOptions)
+		for (const dirs of paths.winLibs) {
+			const subDir = dirs.dir
+			const fn = dirs.name
+			const fPath = subDir ? urljoin(subDir, fn) : fn
+			const libUrl = urljoin(self.externalPath, fPath)
+			log.http('DIST', '\t- ' + libUrl)
+
+			await fs.ensureDir(path.join(self.internalPath, subDir))
+
+			const sum = await this.downloader.downloadFile(libUrl, {
+				path: path.join(self.internalPath, fPath),
+				hash: sums ? 'sha256' : null,
+			})
+
+			if (sums) {
+				testSum(sums, sum, fPath)
+			}
+		}
+	}
+}
+
+module.exports = Dist

package/lib/downloader.js

@@ -0,0 +1,92 @@
+'use strict'
+const crypto = require('crypto')
+const axios = require('axios')
+const MemoryStream = require('memory-stream')
+const zlib = require('zlib')
+const tar = require('tar')
+const fs = require('fs')
+const CMLog = require('./cmLog')
+
+class Downloader {
+	constructor(options) {
+		this.options = options || {}
+		this.log = new CMLog(this.options)
+	}
+	downloadToStream(url, stream, hash) {
+		const self = this
+		const shasum = hash ? crypto.createHash(hash) : null
+		return new Promise(function (resolve, reject) {
+			let length = 0
+			let done = 0
+			let lastPercent = 0
+			axios
+				.get(url, { responseType: 'stream' })
+				.then(function (response) {
+					length = parseInt(response.headers['content-length'])
+					if (typeof length !== 'number') {
+						length = 0
+					}
+
+					response.data.on('data', function (chunk) {
+						if (shasum) {
+							shasum.update(chunk)
+						}
+						if (length) {
+							done += chunk.length
+							let percent = (done / length) * 100
+							percent = Math.round(percent / 10) * 10 + 10
+							if (percent > lastPercent) {
+								self.log.verbose('DWNL', '\t' + lastPercent + '%')
+								lastPercent = percent
+							}
+						}
+					})
+
+					response.data.pipe(stream)
+				})
+				.catch(function (err) {
+					reject(err)
+				})
+
+			stream.once('error', function (err) {
+				reject(err)
+			})
+
+			stream.once('finish', function () {
+				resolve(shasum ? shasum.digest('hex') : undefined)
+			})
+		})
+	}
+	async downloadString(url) {
+		const result = new MemoryStream()
+		await this.downloadToStream(url, result)
+		return result.toString()
+	}
+	async downloadFile(url, options) {
+		if (typeof options === 'string') {
+			options.path = options
+		}
+		const result = fs.createWriteStream(options.path)
+		const sum = await this.downloadToStream(url, result, options.hash)
+		this.testSum(url, sum, options)
+		return sum
+	}
+	async downloadTgz(url, options) {
+		if (typeof options === 'string') {
+			options.cwd = options
+		}
+		const gunzip = zlib.createGunzip()
+		const extractor = tar.extract(options)
+		gunzip.pipe(extractor)
+		const sum = await this.downloadToStream(url, gunzip, options.hash)
+		this.testSum(url, sum, options)
+		return sum
+	}
+	testSum(url, sum, options) {
+		if (options.hash && sum && options.sum && options.sum !== sum) {
+			throw new Error(options.hash.toUpperCase() + " sum of download '" + url + "' mismatch!")
+		}
+	}
+}
+
+module.exports = Downloader

package/lib/environment.js

@@ -0,0 +1,97 @@
+'use strict'
+const os = require('os')
+const which = require('which')
+
+const environment = (module.exports = {
+	cmakeJsVersion: require('../package.json').version,
+	platform: os.platform(),
+	isWin: os.platform() === 'win32',
+	isLinux: os.platform() === 'linux',
+	isOSX: os.platform() === 'darwin',
+	arch: os.arch(),
+	isX86: os.arch() === 'ia32' || os.arch() === 'x86',
+	isX64: os.arch() === 'x64',
+	isArm: os.arch() === 'arm',
+	isArm64: os.arch() === 'arm64',
+	runtime: 'node',
+	runtimeVersion: process.versions.node,
+})
+
+Object.defineProperties(environment, {
+	_isNinjaAvailable: {
+		value: null,
+		writable: true,
+	},
+	isNinjaAvailable: {
+		get: function () {
+			if (this._isNinjaAvailable === null) {
+				this._isNinjaAvailable = false
+				try {
+					if (which.sync('ninja')) {
+						this._isNinjaAvailable = true
+					}
+				} catch (e) {
+					// Ignore
+				}
+			}
+			return this._isNinjaAvailable
+		},
+	},
+	_isMakeAvailable: {
+		value: null,
+		writable: true,
+	},
+	isMakeAvailable: {
+		get: function () {
+			if (this._isMakeAvailable === null) {
+				this._isMakeAvailable = false
+				try {
+					if (which.sync('make')) {
+						this._isMakeAvailable = true
+					}
+				} catch (e) {
+					// Ignore
+				}
+			}
+			return this._isMakeAvailable
+		},
+	},
+	_isGPPAvailable: {
+		value: null,
+		writable: true,
+	},
+	isGPPAvailable: {
+		get: function () {
+			if (this._isGPPAvailable === null) {
+				this._isGPPAvailable = false
+				try {
+					if (which.sync('g++')) {
+						this._isGPPAvailable = true
+					}
+				} catch (e) {
+					// Ignore
+				}
+			}
+			return this._isGPPAvailable
+		},
+	},
+	_isClangAvailable: {
+		value: null,
+		writable: true,
+	},
+	isClangAvailable: {
+		get: function () {
+			if (this._isClangAvailable === null) {
+				this._isClangAvailable = false
+				try {
+					if (which.sync('clang++')) {
+						this._isClangAvailable = true
+					}
+				} catch (e) {
+					// Ignore
+				}
+			}
+			return this._isClangAvailable
+		},
+	},
+})

package/lib/import/Find-VisualStudio.cs

@@ -0,0 +1,250 @@
+// Copyright 2017 - Refael Ackermann
+// Distributed under MIT style license
+// See accompanying file LICENSE at https://github.com/node4good/windows-autoconf
+
+// Usage:
+// powershell -ExecutionPolicy Unrestricted -Command "Add-Type -Path Find-VisualStudio.cs; [VisualStudioConfiguration.Main]::PrintJson()"
+// This script needs to be compatible with PowerShell v2 to run on Windows 2008R2 and Windows 7.
+
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+
+namespace VisualStudioConfiguration
+{
+    [Flags]
+    public enum InstanceState : uint
+    {
+        None = 0,
+        Local = 1,
+        Registered = 2,
+        NoRebootRequired = 4,
+        NoErrors = 8,
+        Complete = 4294967295,
+    }
+
+    [Guid("6380BCFF-41D3-4B2E-8B2E-BF8A6810C848")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface IEnumSetupInstances
+    {
+
+        void Next([MarshalAs(UnmanagedType.U4), In] int celt,
+            [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.Interface), Out] ISetupInstance[] rgelt,
+            [MarshalAs(UnmanagedType.U4)] out int pceltFetched);
+
+        void Skip([MarshalAs(UnmanagedType.U4), In] int celt);
+
+        void Reset();
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        IEnumSetupInstances Clone();
+    }
+
+    [Guid("42843719-DB4C-46C2-8E7C-64F1816EFD5B")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupConfiguration
+    {
+    }
+
+    [Guid("26AAB78C-4A60-49D6-AF3B-3C35BC93365D")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupConfiguration2 : ISetupConfiguration
+    {
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        IEnumSetupInstances EnumInstances();
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        ISetupInstance GetInstanceForCurrentProcess();
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        ISetupInstance GetInstanceForPath([MarshalAs(UnmanagedType.LPWStr), In] string path);
+
+        [return: MarshalAs(UnmanagedType.Interface)]
+        IEnumSetupInstances EnumAllInstances();
+    }
+
+    [Guid("B41463C3-8866-43B5-BC33-2B0676F7F42E")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupInstance
+    {
+    }
+
+    [Guid("89143C9A-05AF-49B0-B717-72E218A2185C")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupInstance2 : ISetupInstance
+    {
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetInstanceId();
+
+        [return: MarshalAs(UnmanagedType.Struct)]
+        System.Runtime.InteropServices.ComTypes.FILETIME GetInstallDate();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetInstallationName();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetInstallationPath();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetInstallationVersion();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetDisplayName([MarshalAs(UnmanagedType.U4), In] int lcid);
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetDescription([MarshalAs(UnmanagedType.U4), In] int lcid);
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string ResolvePath([MarshalAs(UnmanagedType.LPWStr), In] string pwszRelativePath);
+
+        [return: MarshalAs(UnmanagedType.U4)]
+        InstanceState GetState();
+
+        [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_UNKNOWN)]
+        ISetupPackageReference[] GetPackages();
+
+        ISetupPackageReference GetProduct();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetProductPath();
+
+        [return: MarshalAs(UnmanagedType.VariantBool)]
+        bool IsLaunchable();
+
+        [return: MarshalAs(UnmanagedType.VariantBool)]
+        bool IsComplete();
+
+        [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_UNKNOWN)]
+        ISetupPropertyStore GetProperties();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetEnginePath();
+    }
+
+    [Guid("DA8D8A16-B2B6-4487-A2F1-594CCCCD6BF5")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupPackageReference
+    {
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetId();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetVersion();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetChip();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetLanguage();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetBranch();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetType();
+
+        [return: MarshalAs(UnmanagedType.BStr)]
+        string GetUniqueId();
+
+        [return: MarshalAs(UnmanagedType.VariantBool)]
+        bool GetIsExtension();
+    }
+
+    [Guid("c601c175-a3be-44bc-91f6-4568d230fc83")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [ComImport]
+    public interface ISetupPropertyStore
+    {
+
+        [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_BSTR)]
+        string[] GetNames();
+
+        object GetValue([MarshalAs(UnmanagedType.LPWStr), In] string pwszName);
+    }
+
+    [Guid("42843719-DB4C-46C2-8E7C-64F1816EFD5B")]
+    [CoClass(typeof(SetupConfigurationClass))]
+    [ComImport]
+    public interface SetupConfiguration : ISetupConfiguration2, ISetupConfiguration
+    {
+    }
+
+    [Guid("177F0C4A-1CD3-4DE7-A32C-71DBBB9FA36D")]
+    [ClassInterface(ClassInterfaceType.None)]
+    [ComImport]
+    public class SetupConfigurationClass
+    {
+    }
+
+    public static class Main
+    {
+        public static void PrintJson()
+        {
+            ISetupConfiguration query = new SetupConfiguration();
+            ISetupConfiguration2 query2 = (ISetupConfiguration2)query;
+            IEnumSetupInstances e = query2.EnumAllInstances();
+
+            int pceltFetched;
+            ISetupInstance2[] rgelt = new ISetupInstance2[1];
+            List<string> instances = new List<string>();
+            while (true)
+            {
+                e.Next(1, rgelt, out pceltFetched);
+                if (pceltFetched <= 0)
+                {
+                    Console.WriteLine(String.Format("[{0}]", string.Join(",", instances.ToArray())));
+                    return;
+                }
+
+                try
+                {
+                    instances.Add(InstanceJson(rgelt[0]));
+                }
+                catch (COMException)
+                {
+                    // Ignore instances that can't be queried.
+                }
+            }
+        }
+
+        private static string JsonString(string s)
+        {
+            return "\"" + s.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
+        }
+
+        private static string InstanceJson(ISetupInstance2 setupInstance2)
+        {
+            // Visual Studio component directory:
+            // https://docs.microsoft.com/en-us/visualstudio/install/workload-and-component-ids
+
+            StringBuilder json = new StringBuilder();
+            json.Append("{");
+
+            string path = JsonString(setupInstance2.GetInstallationPath());
+            json.Append(String.Format("\"path\":{0},", path));
+
+            string version = JsonString(setupInstance2.GetInstallationVersion());
+            json.Append(String.Format("\"version\":{0},", version));
+
+            List<string> packages = new List<string>();
+            foreach (ISetupPackageReference package in setupInstance2.GetPackages())
+            {
+                string id = JsonString(package.GetId());
+                packages.Add(id);
+            }
+            json.Append(String.Format("\"packages\":[{0}]", string.Join(",", packages.ToArray())));
+
+            json.Append("}");
+            return json.ToString();
+        }
+    }
+}

package/lib/import/LICENSE

@@ -0,0 +1,24 @@
+(The MIT License)
+
+Copyright (c) 2012 Nathan Rajlich <nathan@tootallnate.net>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/lib/import/README

@@ -0,0 +1,6 @@
+This is a copy of some files from node-gyp, with some minor modifications.
+
+Currently based on v10.0.1
+
+node-gyp has a decent strategy for finding Visual Studio, and has a lot more developer time behind them to make a good and robust solution.
+We may as well benefit from their solution than reinvent it