Merge pull request #1 from gaurav-nelson/fix_id_errors

Fixed broken links, headings with titles, instances of \"

Author: gaurav-nelson

scripts/splitspec.js

@@ -37,22 +37,51 @@ function splitOpenApiSpec(inputFilePath) {
     // Function to collect definitions from a schema reference
     function collectDefinitions(tag, schema, definitions) {
         if (schema.$ref) {
-            const refName = schema.$ref.split('/').pop(); // Get the last part after the last '/'
-            // Perform a case-insensitive search for the definition
-            const matchingDefinition = Object.keys(definitions).find(defName => defName.toLowerCase() === refName.toLowerCase());
-            if (matchingDefinition && !tagMap[tag].definitions[uppercaseFirstChar(matchingDefinition)]) {
-                // Add the definition with the first character uppercased
-                tagMap[tag].definitions[uppercaseFirstChar(matchingDefinition)] = definitions[matchingDefinition];
-                // Recursively collect definitions from the referenced definition
-                collectDefinitions(tag, definitions[matchingDefinition], definitions);
-            }
-        } else if (schema.type === 'object' && schema.properties) {
-            for (const prop of Object.values(schema.properties)) {
-                collectDefinitions(tag, prop, definitions);
-            }
-        } else if (schema.type === 'array' && schema.items) {
-            collectDefinitions(tag, schema.items, definitions);
-        }
+                        const refName = schema.$ref.split('/').pop(); // Get the last part after the last '/'
+                        // Perform a case-insensitive search for the definition
+                        const matchingDefinition = Object.keys(definitions).find(defName => defName.toLowerCase() === refName.toLowerCase());
+                        if (matchingDefinition && !tagMap[tag].definitions[uppercaseFirstChar(matchingDefinition)]) {
+                            // Add the definition with the first character uppercased
+                            tagMap[tag].definitions[uppercaseFirstChar(matchingDefinition)] = definitions[matchingDefinition];
+                            // Recursively collect definitions from the referenced definition
+                            collectDefinitions(tag, definitions[matchingDefinition], definitions);
+                        }
+                    } else if (schema.type === 'object' && schema.properties) {
+                        for (const [propName, prop] of Object.entries(schema.properties)) {
+                            collectDefinitions(tag, prop, definitions);
+                            // Handle error property
+                            if (propName === 'error' && prop.$ref) {
+                                const errorRefName = prop.$ref.split('/').pop();
+                                const matchingErrorDefinition = Object.keys(definitions).find(defName => defName.toLowerCase() === errorRefName.toLowerCase());
+                                if (matchingErrorDefinition && !tagMap[tag].definitions[uppercaseFirstChar(matchingErrorDefinition)]) {
+                                    tagMap[tag].definitions[uppercaseFirstChar(matchingErrorDefinition)] = definitions[matchingErrorDefinition];
+                                    collectDefinitions(tag, definitions[matchingErrorDefinition], definitions);
+                                }
+                            }
+                        }
+                    } else if (schema.type === 'array' && schema.items) {
+                        collectDefinitions(tag, schema.items, definitions);
+                    } else if (schema.allOf) {
+                        for (const subSchema of schema.allOf) {
+                            collectDefinitions(tag, subSchema, definitions);
+                        }
+                    } else if (schema.properties) {
+                        for (const prop of Object.values(schema.properties)) {
+                            collectDefinitions(tag, prop, definitions);
+                        }
+                    } else if (schema.items) {
+                        collectDefinitions(tag, schema.items, definitions);
+                    } else if (schema.oneOf) {
+                        for (const subSchema of schema.oneOf) {
+                            collectDefinitions(tag, subSchema, definitions);
+                        }
+                    } else if (schema.anyOf) {
+                        for (const subSchema of schema.anyOf) {
+                            collectDefinitions(tag, subSchema, definitions);
+                        }
+                    } else if (schema.additionalProperties) {
+                        collectDefinitions(tag, schema.additionalProperties, definitions);
+                    }
     }
 
     // Function to collect definitions from various parts of the OpenAPI spec

scripts/updateasciidoc.js

@@ -2,13 +2,33 @@ const fs = require("fs");
 const path = require("path");
 const entities = require("entities");
 
+const specificReplacements = {
+  "<<string>>": "`string`",
+  "<<String>>": "`String`",
+  "<<Object>>": "`Object`",
+  "<<object>>": "`object`",
+  "<<integer>>": "`integer`",
+  "<<Integer>>": "`Integer`",
+};
+
 // Function to capitalize the first letter of a string
 const capitalizeFirstLetter = (string) => {
   return string.charAt(0).toUpperCase() + string.slice(1);
 };
 
+// Function to process special case
+function processSpecialCase(line) {
+  const match = line.match(/(.*?)(_.*?_)(.*)/);
+  if (match) {
+    const [_, part1, part2, part3] = match;
+    return `${part1}${part2}\n${part3}`;
+  }
+  return line;
+}
+
 // Function to update the AsciiDoc file
 const updateAsciiDoc = (filePath) => {
+  const context = path.basename(fileName, path.extname(fileName));
   // Read the file
   fs.readFile(filePath, "utf8", (err, data) => {
     if (err) {
@@ -43,11 +63,16 @@ const updateAsciiDoc = (filePath) => {
 
       // Stop processing when we encounter '[#models]'
       if (line.startsWith("[#models]")) {
-        updatedLines.push('[id="common-object-reference"]');
+        updatedLines.push('[id="common-object-reference_{context}"]');
         updatedLines.push("== Common object reference");
         updatedLines.push("");
         for (let j = i + 2; j < lines.length; j++) {
-          const decodedLine = entities.decodeHTML(lines[j]);
+          let decodedLine = entities.decodeHTML(lines[j]);
+
+          //replace \" with "
+          if (decodedLine.includes('"')) {
+            decodedLine = decodedLine.replace(/\"/g, '"');
+          }
 
           // Check if the current line is "JSON" and skip it
           if (decodedLine.trim() === "JSON") {
@@ -60,6 +85,49 @@ const updateAsciiDoc = (filePath) => {
             continue; // Skip adding the original "====" line
           }
 
+          if (decodedLine.startsWith("[#")) {
+            const updatedLine = decodedLine.replace(
+              /\[(#)(.*)\]/g,
+              (match, p1, p2) => {
+                return `[id="${p2}_{context}"]`;
+              }
+            );
+            updatedLines.push(updatedLine);
+            continue;
+          }
+
+          // New case for updated lines starting with '=' and containing '_<some-text>_'
+          if (decodedLine.startsWith("=") && /_[^_]+_/.test(decodedLine)) {
+            decodedLine = processSpecialCase(decodedLine);
+            updatedLines.push(decodedLine);
+            continue;
+          }
+
+          if (decodedLine.includes("<<") && decodedLine.includes(">>")) {
+            // Check for the specific edge case
+            if (decodedLine.includes("<<Stream_result_of_")) {
+              decodedLine = decodedLine.replace(
+                /<<Stream_result_of_(.*?)>>/g,
+                (match, p1) => {
+                  // Capitalize the first letter of p1
+                  const capitalizedP1 =
+                    p1.charAt(0).toUpperCase() + p1.slice(1);
+                  return `<<StreamResultOf${capitalizedP1}_{context}, Stream_result_of_${p1}>>`;
+                }
+              );
+            } else {
+              for (const [key, value] of Object.entries(specificReplacements)) {
+                decodedLine = decodedLine.replace(new RegExp(key, "g"), value);
+              }
+
+              decodedLine = decodedLine.replace(/<<([^>]*)>>/g, (match, p1) => {
+                return `<<${p1}_{context}, ${p1}>>`;
+              });
+            }
+
+            updatedLines.push(decodedLine);
+            continue;
+          }
           updatedLines.push(decodedLine);
         }
         break;
@@ -69,14 +137,17 @@ const updateAsciiDoc = (filePath) => {
       if (updatedLines.length === 0) {
         updatedLines.push("// Auto-generated by scripts. Do not edit.");
         updatedLines.push(":_mod-docs-content-type: ASSEMBLY");
+        updatedLines.push(`:context: ${context}`);
         updatedLines.push("");
         nextHeadingIsMainHeading = true;
       }
 
       // Capitalize the first letter of lines starting with '[.'
       if (line.startsWith("[.")) {
         const updatedLine = line.slice(2, -1).trim(); // Remove '[.' and trim spaces, then remove last character
-        updatedLines.push(`[id="${capitalizeFirstLetter(updatedLine)}"]`); // Format as [id="..."]
+        updatedLines.push(
+          `[id="${capitalizeFirstLetter(updatedLine)}_{context}"]`
+        );
         continue;
       }
 
@@ -104,6 +175,11 @@ const updateAsciiDoc = (filePath) => {
             updatedLine = newLine;
           }
 
+          // New case for updated lines starting with '=' and containing '_<some-text>_'
+          if (updatedLine.startsWith("=") && /_<[^_]+>_/.test(updatedLine)) {
+            updatedLine = processSpecialCase(updatedLine);
+          }
+
           updatedLines.push(updatedLine); // Add the updated line
 
           if (nextHeadingIsMainHeading) {
@@ -119,11 +195,51 @@ const updateAsciiDoc = (filePath) => {
         } else if (equalCount === 2) {
           // If there are exactly 2 '=', just trim the line
           let updatedLine = line.slice(2).trim();
+          // New case for updated lines starting with '=' and containing '_<some-text>_'
+          if (updatedLine.startsWith("=") && /_<[^_]+>_/.test(line)) {
+            updatedLine = processSpecialCase(updatedLine);
+          }
           updatedLines.push(updatedLine); // Add the updated line
           continue;
         }
       }
 
+      // Check if line contains both <<some_text>> and add context to it <<some_text_{context}>>
+      if (line.includes("<<") && line.includes(">>")) {
+        let updatedLine = line;
+
+        for (const [key, value] of Object.entries(specificReplacements)) {
+          updatedLine = updatedLine.replace(new RegExp(key, "g"), value);
+        }
+
+        // Check for the specific edge case
+        if (updatedLine.includes("<<Stream_result_of_")) {
+          updatedLine = updatedLine.replace(
+            /<<Stream_result_of_(.*?)>>/g,
+            (match, p1) => {
+              // Capitalize the first letter of p1
+              const capitalizedP1 = p1.charAt(0).toUpperCase() + p1.slice(1);
+              return `<<StreamResultOf${capitalizedP1}_{context}, Stream_result_of_${p1}>>`;
+            }
+          );
+        } else {
+          updatedLine = updatedLine.replace(/<<([^>]*)>>/g, (match, p1) => {
+            return `<<${p1}_{context}, ${p1}>>`;
+          });
+        }
+        updatedLines.push(updatedLine);
+        continue;
+      }
+
+      // Check if line matches [#<some-text>] and change it to [id="<some-text>_{context}"]
+      if (/$$#([^]]+)$$/.test(line)) {
+        const updatedLine = line.replace(/$$#([^]]+)$$/g, (match, p1) => {
+          return `[id="${p1}_{context}"]`;
+        });
+        updatedLines.push(updatedLine);
+        continue;
+      }
+
       // Push other lines unchanged
       updatedLines.push(line);
     }