spec-up-t 1.2.2 → 1.2.4

package/src/fix-markdown-files.js

@@ -2,99 +2,161 @@ const fs = require('fs');
 const path = require('path');
 const { shouldProcessFile } = require('./utils/file-filter');
 
-// Function to process markdown files in a directory recursively
-function fixMarkdownFiles(directory) {
-    // Helper function to process a directory
-    function processDirectory(directory) {
-        try {
-            // Read the contents of the directory synchronously
-            const items = fs.readdirSync(directory, { withFileTypes: true });
-
-            // Loop through each item in the directory
-            items.forEach(item => {
-                const itemPath = path.join(directory, item.name);
-                if (item.isDirectory()) {
-                    // If the item is a directory, call processDirectory recursively
-                    processDirectory(itemPath);
-                } else if (item.isFile() && shouldProcessFile(item.name)) {
-                    try {
-                        // Read the file synchronously
-                        let data = fs.readFileSync(itemPath, 'utf8');
-
-                        // Split the content into lines
-                        let lines = data.split('\n');
-                        let modified = false;
-
-                        // Handle specific functionality for `[[def:` lines
-                        for (let i = 0; i < lines.length; i++) {
-                            if (lines[i].startsWith('[[def:')) {
-                                // Ensure a blank line immediately follows `[[def:` lines
-                                if (i + 1 < lines.length && lines[i + 1].trim() !== '') {
-                                    lines.splice(i + 1, 0, ''); // Insert blank line
-                                    modified = true;
-                                }
-                            }
-                        }
-
-                        // Ensure there is exactly one blank line between paragraphs
-                        let newLines = [];
-                        let previousLineWasEmpty = false;
-
-                        for (let i = 0; i < lines.length; i++) {
-                            const isCurrentLineEmpty = lines[i].trim() === '';
-
-                            if (!isCurrentLineEmpty) {
-                                newLines.push(lines[i]); // Add non-empty lines
-                                previousLineWasEmpty = false;
-                            } else if (!previousLineWasEmpty) {
-                                newLines.push(''); // Add exactly one blank line
-                                previousLineWasEmpty = true;
-                            } else {
-                                modified = true; // Skip additional blank lines
-                            }
-                        }
-
-                        // Prepend `~ ` to lines that do not start with `[[def:`, `[[tref:`, are not blank, do not already start with `~ `, and are not HTML comments
-                        for (let i = 0; i < newLines.length; i++) {
-                            if (
-                                !newLines[i].startsWith('[[def:') &&
-                                !newLines[i].startsWith('[[tref:') &&
-                                newLines[i].trim() !== '' &&
-                                !newLines[i].startsWith('~ ') &&
-                                !newLines[i].trim().startsWith('<!--')
-                            ) {
-                                newLines[i] = `~ ${newLines[i]}`;
-                                modified = true;
-                            }
-                        }
-
-                        // Ensure there is exactly one blank line at the end of the file
-                        if (newLines[newLines.length - 1] !== '') {
-                            newLines.push('');
-                            modified = true;
-                        }
-
-                        // Join the lines back into a single string
-                        if (modified) {
-                            data = newLines.join('\n');
-                        }
-
-                        // Write the modified content back to the file synchronously if there were any changes
-                        if (modified) {
-                            fs.writeFileSync(itemPath, data, 'utf8');
-                        }
-                    } catch (err) {
-                        console.error(`❌ Error while trying to fix the markdown in file ${item.name}: ${err}`);
-                    }
-                }
-            });
-        } catch (err) {
-            console.error(`❌ Error reading directory: ${err}`);
+/**
+ * Handles specific functionality for `[[def:` lines
+ * @param {string[]} lines - Array of file lines
+ * @returns {object} - Object containing modified lines and modification status
+ */
+function processDefLines(lines) {
+    const result = [...lines];
+    let modified = false;
+
+    for (let i = 0; i < result.length; i++) {
+        if (result[i].startsWith('[[def:')) {
+            // Ensure a blank line immediately follows `[[def:` lines
+            if (i + 1 < result.length && result[i + 1].trim() !== '') {
+                result.splice(i + 1, 0, ''); // Insert blank line
+                modified = true;
+            }
+        }
+    }
+
+    return { lines: result, modified };
+}
+
+/**
+ * Ensures there is exactly one blank line between paragraphs
+ * @param {string[]} lines - Array of file lines
+ * @returns {object} - Object containing modified lines and modification status
+ */
+function normalizeParagraphSpacing(lines) {
+    let newLines = [];
+    let previousLineWasEmpty = false;
+    let modified = false;
+
+    for (const line of lines) {
+        const isCurrentLineEmpty = line.trim() === '';
+
+        if (!isCurrentLineEmpty) {
+            newLines.push(line); // Add non-empty lines
+            previousLineWasEmpty = false;
+        } else if (!previousLineWasEmpty) {
+            newLines.push(''); // Add exactly one blank line
+            previousLineWasEmpty = true;
+        } else {
+            modified = true; // Skip additional blank lines
         }
     }
 
-    // Start processing from the given directory
-    processDirectory(directory);
+    return { lines: newLines, modified };
+}
+
+/**
+ * Prepends `~ ` to appropriate lines
+ * @param {string[]} lines - Array of file lines
+ * @returns {object} - Object containing modified lines and modification status
+ */
+function prependTildeToLines(lines) {
+    const result = [...lines];
+    let modified = false;
+
+    for (let i = 0; i < result.length; i++) {
+        if (
+            !result[i].startsWith('[[def:') &&
+            !result[i].startsWith('[[tref:') &&
+            result[i].trim() !== '' &&
+            !result[i].startsWith('~ ') &&
+            !result[i].trim().startsWith('<!--')
+        ) {
+            result[i] = `~ ${result[i]}`;
+            modified = true;
+        }
+    }
+
+    return { lines: result, modified };
+}
+
+/**
+ * Ensures there is exactly one blank line at the end of the file
+ * @param {string[]} lines - Array of file lines
+ * @returns {object} - Object containing modified lines and modification status
+ */
+function ensureTrailingNewline(lines) {
+    const result = [...lines];
+    let modified = false;
+
+    if (result[result.length - 1] !== '') {
+        result.push('');
+        modified = true;
+    }
+
+    return { lines: result, modified };
+}
+
+/**
+ * Processes a single markdown file and applies formatting rules
+ * @param {string} filePath - Path to the markdown file
+ * @returns {void}
+ */
+function processMarkdownFile(filePath, fileName) {
+    try {
+        // Read the file synchronously
+        let data = fs.readFileSync(filePath, 'utf8');
+
+        // Split the content into lines
+        let lines = data.split('\n');
+        let modified = false;
+
+        // Apply each processing function in sequence
+        const defResult = processDefLines(lines);
+        lines = defResult.lines;
+        modified = modified || defResult.modified;
+
+        const spacingResult = normalizeParagraphSpacing(lines);
+        lines = spacingResult.lines;
+        modified = modified || spacingResult.modified;
+
+        const tildeResult = prependTildeToLines(lines);
+        lines = tildeResult.lines;
+        modified = modified || tildeResult.modified;
+
+        const newlineResult = ensureTrailingNewline(lines);
+        lines = newlineResult.lines;
+        modified = modified || newlineResult.modified;
+
+        // Write the modified content back to the file synchronously if there were any changes
+        if (modified) {
+            const newData = lines.join('\n');
+            fs.writeFileSync(filePath, newData, 'utf8');
+        }
+    } catch (err) {
+        console.error(`❌ Error while trying to fix the markdown in file ${fileName}: ${err}`);
+    }
+}
+
+/**
+ * Processes markdown files in a directory recursively
+ * @param {string} directory - The directory to process
+ * @returns {void}
+ */
+function fixMarkdownFiles(directory) {
+    try {
+        // Read the contents of the directory synchronously
+        const items = fs.readdirSync(directory, { withFileTypes: true });
+
+        // Loop through each item in the directory
+        items.forEach(item => {
+            const itemPath = path.join(directory, item.name);
+            if (item.isDirectory()) {
+                // If the item is a directory, call fixMarkdownFiles recursively
+                fixMarkdownFiles(itemPath);
+            } else if (item.isFile() && shouldProcessFile(item.name)) {
+                processMarkdownFile(itemPath, item.name);
+            }
+        });
+    } catch (err) {
+        console.error(`❌ Error reading directory: ${err}`);
+    }
 }
 
 module.exports = {

package/src/health-check/external-specs-checker.js

@@ -17,6 +17,7 @@ function isValidGitHubPagesUrl(urlStr) {
       parsedUrl.hostname.endsWith('.github.io')
     );
   } catch (error) {
+    console.error(`❌ Error validating GitHub Pages URL: ${error.message}`);
     return false;
   }
 }
@@ -34,6 +35,7 @@ function isValidGitHubRepoUrl(urlStr) {
       parsedUrl.pathname.split('/').filter(Boolean).length >= 2
     );
   } catch (error) {
+    console.error(`❌ Error validating GitHub repo URL: ${error.message}`);
     return false;
   }
 }
@@ -69,131 +71,208 @@ function urlExists(urlStr) {
 
       req.end();
     } catch (error) {
+      console.error(`❌ URL Format Error: Invalid URL format for ${urlStr} - ${error.message}`);
       resolve(false);
     }
   });
 }
 
 /**
- * Check external specs in a specs.json file
+ * Check if specs.json file exists and read it
  * @param {string} projectRoot - Root directory of the project
- * @returns {Promise<Array>} - Array of check results
+ * @returns {Object} - Object containing results and specs data if found
  */
-async function checkExternalSpecs(projectRoot) {
-  const results = [];
+function checkAndReadSpecsFile(projectRoot) {
+  const specsPath = path.join(projectRoot, 'specs.json');
   
-  try {
-    const specsPath = path.join(projectRoot, 'specs.json');
-    
-    // Check if specs.json exists
-    if (!fs.existsSync(specsPath)) {
-      return [{
+  if (!fs.existsSync(specsPath)) {
+    return {
+      results: [{
         name: 'Find specs.json file',
         success: false,
         details: 'specs.json file not found in project root'
-      }];
-    }
-    
-    results.push({
-      name: 'Find specs.json file',
-      success: true,
-      details: 'specs.json file found'
-    });
-    
-    // Read specs.json
+      }],
+      specs: null
+    };
+  }
+  
+  try {
     const specsContent = fs.readFileSync(specsPath, 'utf8');
     const specs = JSON.parse(specsContent);
     
-    // Check if external_specs key exists
-    if (!specs.specs || !Array.isArray(specs.specs) || !specs.specs.some(spec => spec.external_specs)) {
-      results.push({
+    return {
+      results: [{
+        name: 'Find specs.json file',
+        success: true,
+        details: 'specs.json file found'
+      }],
+      specs
+    };
+  } catch (error) {
+    return {
+      results: [{
+        name: 'Parse specs.json file',
+        success: false,
+        details: `❌ Error parsing specs.json: ${error.message}`
+      }],
+      specs: null
+    };
+  }
+}
+
+/**
+ * Extract external specs from specs data
+ * @param {Object} specs - Specs data
+ * @returns {Object} - Object containing results and external specs if found
+ */
+function extractExternalSpecs(specs) {
+  if (!specs.specs || !Array.isArray(specs.specs) || !specs.specs.some(spec => spec.external_specs)) {
+    return {
+      results: [{
         name: 'Find external_specs in specs.json',
         success: false,
         details: 'external_specs key not found in specs.json'
-      });
-      return results;
+      }],
+      externalSpecs: []
+    };
+  }
+  
+  const externalSpecs = [];
+  
+  specs.specs.forEach(spec => {
+    if (spec.external_specs && Array.isArray(spec.external_specs)) {
+      externalSpecs.push(...spec.external_specs);
     }
-    
-    results.push({
+  });
+  
+  return {
+    results: [{
       name: 'Find external_specs in specs.json',
       success: true,
       details: 'external_specs key found in specs.json'
+    }],
+    externalSpecs
+  };
+}
+
+/**
+ * Check GitHub Pages URL for an external spec
+ * @param {Object} spec - External spec object
+ * @returns {Promise<Array>} - Array of check results
+ */
+async function checkGitHubPagesUrl(spec) {
+  const results = [];
+  
+  if (!spec.gh_page) {
+    results.push({
+      name: `Check "${spec.external_spec}" gh_page URL`,
+      success: false,
+      details: 'gh_page URL is missing'
     });
-    
-    // Find all external specs
-    const externalSpecs = [];
-    specs.specs.forEach(spec => {
-      if (spec.external_specs && Array.isArray(spec.external_specs)) {
-        externalSpecs.push(...spec.external_specs);
-      }
+    return results;
+  }
+  
+  const isValidGhPage = isValidGitHubPagesUrl(spec.gh_page);
+  results.push({
+    name: `Check "${spec.external_spec}" gh_page URL structure`,
+    success: isValidGhPage,
+    details: isValidGhPage 
+      ? 'Valid GitHub Pages URL structure' 
+      : `Invalid GitHub Pages URL structure: ${spec.gh_page}`
+  });
+  
+  if (isValidGhPage) {
+    const ghPageExists = await urlExists(spec.gh_page);
+    results.push({
+      name: `Check "${spec.external_spec}" gh_page URL exists`,
+      success: ghPageExists,
+      details: ghPageExists 
+        ? 'GitHub Pages URL is accessible' 
+        : `GitHub Pages URL is not accessible: ${spec.gh_page}`
+    });
+  }
+  
+  return results;
+}
+
+/**
+ * Check repository URL for an external spec
+ * @param {Object} spec - External spec object
+ * @returns {Promise<Array>} - Array of check results
+ */
+async function checkRepositoryUrl(spec) {
+  const results = [];
+  
+  if (!spec.url) {
+    results.push({
+      name: `Check "${spec.external_spec}" repo URL`,
+      success: false,
+      details: 'Repository URL is missing'
     });
+    return results;
+  }
+  
+  const isValidRepoUrl = isValidGitHubRepoUrl(spec.url);
+  results.push({
+    name: `Check "${spec.external_spec}" repo URL structure`,
+    success: isValidRepoUrl,
+    details: isValidRepoUrl 
+      ? 'Valid GitHub repository URL structure' 
+      : `Invalid GitHub repository URL structure: ${spec.url}`
+  });
+  
+  if (isValidRepoUrl) {
+    const repoUrlExists = await urlExists(spec.url);
+    results.push({
+      name: `Check "${spec.external_spec}" repo URL exists`,
+      success: repoUrlExists,
+      details: repoUrlExists 
+        ? 'GitHub repository URL is accessible' 
+        : `GitHub repository URL is not accessible: ${spec.url}`
+    });
+  }
+  
+  return results;
+}
+
+/**
+ * Check external specs in a specs.json file
+ * @param {string} projectRoot - Root directory of the project
+ * @returns {Promise<Array>} - Array of check results
+ */
+async function checkExternalSpecs(projectRoot) {
+  try {
+    // Check for and read specs.json file
+    const { results, specs } = checkAndReadSpecsFile(projectRoot);
+    
+    if (!specs) {
+      return results;
+    }
+    
+    // Extract external specs from specs data
+    const { results: extractResults, externalSpecs } = extractExternalSpecs(specs);
+    
+    // Combine results
+    const allResults = [...results, ...extractResults];
+    
+    if (externalSpecs.length === 0) {
+      return allResults;
+    }
     
     // Check each external spec
     for (const spec of externalSpecs) {
-      // Check gh_page structure
-      if (spec.gh_page) {
-        const isValidGhPage = isValidGitHubPagesUrl(spec.gh_page);
-        results.push({
-          name: `Check "${spec.external_spec}" gh_page URL structure`,
-          success: isValidGhPage,
-          details: isValidGhPage 
-            ? 'Valid GitHub Pages URL structure' 
-            : `Invalid GitHub Pages URL structure: ${spec.gh_page}`
-        });
-        
-        // Check if gh_page exists
-        if (isValidGhPage) {
-          const ghPageExists = await urlExists(spec.gh_page);
-          results.push({
-            name: `Check "${spec.external_spec}" gh_page URL exists`,
-            success: ghPageExists,
-            details: ghPageExists 
-              ? 'GitHub Pages URL is accessible' 
-              : `GitHub Pages URL is not accessible: ${spec.gh_page}`
-          });
-        }
-      } else {
-        results.push({
-          name: `Check "${spec.external_spec}" gh_page URL`,
-          success: false,
-          details: 'gh_page URL is missing'
-        });
-      }
+      // Check GitHub Pages URL
+      const ghPageResults = await checkGitHubPagesUrl(spec);
+      allResults.push(...ghPageResults);
       
-      // Check url structure
-      if (spec.url) {
-        const isValidRepoUrl = isValidGitHubRepoUrl(spec.url);
-        results.push({
-          name: `Check "${spec.external_spec}" repo URL structure`,
-          success: isValidRepoUrl,
-          details: isValidRepoUrl 
-            ? 'Valid GitHub repository URL structure' 
-            : `Invalid GitHub repository URL structure: ${spec.url}`
-        });
-        
-        // Check if url exists
-        if (isValidRepoUrl) {
-          const repoUrlExists = await urlExists(spec.url);
-          results.push({
-            name: `Check "${spec.external_spec}" repo URL exists`,
-            success: repoUrlExists,
-            details: repoUrlExists 
-              ? 'GitHub repository URL is accessible' 
-              : `GitHub repository URL is not accessible: ${spec.url}`
-          });
-        }
-      } else {
-        results.push({
-          name: `Check "${spec.external_spec}" repo URL`,
-          success: false,
-          details: 'Repository URL is missing'
-        });
-      }
+      // Check repository URL
+      const repoUrlResults = await checkRepositoryUrl(spec);
+      allResults.push(...repoUrlResults);
     }
     
-    return results;
+    return allResults;
   } catch (error) {
-    console.error('Error checking external specs:', error);
+    console.error('❌ Error checking external specs:', error);
     return [{
       name: 'External specs check',
       success: false,