orc-scripts 1.2.0-pre.0

package/src/scripts/mergeTranslations.js

@@ -0,0 +1,32 @@
+const path = require("path");
+const util = require("util");
+const fs = require("fs");
+
+const readdir = util.promisify(fs.readdir);
+const readFile = util.promisify(fs.readFile);
+const writeFile = util.promisify(fs.writeFile);
+
+const appTranslationsDir = path.resolve(process.cwd(), "src/translations");
+const orcSharedTranslationsDir = path.resolve(process.cwd(), "node_modules/orc-shared/src/translations");
+
+readdir(appTranslationsDir, (_, files) => {
+	files.forEach(file => {
+		if (!file.endsWith(".json")) {
+			return;
+		}
+
+		const appLocalizationFile = path.resolve(appTranslationsDir, file);
+		const correspondingOrcSharedFile = path.resolve(orcSharedTranslationsDir, file);
+
+		readFile(correspondingOrcSharedFile, "utf8", (_, orcSharedData) => {
+			const orcSharedLocalizations = JSON.parse(orcSharedData);
+
+			readFile(appLocalizationFile, "utf8", (_, appData) => {
+				const appLocalizations = JSON.parse(appData);
+				const mergedData = { ...appLocalizations, ...orcSharedLocalizations };
+				const stringifiedData = JSON.stringify(mergedData, null, 1).concat("\r\n");
+				writeFile(appLocalizationFile, stringifiedData, "utf8");
+			});
+		});
+	});
+});

package/src/scripts/prep.js

@@ -0,0 +1,28 @@
+const util = require("util");
+const path = require("path");
+const makeDir = require("make-dir");
+
+const readdir = util.promisify(require("fs").readdir);
+const copyFile = util.promisify(require("ncp").ncp);
+
+const distDir = path.resolve(process.cwd(), "dist");
+const contentDir = path.resolve(process.cwd(), "src/content");
+const staticDir = path.resolve(process.cwd(), "src/static");
+const mockDir = path.resolve(process.cwd(), "src/__mocks__");
+
+async function prep() {
+	await makeDir("dist");
+	try {
+		await Promise.all([
+			copyFile(contentDir, path.resolve(distDir, "content")),
+			copyFile(mockDir, path.resolve(distDir, "__mocks__")),
+		]);
+	} catch (_) {}
+	if (process.env.NODE_ENV === "production") process.exit(0);
+	try {
+		const files = await readdir(staticDir);
+		await Promise.all(files.map(file => copyFile(path.resolve(staticDir, file), path.resolve(distDir, file))));
+	} catch (_) {}
+}
+
+prep();

package/src/scripts/start.js

@@ -0,0 +1,45 @@
+const webpackDevServer = require("webpack-dev-server");
+const webpack = require("webpack");
+
+const HOST = process.env.HOSTNAME || "localhost";
+
+const args = process.argv.slice(2);
+const argPort = args.indexOf("--port") !== -1 ? args[args.indexOf("--port") + 1] : null;
+const PORT = argPort || process.env.PORT || 5000;
+
+const config = require("../config/webpack.config.js");
+const options = {
+	contentBase: "./dist",
+	publicPath: process.env.WEBPACK_PUBLIC_PATH || "/",
+	historyApiFallback: true,
+	hotOnly: true,
+	port: PORT,
+	host: HOST,
+};
+
+if (HOST !== "localhost") {
+	options.public = HOST;
+}
+if (HOST !== "localhost" || args.indexOf("--https") !== -1 || process.env.HTTPS) {
+	options.https = true;
+}
+
+const location = "http" + (options.https ? "s" : "") + "://" + HOST + ":" + PORT;
+
+// /mockData/ contains json files to simulate API endpoints
+options.before = (app, server) => {
+	app.get("/mockData/*", (req, res, next) => {
+		const parsedUrl = new URL(req.url, location);
+		parsedUrl.pathname = parsedUrl.pathname + ".json";
+		req.url = parsedUrl.href.replace(location, "");
+		next();
+	});
+};
+
+webpackDevServer.addDevServerEntrypoints(config, options);
+const compiler = webpack(config);
+const server = new webpackDevServer(compiler, options);
+
+server.listen(PORT, "localhost", () => {
+	console.log("dev server listening at " + location);
+});

package/src/scripts/tag.js

@@ -0,0 +1,76 @@
+const spawn = require("cross-spawn");
+const readPkgUp = require("read-pkg-up");
+const { inc, lt, eq, coerce, prerelease } = require("semver");
+
+const gitDiffResult = spawn.sync("git", ["diff", "HEAD"]);
+if (gitDiffResult.status !== 0 || gitDiffResult.stdout.toString("utf-8")) {
+	console.error("Working directory not clean, cannot tag release");
+	process.exit(-1);
+}
+
+const gitBranchResult = spawn.sync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+if (gitBranchResult.status !== 0) {
+	console.error(gitBranchResult.stderr.toString("utf-8"));
+	process.exit(-2);
+}
+const currentBranch = gitBranchResult.stdout.toString("utf-8").trim();
+
+const isMaster = currentBranch === "master";
+const isDevelopment = currentBranch === "develop";
+const isRelease = currentBranch.startsWith("releases/");
+const isLegacy = currentBranch.startsWith("legacy/");
+
+const { packageJson } = readPkgUp.sync({ normalize: false }) || {};
+const currentVersion = packageJson.version;
+let tag = "";
+if (isMaster) {
+	// TODO: Should semver increment major/minor/patch - but which is hard to discover
+	// Fail out and tag manually for now
+	console.error("Tags from master branch should be made manually with the npm version command");
+	process.exit(2);
+} else if (isRelease) {
+	const pre = prerelease(currentVersion);
+	const branchVersion = coerce(currentBranch.replace(/^.*\//, "")).version;
+	if (lt(branchVersion, currentVersion)) {
+		// Branch version must be greater or equal
+		console.error("Branch version must be higher than or equal to package version");
+		process.exit(3);
+	}
+	if (pre && eq(branchVersion, currentVersion.replace(/-.*$/, ""))) {
+		tag = inc(currentVersion, "prerelease", "pre");
+	} else {
+		// First pre-release needs specific handling
+		// see https://www.npmjs.com/package/semver#functions,
+		// the inc() function regarding the semantics of "prerelease"
+		tag = branchVersion + "-pre.0";
+	}
+} else if (isLegacy) {
+	// Only patch updates
+	tag = inc(currentVersion, "patch") + "+legacy";
+} else if (isDevelopment) {
+	const pre = prerelease(currentVersion);
+	if (pre && pre[0] !== "dev") {
+		tag = inc(currentVersion, "prepatch", "dev");
+	} else {
+		tag = inc(currentVersion, "prerelease", "dev");
+	}
+}
+
+if (!tag) {
+	console.error("This branch (" + currentBranch + ") cannot have releases tagged from it.");
+	process.exit(4);
+}
+
+const gitTagcheckResult = spawn.sync("git", ["rev-parse", tag]);
+// Failure == no tag == go ahead
+if (gitTagcheckResult.status === 0) {
+	console.error("Tag", tag, "already exists, tagging aborted");
+	process.exit(-3);
+}
+
+const tagResult = spawn.sync("npm", ["version", tag], {
+	stdio: "inherit",
+});
+if (tagResult.status !== 0) {
+	process.exit(1);
+}

package/src/scripts/test.js

@@ -0,0 +1,26 @@
+process.env.BABEL_ENV = "test";
+process.env.NODE_ENV = "test";
+
+const { hasPkgProp, parseEnv, hasFile } = require("../utils");
+
+const args = process.argv.slice(2);
+
+const isCI = require("is-ci") || args.includes("--ci");
+
+const watch =
+	!isCI &&
+	!parseEnv("SCRIPTS_PRECOMMIT", false) &&
+	!args.includes("--no-watch") &&
+	!args.includes("--coverage") &&
+	!args.includes("--updateSnapshot")
+		? ["--watch"]
+		: [];
+
+const ci = isCI ? ["--reporters=default", "--reporters=jest-junit"] : [];
+
+const config =
+	!args.includes("--config") && !hasFile("jest.config.js") && !hasPkgProp("jest")
+		? ["--config", JSON.stringify(require("../config/jest.config"))]
+		: [];
+
+require("jest").run([...config, ...watch, ...ci, ...args]);

package/src/scripts/validateTranslations.js

@@ -0,0 +1,72 @@
+const path = require("path");
+const util = require("util");
+const fs = require("fs");
+const lodash = require("lodash");
+
+const readdir = util.promisify(fs.readdir);
+const readFile = util.promisify(fs.readFile);
+
+const appTranslationsDir = path.resolve(process.cwd(), "src/translations");
+const translations = {};
+const filesToValidate = [];
+const args = process.argv.slice(2);
+
+if (args.length > 0) {
+	for (const arg of args) {
+		filesToValidate.push(path.basename(arg.replace("'", "").replace('"', "")).toLowerCase());
+	}
+}
+
+async function validate() {
+	let exitCode = 0;
+	const files = await readdir(appTranslationsDir);
+
+	for (const file of files) {
+		if (!file.endsWith(".json")) {
+			continue;
+		}
+
+		const appLocalizationFile = path.resolve(appTranslationsDir, file);
+		const appData = await readFile(appLocalizationFile, "utf8");
+
+		const appLocalizations = JSON.parse(appData);
+		translations[file.toLowerCase()] = Object.keys(appLocalizations);
+	}
+
+	for (const language of Object.keys(translations)) {
+		const languageKeys = translations[language];
+
+		if (filesToValidate.length > 0 && !filesToValidate.includes(language)) {
+			continue;
+		}
+
+		for (const otherLanguage of Object.keys(translations).filter(x => x !== language)) {
+			const otherLanguageKeys = translations[otherLanguage];
+			const additionalTranslations = lodash.without(languageKeys, ...otherLanguageKeys);
+
+			if (additionalTranslations.length > 0) {
+				exitCode = -1;
+				console.warn(
+					"Validation exception found when comparing language " +
+						language +
+						" to " +
+						otherLanguage +
+						". Language " +
+						language +
+						" has the following additional translations:",
+				);
+				console.warn(additionalTranslations);
+				console.warn("");
+			}
+		}
+	}
+
+	return exitCode;
+}
+
+validate().then(returnCode => {
+	if (returnCode) {
+		console.log("Validation failed.");
+	}
+	process.exit(returnCode);
+});

package/src/utils.js

@@ -0,0 +1,95 @@
+const fs = require("fs");
+const path = require("path");
+const arrify = require("arrify");
+const which = require("which");
+const readPkgUp = require("read-pkg-up");
+
+const hasOwn = (obj, key) => obj.hasOwnProperty(key) && obj[key] !== null && obj[key] !== undefined;
+
+const hasPath = (obj, keys) => {
+	const [key, ...tail] = keys;
+	if (hasOwn(obj, key)) {
+		if (tail && tail.length) {
+			return hasPath(obj[key], tail);
+		} else {
+			return true;
+		}
+	} else {
+		return false;
+	}
+};
+
+const has = (obj, keypath) => hasPath(obj, keypath.split(/[./]/));
+
+const { packageJson: pkg, path: pkgPath } =
+	readPkgUp.sync({
+		cwd: fs.realpathSync(process.cwd()),
+	}) || {};
+
+const appDirectory = path.dirname(pkgPath);
+
+const fromRoot = (...p) => path.join(appDirectory, ...p);
+const hasFile = (...p) => fs.existsSync(fromRoot(...p));
+
+const hasPkgProp = props => arrify(props).some(prop => has(pkg, prop));
+
+const hasPkgSubProp = pkgProp => props => hasPkgProp(arrify(props).map(p => `${pkgProp}.${p}`));
+
+const hasPeerDep = hasPkgSubProp("peerDependencies");
+const hasDep = hasPkgSubProp("dependencies");
+const hasDevDep = hasPkgSubProp("devDependencies");
+const hasAnyDep = args => [hasDep, hasDevDep, hasPeerDep].some(fn => fn(args));
+
+const ifAnyDep = (deps, t, f) => (hasAnyDep(arrify(deps)) ? t : f);
+
+function parseEnv(name, def) {
+	if (envIsSet(name)) {
+		try {
+			return JSON.parse(process.env[name] || "<fail>");
+		} catch (err) {
+			return process.env[name];
+		}
+	}
+	return def;
+}
+
+function envIsSet(name) {
+	return process.env.hasOwnProperty(name) && process.env[name] && process.env[name] !== "undefined";
+}
+
+function resolveBin(modName, { executable = modName, cwd = process.cwd() } = {}) {
+	let pathFromWhich;
+	try {
+		pathFromWhich = fs.realpathSync(which.sync(executable));
+	} catch (_error) {
+		// ignore _error
+	}
+	try {
+		const modPkgPath = require.resolve(path.join(modName, "package.json"));
+		const modPkgDir = path.dirname(modPkgPath);
+		const { bin } = require(modPkgPath);
+		const binPath = typeof bin === "string" ? bin : bin[executable];
+		const fullPathToBin = path.join(modPkgDir, binPath);
+		if (pathFromWhich.startsWith(cwd)) {
+			return pathFromWhich.replace(cwd, ".");
+		}
+		if (fullPathToBin === pathFromWhich) {
+			return executable;
+		}
+		return fullPathToBin.replace(cwd, ".");
+	} catch (error) {
+		if (pathFromWhich) {
+			return executable;
+		}
+		throw error;
+	}
+}
+
+module.exports = {
+	fromRoot,
+	hasFile,
+	hasPkgProp,
+	ifAnyDep,
+	parseEnv,
+	resolveBin,
+};

package/src/utils.test.js

@@ -0,0 +1,93 @@
+const { fromRoot, hasFile, hasPkgProp, ifAnyDep, parseEnv, resolveBin } = require("./utils");
+const path = require("path");
+
+describe("utils", () => {
+	describe("fromRoot", () => {
+		it("exists", () => expect(fromRoot, "to be a function"));
+
+		it("appends directory parts to the currently running application's root directory", () =>
+			expect(
+				fromRoot,
+				"when called with",
+				["test", "dir"],
+				"to equal",
+				process.cwd() + path.sep + "test" + path.sep + "dir",
+			));
+	});
+
+	describe("hasFile", () => {
+		it("exists", () => expect(hasFile, "to be a function"));
+
+		it("returns true when given file name that exists in CWD", () =>
+			expect(hasFile, "when called with", ["package.json"], "to equal", true));
+
+		it("returns false when given file name that does not exist in CWD", () =>
+			expect(hasFile, "when called with", ["foo.bar"], "to equal", false));
+	});
+
+	describe("hasPkgProp", () => {
+		it("exists", () => expect(hasPkgProp, "to be a function"));
+
+		it("returns true if local package.json has at least one of the given first-level keys", () =>
+			expect(hasPkgProp, "when called with", [["no", "lint-staged", "dont-have"]], "to equal", true));
+
+		it("returns false if local package.json does not have any of the given first-level keys", () =>
+			expect(hasPkgProp, "when called with", [["no-such-key", "nuh-uh", "nope-not-here"]], "to equal", false));
+	});
+
+	describe("ifAnyDep", () => {
+		it("exists", () => expect(ifAnyDep, "to be a function"));
+
+		it("returns the 'then' parameter if project has one of given dependencies", () =>
+			expect(
+				ifAnyDep,
+				"when called with",
+				[["wrong-dependency", "unexpected", "not-this-one"], "then param", "else param"],
+				"to be",
+				"then param",
+			));
+
+		it("returns the 'else' parameter if project has one of given dependencies", () =>
+			expect(
+				ifAnyDep,
+				"when called with",
+				[["wrong-dependency", "expect", "not-this-one"], "then param", "else param"],
+				"to be",
+				"else param",
+			));
+	});
+
+	describe("parseEnv", () => {
+		it("exists", () => expect(parseEnv, "to be a function"));
+
+		it("returns the environment variable given if it exists", () =>
+			expect(parseEnv, "when called with", ["BABEL_ENV", "wrong"], "to equal", "test"));
+
+		it("returns default value if it does not exist", () =>
+			expect(parseEnv, "when called with", ["NO_SUCH_variable", "wrong"], "to equal", "wrong"));
+	});
+
+	describe("resolveBin", () => {
+		it("exists", () => expect(resolveBin, "to be a function"));
+
+		it.skip("resolveBin resolves to the full path when it's not in $PATH", () => {
+			expect(
+				resolveBin("@babel/cli", { executable: "babel" }),
+				"to be",
+				require.resolve("@babel/cli/bin/babel").replace(process.cwd(), "."),
+			);
+		});
+
+		it.skip("resolveBin resolves to the .bin path when it's in $PATH but local", () => {
+			expect(
+				resolveBin("@babel/cli", { executable: "babel" }),
+				"to start with",
+				require.resolve(".bin/babel").replace(process.cwd(), "."),
+			);
+		});
+
+		it.skip("resolveBin resolves to the binary if it's in $PATH", () => {
+			expect(resolveBin("node"), "to be", "node");
+		});
+	});
+});

package/webpack.js

@@ -0,0 +1 @@
+module.exports = require("./src/config/webpack.config.js");