virtual-code-owners 8.0.5 → 8.2.0

package/README.md

@@ -143,7 +143,10 @@ 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.
+- 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`?
 
@@ -207,6 +210,16 @@ 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)
 
@@ -221,8 +234,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`:
 
 ```
@@ -234,16 +245,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
@@ -252,10 +262,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

@@ -26,20 +26,32 @@ export default function generateCodeOwners(
 }
 function generateLine(pCSTLine, pTeamMap) {
 	if (pCSTLine.type === "rule") {
-		const lUserNames = uniq(
-			pCSTLine.users.flatMap((pUser) => expandTeamToUserNames(pUser, pTeamMap)),
-		)
-			.sort(compareUserNames)
-			.join(" ");
 		return (
 			pCSTLine.filesPattern +
 			pCSTLine.spaces +
-			lUserNames +
+			expandTeamsToUsersString(pCSTLine.users, pTeamMap) +
+			(pCSTLine.inlineComment ? ` #${pCSTLine.inlineComment}` : "")
+		);
+	}
+	if (pCSTLine.type === "section-heading") {
+		return (
+			(pCSTLine.optional ? "^" : "") +
+			"[" +
+			pCSTLine.name +
+			"]" +
+			(pCSTLine.minApprovers ? `[${pCSTLine.minApprovers}]` : "") +
+			pCSTLine.spaces +
+			expandTeamsToUsersString(pCSTLine.users, pTeamMap) +
 			(pCSTLine.inlineComment ? ` #${pCSTLine.inlineComment}` : "")
 		);
 	}
 	return pCSTLine.raw;
 }
+function expandTeamsToUsersString(pUsers, pTeamMap) {
+	return uniq(pUsers.flatMap((pUser) => expandTeamToUserNames(pUser, pTeamMap)))
+		.sort(compareUserNames)
+		.join(" ");
+}
 function expandTeamToUserNames(pUser, pTeamMap) {
 	if (pUser.type === "virtual-team-name") {
 		return stringifyTeamMembers(pTeamMap, pUser.bareName);

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.0.5";
+export const VERSION = "8.2.0";

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,34 +17,82 @@ 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 (!lRule?.groups) {
-		if (lTrimmedLine === "") {
-			return { type: "empty", line: pLineNo, raw: pUntreatedLine };
+	if (lTrimmedLine === "") {
+		return { type: "empty", line: pLineNo, raw: pUntreatedLine };
+	}
+	if (lTrimmedLine.startsWith("[") || lTrimmedLine.startsWith("^[")) {
+		return parseSection(pUntreatedLine, pLineNo, pTeamMap);
+	}
+	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",
+	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>\^)?\[(?<name>[^\]]+)\](\[(?<minApprovers>[0-9]+)\])?(?<spaces>\s+)?(?<userNames>.+)?$/,
+	);
+	if (!lSection?.groups) {
+		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,
-		filesPattern: lRule.groups.filesPattern,
-		spaces: lRule.groups.spaces,
-		users: parseUsers(lRule.groups.userNames, pTeamMap),
-		inlineComment: lCommentSplitLine[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);
+	}
+	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/dist/virtual-code-owners/read.js

@@ -25,7 +25,7 @@ function reportAnomalies(pFileName, pAnomalies) {
 	return pAnomalies
 		.map((pAnomaly) => {
 			if (pAnomaly.type === "invalid-line") {
-				return `${pFileName}:${pAnomaly.line}:1 invalid line - neither a rule, comment nor empty: "${pAnomaly.raw}"`;
+				return `${pFileName}:${pAnomaly.line}:1 invalid line - neither a rule, section heading, comment nor empty: "${pAnomaly.raw}"`;
 			} else {
 				return (
 					`${pFileName}:${pAnomaly.line}:1 invalid user or team name "${pAnomaly.raw}" (#${pAnomaly.userNumberWithinLine} on this line). ` +

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "virtual-code-owners",
-	"version": "8.0.5",
+	"version": "8.2.0",
 	"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.4.3"
 	},
 	"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]+$",
-		},
-	},
-};