virtual-code-owners 8.1.0 → 8.2.1

package/README.md

@@ -5,12 +5,12 @@ This generates your `CODEOWNERS` file (_patterns_ x _users_) from
 - a `VIRTUAL-CODEOWNERS.txt` (_patterns_ x _teams_)
 - a `virtual-teams.yml` (_teams_ x _users_)
 
-... which makes it easier to keep `CODEOWNERS` in sync on multi-team mono repos.
-When those teams are not defined on GitHub level.
+... which makes it easier to keep `CODEOWNERS` in sync on multi-team mono repos
+when you don't have (enough) 'real' GitHub or GitLab teams.
 
 ## Usage
 
-- Rename your `.github/CODEOWNERS` to `.github/VIRTUAL-CODEOWNERS.txt` and put team names in them.
+- Rename `.github/CODEOWNERS` to `.github/VIRTUAL-CODEOWNERS.txt` and put team names in them.
 - Define teams that don't (yet) exist on GitHub level in `.github/virtual-teams.yml`
 - Run this:
 
@@ -144,9 +144,6 @@ libs/baarden/       jan@example.com korneel@example.com pier@example.com tjorus@
 ### Any gotcha's?
 
 - It won't check whether the users or teams you entered exist.
-- Only relevant when you're on GitLab: Section heading support is experimental
-  and when generating labeler.yml default section owners aren't expanded to
-  section rules.
 
 ### Do I have to run this each time I edit `VIRTUAL-CODEOWNERS.txt`?
 
@@ -210,11 +207,17 @@ user/team names but doesn't verify their existence in the project.
 
 - valid user/team names start with an `@` or are an e-mail address
 - valid rules have a file pattern and at least one user/team name
+  (unless they're in a _section_ that has default owners `[sales related] @ch/sales`
+  in which case the rule inherits the default owners of that section)
 - valid sections headings comply with the syntax described over at [GitLab](https://docs.gitlab.com/ee/user/project/codeowners/reference.html#sections)
   > different from GitLab's syntax the line `[bla @group` is not interpreted
   > as a rule, but as an erroneous section heading. This behaviour might change
   > to be the same as GitLab's in future releases without a major version bump.
 
+### Does virtual-code-owners support GitLab style sections?
+
+Yes.
+
 ### I want to specify different locations for the files (e.g. because I'm using GitLab)
 
 Here you go:
@@ -228,8 +231,6 @@ npx virtual-code-owners \
 
 ### Can I just validate VIRTUAL-CODEOWNERS.txt & virtual-teams.yml without generating output?
 
-So _without_ generating any output?
-
 Sure thing. Use `--dryRun`:
 
 ```
@@ -241,16 +242,15 @@ npx virtual-code-owners --dryRun
 It keeps editors and IDE's from messing up your formatting.
 
 Various editors assume an ALL_CAPS file name with `#` characters on various lines
-to be markdown, and will auto format them as such. This makes for either very ugly
-or in worst cases invalid CODEOWNERS files. Usually such autoformatting is not
-present on text files.
+to be markdown, and will auto format them as such. Usually such autoformatting is
+not present on text files.
 
-Apparently these editors know about CODEOWNERS, though, so they don't mess with
-the formatting of _those_.
+Often these editors know about CODEOWNERS, so they won't confuse _those_ with
+markdown.
 
 ### Why does this exist at all? Why not just use GitHub teams?
 
-You should _totally_ use GitHub teams! If you can.
+If you can you should _totally_ use GitHub teams!
 
 Organizations sometimes have large mono repositories with many code owners.
 They or their bureaucracy haven't landed on actually using GitHub teams to
@@ -259,10 +259,9 @@ the organization chart (and hence the GitHub teams). Teams in those organization
 who want to have clear code ownership can either:
 
 - Wrestle the bureaucracy.  
-  Recommended! It might take a while, though - and even though there are good
-  people on many levels in bureaucracies, it might eventually not pan out
-  because #reasons.
+  Recommended! It will often require patience though, and in the mean time
+  you might want to have some clarity on code ownership.
 - Maintain a CODEOWNERS file with code assigned to large lists of individuals.  
-  An option, but laborious to maintain, even for smaller projects
+  That's a lotta work, even for smaller projects
 
 This is where `virtual-code-owners` comes in.

package/dist/codeowners/generate.js

@@ -37,7 +37,7 @@ function generateLine(pCSTLine, pTeamMap) {
 		return (
 			(pCSTLine.optional ? "^" : "") +
 			"[" +
-			pCSTLine.sectionName +
+			pCSTLine.name +
 			"]" +
 			(pCSTLine.minApprovers ? `[${pCSTLine.minApprovers}]` : "") +
 			pCSTLine.spaces +

package/dist/labeler-yml/generate.js

@@ -49,8 +49,13 @@ function transformForYamlAndMinimatch(pOriginalString) {
 	return lReturnValue;
 }
 function lineContainsTeamName(pLine, pTeamName) {
-	return pLine.users.some(
+	const lHasTeamNameInRegularUsers = pLine.users.some(
 		(pUser) =>
 			pUser.type === "virtual-team-name" && pUser.bareName === pTeamName,
 	);
+	const lHasTeamNameInInheritedUsers = (pLine.inheritedUsers ?? []).some(
+		(pUser) =>
+			pUser.type === "virtual-team-name" && pUser.bareName === pTeamName,
+	);
+	return lHasTeamNameInRegularUsers || lHasTeamNameInInheritedUsers;
 }

package/dist/team-map/read.js

@@ -1,8 +1,6 @@
-import Ajv from "ajv";
 import { readFileSync } from "node:fs";
-import { EOL } from "node:os";
 import { parse as parseYaml } from "yaml";
-import virtualTeamsSchema from "./virtual-teams.schema.js";
+import { EOL } from "node:os";
 export default function readTeamMap(pVirtualTeamsFileName) {
 	const lVirtualTeamsAsAString = readFileSync(pVirtualTeamsFileName, {
 		encoding: "utf-8",
@@ -11,22 +9,74 @@ export default function readTeamMap(pVirtualTeamsFileName) {
 	assertTeamMapValid(lTeamMap, pVirtualTeamsFileName);
 	return lTeamMap;
 }
-function assertTeamMapValid(pTeamMap, pVirtualTeamsFileName) {
-	const ajv = new Ajv({
-		allErrors: true,
-		verbose: true,
-	});
-	if (!ajv.validate(virtualTeamsSchema, pTeamMap)) {
+function assertTeamMapValid(pTeamMapCandidate, pVirtualTeamsFileName) {
+	const [lValid, lError] = validateTeamMap(pTeamMapCandidate);
+	if (!lValid) {
 		throw new Error(
-			`This is not a valid virtual-teams.yml:${EOL}${formatAjvErrors(ajv.errors, pVirtualTeamsFileName)}.\n`,
+			`'${pVirtualTeamsFileName}' is not a valid virtual-teams.yml:${EOL}  ${lError}`,
 		);
 	}
 }
-function formatAjvErrors(pAjvErrors, pVirtualTeamsFileName) {
-	return pAjvErrors
-		.map((pAjvError) => formatAjvError(pAjvError, pVirtualTeamsFileName))
-		.join(EOL);
+function validateTeamMap(pCandidateTeamMap) {
+	if (
+		typeof pCandidateTeamMap !== "object" ||
+		pCandidateTeamMap === null ||
+		Array.isArray(pCandidateTeamMap)
+	) {
+		return [false, "The team map is not an object"];
+	}
+	const lTeamNameResults = Object.keys(pCandidateTeamMap).map(validateTeamName);
+	const lErrors = lTeamNameResults.filter((result) => !result[0]);
+	if (lErrors.length > 0) {
+		return [
+			false,
+			`These team names are not valid: ${lErrors.map((error) => error[1]).join(", ")}`,
+		];
+	}
+	const lTeamResults = Object.keys(pCandidateTeamMap).map((pKey) =>
+		validateTeam(pCandidateTeamMap[pKey], pKey),
+	);
+	const lTeamErrors = lTeamResults.filter((result) => !result[0]);
+	if (lTeamErrors.length > 0) {
+		return [false, lTeamErrors.map((error) => error[1]).join(`, ${EOL}  `)];
+	}
+	return [true];
 }
-function formatAjvError(pAjvError, pVirtualTeamsFileName) {
-	return `${pVirtualTeamsFileName}: ${pAjvError.instancePath} - ${JSON.stringify(pAjvError.data)} ${pAjvError.message}`;
+function validateTeamName(pTeamNameCandidate) {
+	if (typeof pTeamNameCandidate !== "string") {
+		return [false, "not a string"];
+	}
+	if (pTeamNameCandidate === "") {
+		return [false, "'' (empty string)"];
+	}
+	if (pTeamNameCandidate.includes(" ")) {
+		return [false, `'${pTeamNameCandidate}' (contains spaces)`];
+	}
+	return [true];
+}
+function validateTeam(pCandidateTeam, pTeamName) {
+	if (!Array.isArray(pCandidateTeam)) {
+		return [false, `This team is not an array: '${pTeamName}'`];
+	}
+	const lTeamMemberResults = pCandidateTeam.map(validateTeamMember);
+	const lErrors = lTeamMemberResults.filter((result) => !result[0]);
+	if (lErrors.length > 0) {
+		return [false, lErrors.map((error) => error[1]).join(", ")];
+	}
+	return [true];
+}
+function validateTeamMember(pTeamMemberCandidate) {
+	if (typeof pTeamMemberCandidate !== "string") {
+		return [
+			false,
+			`This username is not a string: '${pTeamMemberCandidate.toString()}'`,
+		];
+	}
+	if (!/^[^@][^\s]+$/.test(pTeamMemberCandidate)) {
+		return [
+			false,
+			`This username doesn't match /^[^@][^\\s]+$/: '${pTeamMemberCandidate}'`,
+		];
+	}
+	return [true];
 }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "8.1.0";
+export const VERSION = "8.2.1";

package/dist/virtual-code-owners/parse.js

@@ -1,6 +1,14 @@
 import { EOL } from "node:os";
 import { isEmailIshUsername } from "../utensils.js";
+let STATE = {
+	currentSection: "",
+	inheritedUsers: [],
+};
 export function parse(pVirtualCodeOwnersAsString, pTeamMap = {}) {
+	STATE = {
+		currentSection: "",
+		inheritedUsers: [],
+	};
 	return pVirtualCodeOwnersAsString
 		.split(EOL)
 		.map((pUntreatedLine, pLineNo) =>
@@ -9,63 +17,74 @@ export function parse(pVirtualCodeOwnersAsString, pTeamMap = {}) {
 }
 function parseLine(pUntreatedLine, pTeamMap, pLineNo) {
 	const lTrimmedLine = pUntreatedLine.trim();
-	const lCommentSplitLine = lTrimmedLine.split(/\s*#/);
-	const lRule = lCommentSplitLine[0]?.match(
-		/^(?<filesPattern>[^\s]+)(?<spaces>\s+)(?<userNames>.*)$/,
-	);
 	if (lTrimmedLine.startsWith("#!")) {
 		return { type: "ignorable-comment", line: pLineNo, raw: pUntreatedLine };
 	}
 	if (lTrimmedLine.startsWith("#")) {
 		return { type: "comment", line: pLineNo, raw: pUntreatedLine };
 	}
+	if (lTrimmedLine === "") {
+		return { type: "empty", line: pLineNo, raw: pUntreatedLine };
+	}
 	if (lTrimmedLine.startsWith("[") || lTrimmedLine.startsWith("^[")) {
 		return parseSection(pUntreatedLine, pLineNo, pTeamMap);
 	}
-	if (!lRule?.groups) {
-		if (lTrimmedLine === "") {
-			return { type: "empty", line: pLineNo, raw: pUntreatedLine };
+	return parseRule(pUntreatedLine, pLineNo, pTeamMap);
+}
+function parseRule(pUntreatedLine, pLineNo, pTeamMap) {
+	const lTrimmedLine = pUntreatedLine.trim();
+	const lCommentSplitLine = lTrimmedLine.split(/\s*#/);
+	const lRule = lCommentSplitLine[0]?.match(
+		/^(?<filesPattern>[^\s]+)(?<spaces>\s+)?(?<userNames>.+)?$/,
+	);
+	const ruleIsValid =
+		lRule?.groups &&
+		(lRule.groups.userNames || STATE.inheritedUsers.length > 0);
+	if (ruleIsValid) {
+		let lReturnValue = {
+			type: "rule",
+			line: pLineNo,
+			raw: pUntreatedLine,
+			filesPattern: lRule.groups.filesPattern,
+			spaces: lRule.groups?.spaces ?? "",
+			users: parseUsers(lRule.groups?.userNames ?? "", pTeamMap),
+			inlineComment: lCommentSplitLine[1] ?? "",
+		};
+		if (STATE.currentSection) {
+			lReturnValue.inheritedUsers = STATE.inheritedUsers;
+			lReturnValue.currentSection = STATE.currentSection;
 		}
-		return { type: "unknown", line: pLineNo, raw: pUntreatedLine };
+		return lReturnValue;
 	}
-	return {
-		type: "rule",
-		line: pLineNo,
-		filesPattern: lRule.groups.filesPattern,
-		spaces: lRule.groups.spaces,
-		users: parseUsers(lRule.groups.userNames, pTeamMap),
-		inlineComment: lCommentSplitLine[1] ?? "",
-		raw: pUntreatedLine,
-	};
+	return { type: "unknown", line: pLineNo, raw: pUntreatedLine };
 }
 function parseSection(pUntreatedLine, pLineNo, pTeamMap) {
 	const lTrimmedLine = pUntreatedLine.trim();
 	const lCommentSplitLine = lTrimmedLine.split(/\s*#/);
 	const lSection = lCommentSplitLine[0]?.match(
-		/^(?<optionalIndicator>\^)?\[(?<sectionName>[^\]]+)\](\[(?<minApprovers>[0-9]+)\])?(?<spaces>\s+)(?<userNames>.*)$/,
+		/^(?<optionalIndicator>\^)?\[(?<name>[^\]]+)\](\[(?<minApprovers>[0-9]+)\])?(?<spaces>\s+)?(?<userNames>.+)?$/,
 	);
 	if (!lSection?.groups) {
-		return lTrimmedLine.endsWith("]")
-			? {
-					type: "section-without-users",
-					line: pLineNo,
-					raw: pUntreatedLine,
-				}
-			: {
-					type: "unknown",
-					line: pLineNo,
-					raw: pUntreatedLine,
-				};
+		return {
+			type: "unknown",
+			line: pLineNo,
+			raw: pUntreatedLine,
+		};
 	}
+	const lUsers = parseUsers(lSection.groups?.userNames ?? "", pTeamMap);
+	STATE = {
+		currentSection: lSection.groups.name,
+		inheritedUsers: lUsers,
+	};
 	const lReturnValue = {
 		type: "section-heading",
 		line: pLineNo,
-		optional: lSection.groups.optionalIndicator === "^",
-		sectionName: lSection.groups.sectionName,
-		spaces: lSection.groups.spaces,
-		users: parseUsers(lSection.groups.userNames, pTeamMap),
-		inlineComment: lTrimmedLine.split(/\s*#/)[1] ?? "",
 		raw: pUntreatedLine,
+		optional: lSection.groups.optionalIndicator === "^",
+		name: lSection.groups.name,
+		spaces: lSection.groups?.spaces ?? "",
+		users: parseUsers(lSection.groups?.userNames ?? "", pTeamMap),
+		inlineComment: lCommentSplitLine[1] ?? "",
 	};
 	if (lSection.groups.minApprovers) {
 		lReturnValue.minApprovers = parseInt(lSection.groups.minApprovers, 10);
@@ -73,7 +92,7 @@ function parseSection(pUntreatedLine, pLineNo, pTeamMap) {
 	return lReturnValue;
 }
 function parseUsers(pUserNamesString, pTeamMap) {
-	const lUserNames = pUserNamesString.split(/\s+/);
+	const lUserNames = pUserNamesString ? pUserNamesString.split(/\s+/) : [];
 	return lUserNames.map((pUserName, pIndex) => {
 		const lBareName = getBareUserName(pUserName);
 		return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "virtual-code-owners",
-	"version": "8.1.0",
+	"version": "8.2.1",
 	"description": "CODEOWNERS with teams for teams that can't use GitHub teams",
 	"type": "module",
 	"bin": {
@@ -26,8 +26,7 @@
 		"url": "https://github.com/sverweij/virtual-code-owners/issues"
 	},
 	"dependencies": {
-		"ajv": "8.13.0",
-		"yaml": "2.4.2"
+		"yaml": "2.5.0"
 	},
 	"engines": {
 		"node": "^18.11.0||>=20.0.0"

package/dist/team-map/virtual-teams.schema.js

@@ -1,16 +0,0 @@
-export default {
-	$schema: "http://json-schema.org/draft-07/schema#",
-	title: "virtual teams schema for virtual-code-owners",
-	description: "a list of teams and their team members",
-	$id: "org.js.virtual-code-owners/7.0.0",
-	type: "object",
-	additionalProperties: {
-		type: "array",
-		items: {
-			type: "string",
-			description:
-				"Username or e-mail address of a team member. (Don't prefix usernames with '@')",
-			pattern: "^[^@][^\\s]+$",
-		},
-	},
-};