feat(doctor): rewrite

packages/doctorv2/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "@nativescript/doctorv2",
+	"version": "1.0.0",
+	"private": true,
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch"
+	},
+	"devDependencies": {
+		"typescript": "~4.5.5"
+	},
+	"dependencies": {
+		"ansi-colors": "^4.1.1",
+		"semver": "^7.3.5"
+	}
+}

packages/doctorv2/src/helpers/child-process.ts

@@ -0,0 +1,57 @@
+import { exec as _exec } from "child_process";
+import type { ExecOptions } from "child_process";
+import { returnFalse } from ".";
+
+export interface IExecResult {
+	stdout: string;
+	stderr: string;
+}
+
+export function exec(
+	command: string,
+	options?: ExecOptions
+): Promise<IExecResult> {
+	return new Promise((resolve, reject) => {
+		_exec(command, options, (err, stdout, stderr) => {
+			if (err) {
+				return reject(err);
+			}
+
+			resolve({
+				stdout,
+				stderr,
+			});
+		});
+	});
+}
+
+export function execSafe(
+	command: string,
+	options?: ExecOptions
+): Promise<IExecResult | false> {
+	return exec(command, options).catch(returnFalse);
+}
+
+/*
+export class ChildProcess {
+	public exec(
+		command: string,
+		options?: childProcess.ExecOptions
+	): Promise<IProcessInfo> {
+		return new Promise<IProcessInfo>((resolve, reject) => {
+			childProcess.exec(command, options, (err, stdout, stderr) => {
+				if (err) {
+					reject(err);
+				}
+
+				const result: IProcessInfo = {
+					stdout,
+					stderr,
+				};
+
+				resolve(result);
+			});
+		});
+	}
+}
+*/

packages/doctorv2/src/helpers/index.ts

@@ -0,0 +1,23 @@
+export const returnFalse: () => false = () => false;
+export const returnNull: () => null = () => null;
+
+export const safeMatch = (text: string, regex: RegExp) => {
+	const match = text.match(regex);
+
+	if (Array.isArray(match)) {
+		return match;
+	}
+
+	return [];
+};
+
+export const safeMatchAll = (text: string, regex: RegExp) => {
+	const matches = [];
+	let match = null;
+
+	while ((match = regex.exec(text)) !== null) {
+		matches.push(match);
+	}
+
+	return matches;
+};

packages/doctorv2/src/helpers/results.ts

@@ -0,0 +1,32 @@
+import { IRequirementResult, ResultType } from "..";
+
+export function result(
+	type: ResultType,
+	data: Omit<IRequirementResult, "type">
+): IRequirementResult {
+	return {
+		type,
+		...data,
+	};
+}
+
+export function ok(message: string, details?: string) {
+	return result(ResultType.OK, {
+		message,
+		details,
+	});
+}
+
+export function error(message: string, details?: string) {
+	return result(ResultType.ERROR, {
+		message,
+		details,
+	});
+}
+
+export function warn(message: string, details?: string) {
+	return result(ResultType.WARN, {
+		message,
+		details,
+	});
+}

packages/doctorv2/src/helpers/semver.ts

@@ -0,0 +1,49 @@
+import * as semver from "semver";
+
+export function isInRange(
+	version: string,
+	range: { min?: string; max?: string }
+) {
+	try {
+		const _version = semver.coerce(version);
+
+		let _range: string;
+		if (range.min && !range.max) {
+			_range = `>=${range.min}`;
+		} else if (range.max && !range.min) {
+			_range = `<=${range.max}`;
+		} else if (range.min && range.max) {
+			_range = `${range.min} - ${range.max}`;
+		} else {
+			// no min or max - return true
+			return true;
+		}
+		const _inRange = semver.satisfies(_version, _range);
+
+		// console.log({
+		// 	_version: _version.toString(),
+		// 	_range,
+		// 	_inRange,
+		// });
+
+		return _inRange;
+	} catch (err) {
+		console.log("isInRange err", err);
+		return false;
+	}
+}
+
+export function notInRange(
+	version: string,
+	range: { min?: string; max?: string }
+) {
+	return !isInRange(version, range);
+}
+
+// export function padVersion(version: string, digits = 3) {
+// 	if (version) {
+// 		const zeroesToAppend = digits - version.split(".").length;
+// 		return version + ".0".repeat(zeroesToAppend);
+// 	}
+// 	return version;
+// }

packages/doctorv2/src/index.ts

@@ -0,0 +1,87 @@
+import { printResults } from "./printers/pretty";
+import { printResults as printResultsMD } from "./printers/markdown";
+
+export type TPlatform = "android" | "ios";
+
+export type TPlatforms = {
+	[platform in TPlatform]?: boolean;
+};
+
+export const enum ResultType {
+	ERROR = "ERROR",
+	OK = "OK",
+	WARN = "WARN",
+}
+
+export interface IRequirementResult {
+	type: ResultType;
+	message: string;
+	details?: string;
+	platforms?: TPlatforms;
+}
+
+export type RequirementFunction = (
+	results: IRequirementResult[]
+) => Promise<IRequirementResult | IRequirementResult[] | void>;
+
+// export interface RequirementFunction {
+// 	platforms: TPlatforms
+// }
+
+// todo: rename or whatever, but this is augmented by all requirements that provide new info
+export interface RequirementDetails {
+	base?: true;
+}
+
+export const details: RequirementDetails = {};
+
+import { commonRequirements } from "./requirements/common";
+import { androidRequirements } from "./requirements/android";
+import { iosRequirements } from "./requirements/ios";
+
+const allRequirements = [
+	...commonRequirements,
+	...androidRequirements,
+	...iosRequirements,
+];
+
+console.time("allRequirements");
+
+const globalResults: IRequirementResult[] = [];
+const promises: ReturnType<
+	RequirementFunction
+>[] = allRequirements.map((f: RequirementFunction) => f(globalResults));
+
+Promise.allSettled(promises).then((results) => {
+	// const res: IRequirementResult[] = [];
+	for (const result of results) {
+		if (result.status === "fulfilled") {
+			if (Array.isArray(result.value)) {
+				globalResults.push(...result.value);
+			} else if (result.value) {
+				globalResults.push(result.value);
+			}
+		}
+
+		if (result.status === "rejected") {
+			console.log(result.reason);
+			globalResults.push({
+				type: ResultType.WARN,
+				message: `Failed to verify requirement: ${result.reason}`,
+			});
+		}
+	}
+
+	const filtered = globalResults.filter(Boolean);
+	console.timeEnd("allRequirements");
+
+	console.log("-".repeat(100));
+	console.log(details);
+	console.log("-".repeat(100));
+
+	printResults(filtered);
+
+	const data = { results: filtered, details };
+
+	printResultsMD(data);
+});

packages/doctorv2/src/printers/markdown.ts

@@ -0,0 +1,55 @@
+import { green } from "ansi-colors";
+import { details, IRequirementResult, RequirementDetails } from "..";
+
+export function printResults(data: {
+	results: IRequirementResult[];
+	details: RequirementDetails;
+}) {
+	const asYamlList = (list: string[]) => {
+		if (Array.isArray(list)) {
+			return "\n" + list.map((item: string) => `  - ${item}`).join("\n");
+		}
+
+		return list ?? "Not Found";
+	};
+
+	const md = [
+		`<!-- COPY START -->`,
+		"```yaml",
+		`OS: ${details.os.name} ${details.os.version}`,
+		`CPU: ${details.cpu}`,
+		`Shell: ${details.shell}`,
+		`node: ${details.node.version} (${details.node.path})`,
+		`npm: ${details.npm.version}`,
+		`nativescript: ${details.nativescript.version}`,
+		``,
+		`# android`,
+		`java: ${details.java.version}`,
+		`javac: ${details.javac.version}`,
+		`ndk: ${asYamlList(details.android.installedNDKVersions)}`,
+		`apis: ${asYamlList(details.android.installedTargets)}`,
+		`build_tools: ${asYamlList(details.android.installedBuildTools)}`,
+		`system_images: ${asYamlList(details.android.installedSystemImages)}`,
+		``,
+		`# ios`,
+		`xcode: ${details.xcode.version} (${details.xcode.buildVersion})`,
+		`cocoapods: ${details.cocoapods.version}`,
+		`python: ${details.python.version}`,
+		// `ruby: ${details.ruby.version}`,
+		`platforms: ${asYamlList(details.ios.platforms)}`,
+		"```",
+		``,
+		`### Dependencies`,
+		``,
+		"```json",
+		'"dependencies": ' + JSON.stringify({}, null, 2) + ",",
+		'"devDependencies": ' + JSON.stringify({}, null, 2),
+		"```",
+		`<!-- COPY END -->`,
+		``,
+		green.bold(`√ Results have been copied to your clipboard`),
+		``,
+	].join("\n");
+
+	console.log(md);
+}