declapract-typescript-ehmpathy 0.47.30 → 0.47.32

package/dist/practices/cicd-common/best-practice/.github/workflows/test.yml.declapract.ts

@@ -18,7 +18,12 @@ export const check: FileCheckFunction = async (contents, context) => {
     { template: context.declaredFileContents },
     context,
   );
-  if (contents === expected) throw new Error('file matches expected content');
+
+  // if contents don't match expected, best practice is violated
+  if (contents !== expected)
+    throw new Error('file does not match expected content with apikey secrets');
+
+  // return = file matches expected (best practice followed)
 };
 
 /**

package/dist/practices/cicd-package/best-practice/.github/workflows/publish.yml.declapract.ts

@@ -18,7 +18,12 @@ export const check: FileCheckFunction = async (contents, context) => {
     { template: context.declaredFileContents },
     context,
   );
-  if (contents === expected) throw new Error('file matches expected content');
+
+  // if contents don't match expected, best practice is violated
+  if (contents !== expected)
+    throw new Error('file does not match expected content with apikey secrets');
+
+  // return = file matches expected (best practice followed)
 };
 
 /**

package/dist/practices/cicd-service/best-practice/.github/workflows/deploy.yml.declapract.ts

@@ -18,7 +18,12 @@ export const check: FileCheckFunction = async (contents, context) => {
     { template: context.declaredFileContents },
     context,
   );
-  if (contents === expected) throw new Error('file matches expected content');
+
+  // if contents don't match expected, best practice is violated
+  if (contents !== expected)
+    throw new Error('file does not match expected content with apikey secrets');
+
+  // return = file matches expected (best practice followed)
 };
 
 /**

package/dist/practices/git/best-practice/.gitattributes.declapract.ts

@@ -8,53 +8,126 @@ export const check: FileCheckType = FileCheckType.CONTAINS;
 /**
  * sections of gitattributes entries to ensure exist
  */
-const SECTIONS = [
+const SECTIONS: {
+  header: { latest: string; priors: string[] };
+  entries: { latest: string[]; priors: string[] };
+}[] = [
   {
-    header:
-      '# exclude package locks from git diff; https://stackoverflow.com/a/72834452/3068233',
-    entries: ['pnpm-lock.yaml -diff', 'package-lock.json -diff'],
+    header: {
+      latest:
+        '# exclude package locks from git diff; https://stackoverflow.com/a/72834452/3068233',
+      priors: [
+        '# exclude package-lock from git diff; https://stackoverflow.com/a/72834452/3068233',
+      ],
+    },
+    entries: {
+      latest: ['pnpm-lock.yaml -diff', 'package-lock.json -diff'],
+      priors: ['pnpm-lock.json -diff'],
+    },
   },
   {
-    header:
-      '# auto-resolve lock file conflicts by taking theirs; run install after merge',
-    entries: ['pnpm-lock.yaml merge=theirs', 'package-lock.json merge=theirs'],
+    header: {
+      latest:
+        '# auto-resolve lock file conflicts by taking theirs; run install after merge',
+      priors: [],
+    },
+    entries: {
+      latest: ['pnpm-lock.yaml merge=theirs', 'package-lock.json merge=theirs'],
+      priors: ['pnpm-lock.json merge=theirs'],
+    },
   },
 ];
 
+/**
+ * all latest entries managed by this practice (for deduplication)
+ */
+const ALL_LATEST_ENTRIES = SECTIONS.flatMap((s) => s.entries.latest);
+
+/**
+ * all prior entries that should be removed
+ */
+const ALL_PRIOR_ENTRIES = SECTIONS.flatMap((s) => s.entries.priors);
+
+/**
+ * all prior headers that should be removed
+ */
+const ALL_PRIOR_HEADERS = SECTIONS.flatMap((s) => s.header.priors);
+
+/**
+ * removes legacy headers, duplicate entries, and cleans up empty lines
+ */
+const cleanContent = (content: string): string => {
+  const lines = content.split('\n');
+  const seenEntries = new Set<string>();
+  const cleanedLines: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // skip prior headers
+    if (ALL_PRIOR_HEADERS.includes(trimmed)) continue;
+
+    // skip prior entries
+    if (ALL_PRIOR_ENTRIES.includes(trimmed)) continue;
+
+    // skip duplicate latest entries (keep first occurrence)
+    if (ALL_LATEST_ENTRIES.includes(trimmed)) {
+      if (seenEntries.has(trimmed)) continue;
+      seenEntries.add(trimmed);
+    }
+
+    cleanedLines.push(line);
+  }
+
+  // collapse multiple consecutive empty lines into one
+  const collapsedLines: string[] = [];
+  let prevWasEmpty = false;
+  for (const line of cleanedLines) {
+    const isEmpty = line.trim() === '';
+    if (isEmpty && prevWasEmpty) continue;
+    collapsedLines.push(line);
+    prevWasEmpty = isEmpty;
+  }
+
+  return collapsedLines.join('\n').trim();
+};
+
 /**
  * ensures a section with header and entries exists in the content
  */
 const ensureSection = (
   content: string,
-  section: { header: string; entries: string[] },
+  section: (typeof SECTIONS)[number],
 ): string => {
   const lines = content.split('\n');
 
   // find the header line index
-  const headerIndex = lines.findIndex((line) => line.trim() === section.header);
+  const headerIndex = lines.findIndex(
+    (line) => line.trim() === section.header.latest,
+  );
 
   // if header not found, append the whole section at the end
   if (headerIndex === -1) {
     return (
       content.trimEnd() +
       '\n\n' +
-      [section.header, ...section.entries].join('\n') +
+      [section.header.latest, ...section.entries.latest].join('\n') +
       '\n'
     );
   }
 
-  // find which entries are missing
-  const missingEntries = section.entries.filter(
+  // find which entries are absent
+  const entriesAbsent = section.entries.latest.filter(
     (entry) => !content.includes(entry),
   );
 
-  // if no missing entries, nothing to fix
-  if (missingEntries.length === 0) return content;
+  // if all entries present, no fix required
+  if (entriesAbsent.length === 0) return content;
 
-  // insert missing entries right after the header
+  // insert absent entries right after the header
   const newLines = [
     ...lines.slice(0, headerIndex + 1),
-    ...missingEntries,
+    ...entriesAbsent,
     ...lines.slice(headerIndex + 1),
   ];
 
@@ -62,22 +135,25 @@ const ensureSection = (
 };
 
 /**
- * fix by ensuring all sections are present with their entries
+ * fix by cleanup of legacy content and ensure all sections are present
  */
 export const fix: FileFixFunction = (contents) => {
   // if no contents, create the file with all sections
   if (!contents) {
     const allSections = SECTIONS.map((s) =>
-      [s.header, ...s.entries].join('\n'),
+      [s.header.latest, ...s.entries.latest].join('\n'),
     ).join('\n\n');
     return { contents: allSections + '\n' };
   }
 
+  // clean up legacy headers and duplicates first
+  let result = cleanContent(contents);
+
   // ensure each section exists
-  let result = contents;
   for (const section of SECTIONS) {
     result = ensureSection(result, section);
   }
 
-  return { contents: result };
+  // normalize to exactly one final newline
+  return { contents: result.trimEnd() + '\n' };
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "declapract-typescript-ehmpathy",
   "author": "ehmpathy",
   "description": "declapract best practices declarations for typescript",
-  "version": "0.47.30",
+  "version": "0.47.32",
   "license": "MIT",
   "main": "src/index.js",
   "repository": "ehmpathy/declapract-typescript-ehmpathy",