spec-up-t 1.2.3 → 1.2.5

package/src/create-term-index.js

@@ -1,41 +1,145 @@
 /**
  * Steps:
- * 1. Reads the configuration from 'specs.json'.
- * 2. Extracts the directories containing the specifications and terms.
- * 3. Lists all file names in the specified terms directory.
+ * 1. Reads the configuration from 'specs.json', with fallbacks for missing or invalid files.
+ * 2. Extracts the directories containing the specifications and terms, with defaults for missing values.
+ * 3. Lists all file names in the specified terms directory if it exists.
  * 4. Joins each file name with the terms directory path.
- * 5. Creates an 'output' directory in the project root if it does not exist.
+ * 5. Creates an '.cache' directory in the project root if it does not exist.
  * 6. Writes the list of file paths to 'term-index.json' in the project root.
  *
+ * If any errors occur during the process, appropriate warnings are logged, and an empty term index
+ * will be created rather than throwing fatal errors.
+ *
  * @requires fs-extra - File system operations with extra methods.
  * @requires path - Utilities for working with file and directory paths.
  * @file src/create-term-index.js
  * @author Kor Dwarshuis
- * @version 1.0.0
+ * @version 1.1.0
  * @since 2024-09-02
  */
 
 const { shouldProcessFile } = require('./utils/file-filter');
 
 function createTermIndex() {
-    const fs = require('fs-extra');
-    const path = require('path');
-    const config = fs.readJsonSync('specs.json');
-    const specDirectories = config.specs.map(spec => spec.spec_directory);
-    const specTermDirectoryName = config.specs.map(spec => spec.spec_terms_directory);
-    const outputPathJSON = path.join('output', 'term-index.json');
-    const files = fs.readdirSync(path.join(specDirectories[0], specTermDirectoryName[0]))
-        .filter(shouldProcessFile);
-
-    const filePaths = files.map(file => specTermDirectoryName[0] + '/' + file);
-
-    if (!fs.existsSync('output')) {
-        fs.mkdirSync('output');
+    try {
+        const fs = require('fs-extra');
+        const path = require('path');
+        const configPath = 'specs.json';
+        
+        // Check if specs.json exists
+        if (!fs.existsSync(configPath)) {
+            console.warn(`Config file '${configPath}' not found. Using default configuration.`);
+            var config = { specs: [] };
+        } else {
+            // Read config with try-catch to handle parsing errors
+            try {
+                var config = fs.readJsonSync(configPath);
+            } catch (readError) {
+                console.warn(`Error reading config file: ${readError.message}. Using default configuration.`);
+                var config = { specs: [] };
+            }
+        }
+        
+        // Provide defaults for missing config
+        if (!config) {
+            console.warn('Config file is empty or invalid. Using defaults.');
+            config = { specs: [] };
+        }
+        
+        if (!config.specs) {
+            console.warn('No specs array found in config. Creating empty specs array.');
+            config.specs = [];
+        } else if (!Array.isArray(config.specs)) {
+            console.warn('Config specs is not an array. Converting to array.');
+            config.specs = [config.specs]; // Convert to array if it's an object
+        }
+        
+        // If no valid specs, create an empty term index
+        if (config.specs.length === 0) {
+            console.warn('No specs found in configuration. Creating an empty term index.');
+        }
+        
+        // Extract spec directories with fallback to current directory
+        const specDirectories = config.specs.map((spec, index) => {
+            if (!spec.spec_directory) {
+                console.warn(`Warning: spec_directory missing in specs.json entry #${index + 1}. Using current directory.`);
+                return '.';  // Default to current directory
+            }
+            return spec.spec_directory;
+        });
+        
+        // Extract term directories with fallback to default value
+        const specTermDirectoryName = config.specs.map((spec, index) => {
+            if (!spec.spec_terms_directory) {
+                console.warn(`Warning: spec_terms_directory missing in specs.json entry #${index + 1}. Using default 'terms' directory.`);
+                return 'terms'; // Default directory name for terms
+            }
+            return spec.spec_terms_directory;
+        });
+        
+        // Safety check - if we have no valid entries, warn and exit cleanly
+        if (specDirectories.length === 0 || specTermDirectoryName.length === 0) {
+            console.log('No term directories found in configuration. Creating empty term index.');
+            
+            // Create an empty term index
+            const outputPathJSON = path.join('.cache', 'term-index.json');
+            if (!fs.existsSync('.cache')) {
+                fs.mkdirSync('.cache', { recursive: true });
+            }
+            fs.writeJsonSync(outputPathJSON, [], { spaces: 2 });
+            console.log(`✅ Empty term index created at: ${outputPathJSON}`);
+            return; // Exit function early
+        }
+        
+        // Verify that the base spec directory exists
+        const baseSpecDir = specDirectories[0];
+        if (!baseSpecDir || !fs.existsSync(baseSpecDir)) {
+            console.warn(`Spec directory '${baseSpecDir}' does not exist. Creating empty term index.`);
+            
+            // Create an empty term index
+            const outputPathJSON = path.join('.cache', 'term-index.json');
+            if (!fs.existsSync('.cache')) {
+                fs.mkdirSync('.cache', { recursive: true });
+            }
+            fs.writeJsonSync(outputPathJSON, [], { spaces: 2 });
+            console.log(`✅ Empty term index created at: ${outputPathJSON}`);
+            return; // Exit function early
+        }
+        
+        // Verify that the terms directory exists
+        const termsDir = path.join(baseSpecDir, specTermDirectoryName[0]);
+        
+        let files = [];
+        if (!fs.existsSync(termsDir)) {
+            console.warn(`Terms directory '${termsDir}' does not exist. Creating an empty term index.`);
+        } else {
+            // Get list of files and filter them
+            files = fs.readdirSync(termsDir).filter(shouldProcessFile);
+        }
+        
+        if (files.length === 0) {
+            console.log('Warning: No term files found to process.');
+        }
+        
+        const filePaths = files.map(file => specTermDirectoryName[0] + '/' + file);
+        const outputPathJSON = path.join('.cache', 'term-index.json');
+        
+        // Create .cache directory if it doesn't exist
+        if (!fs.existsSync('.cache')) {
+            fs.mkdirSync('.cache', { recursive: true });
+        }
+        
+        // Write the term index file
+        try {
+            fs.writeJsonSync(outputPathJSON, filePaths, { spaces: 2 });
+            console.log(`✅ Term index created with ${files.length} terms. Output: ${outputPathJSON}`);
+        } catch (writeError) {
+            throw new Error(`Failed to write term index file: ${writeError.message}`);
+        }
+    } catch (error) {
+        console.error(`❌ Error creating term index: ${error.message}`);
+        throw error;
     }
-
-    fs.writeJsonSync(outputPathJSON, filePaths, { spaces: 2 });
-    
-    console.log(`✅ The new terms were added. All done.`);
 }
 
 module.exports = {

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 = {