fix: change logic for displaying structural and semantic parser errors

Signed-off-by: Fredrik Nordlander <fredrik.nordlander@digg.se>

Author: fredriknordlander

src/app.ts

@@ -28,6 +28,7 @@ import { SpecParseError } from './util/RapLPSpecParseError.js';
 import type { IParser } from '@stoplight/spectral-parsers';
 import { Document as SpectralDocument } from '@stoplight/spectral-core';
 import { Issue } from './util/RapLPIssueHelpers.js';
+import * as IssueHelper from './util/RapLPIssueHelpers.js';
 
 declare var AggregateError: {
   prototype: AggregateError;
@@ -97,25 +98,24 @@ async function main(): Promise<void> {
     let apiSpecDocument: SpectralDocument;
     let parseResult: any;
     try {
-      // NOTE: use filePath (camelCase)
       const prefer = detectSpecFormatPreference(apiSpecFileName,undefined,'auto');
       parseResult = await parseApiSpecInput(
           {filePath: apiSpecFileName},{
             strict: strict,
             preferJsonError: prefer
           }
       );
+    // Issue handling ----------
       if (parseResult.strictIssues && parseResult.strictIssues.length > 0) {
          console.error('Strict validation reported issues:');
           parseResult.strictIssues.forEach((iss: Issue) =>
             console.error(chalk.yellow(`- ${iss.type} at ${iss.path} : ${iss.message} ${iss.line ? `(line ${iss.line})` : ''}`)),
-            //console.error(`- ${iss.type} at ${iss.path} : ${iss.message} ${iss.line ? `(line ${iss.line})` : ''}`),
           );
           process.exitCode = 2;
           return;
       }
     } catch (err: any) {
-      // Hantering av parse-fel (behåll din logik men använd return; nu innanför main())
+      // Parse handling
       if (err instanceof SpecParseError) {
         const formattedDate = new Date().toISOString();
         const logData = {

src/util/RapLPIssueHelpers.ts

@@ -306,31 +306,70 @@ export function consolidateIssues(issues: Issue[]): Issue[] {
   return merged;
 }
 /**
- * Format single issue into editor-like lines (array of strings)
+ * Format a single Issue into editor-like lines (no duplicates).
  */
 export function formatIssueAsEditorLines(issue: Issue): string[] {
   const lines: string[] = [];
-  const typ = issue.type ? `${issue.type}` : 'Error';
-  lines.push(`${typ} error at ${issue.path || issue.location || '<unknown>'}`);
-  lines.push(issue.message || '(no message)');
-  if (issue.details && issue.details.length) {
-    for (const d of issue.details) lines.push(d);
+
+  const typ = (issue.type ?? 'Error').toString();
+  const target = issue.path || issue.location || '<unknown>';
+  const header = `${typ} error at ${target}`;
+
+  // header
+  lines.push(header);
+
+  // message
+  const msg = (issue.message ?? '').toString().trim();
+  if (msg) lines.push(msg);
+
+  // details (only ones that are not identical to message)
+  if (Array.isArray(issue.details) && issue.details.length) {
+    for (const d of issue.details) {
+      const dd = (d ?? '').toString().trim();
+      if (!dd) continue;
+      if (dd === msg) continue; // skip duplicate
+      lines.push(dd);
+    }
   }
-  if (issue.raw && Array.isArray(issue.raw)) {
+
+  // If raw is present, include only lines from raw that are not duplicates of already included lines
+  if (Array.isArray(issue.raw) && issue.raw.length) {
     for (const r of issue.raw) {
-      const t = String(r).trim();
-      if (t && !lines.includes(t)) lines.push(t);
+      const rr = (r ?? '').toString().trim();
+      if (!rr) continue;
+      // skip if it's identical to header, msg, any details or "Jump to line ..." (we will add jump ourselves)
+      if (rr === header) continue;
+      if (rr === msg) continue;
+      if ((issue.details || []).some(d => (d ?? '').toString().trim() === rr)) continue;
+      if (/^Jump to line\s+\d+/i.test(rr)) continue;
+      lines.push(rr);
     }
   }
-  if (typeof issue.line === 'number') lines.push(`Jump to line ${issue.line}`);
+
+  // Jump to line (prefer issue.line if present)
+  const l = normalizeLine(issue.line);
+  if (l) lines.push(`Jump to line ${l}`);
+
   return lines;
 }
+function normalizeLine(line?: number | null): number | undefined {
+  if (typeof line === 'number' && Number.isFinite(line) && line > 0) return line;
+  return undefined;
+}
 /**
- * Format array of issues to single editor-like string (for snippet)
+ * Format entire Issue[] as a single editor-like text block.
+ * Ensures issues are separated by a blank line.
  */
 export function formatIssuesAsEditorText(issues: Issue[]): string {
-  if (!issues || !issues.length) return '';
-  return issues.map(i => formatIssueAsEditorLines(i).join('\n')).join('\n\n');
+  if (!Array.isArray(issues) || issues.length === 0) return '';
+
+  // We'll assume caller has already consolidated & sorted issues.
+  const blocks: string[] = [];
+  for (const issue of issues) {
+    const lines = formatIssueAsEditorLines(issue);
+    if (lines.length) blocks.push(lines.join('\n'));
+  }
+  return blocks.join('\n\n');
 }
 export function parsePrettyLinesToIssues(prettyLines: string[]): Issue[] {
   const issues: Issue[] = [];

src/util/validateUtil.ts

@@ -206,7 +206,7 @@ export async function parseApiSpecInput(input: SpecInput,
       console.error('Spectral semantic validation failed (non-fatal):', e?.message ?? String(e));
       spectralDiagnostics = [];
     }
-    const finalIssues = IssueHelper.buildIssuesFromPrettyAndSpectral(prettyLines ?? [], spectralDiagnostics, false  /* addOneToLine */);
+    const finalIssues = IssueHelper.buildIssuesFromPrettyAndSpectral(prettyLines ?? [], spectralDiagnostics, true  /* addOneToLine */);
     //console.log('Merged issues length:', Array.isArray(finalIssues) ? finalIssues.length : 0);
     issues = Array.isArray(finalIssues) && finalIssues.length ? finalIssues : undefined;
     issues = finalIssues && finalIssues.length ? finalIssues : undefined;