hdoc-tools 0.23.0 → 0.24.1

package/hdoc-module.js

@@ -725,4 +725,20 @@
 		}
 		return response;
 	};
+
+	exports.find_string_in_string = (fileContent, searchString) => {
+		const lines = fileContent.split('\n');
+	  
+		for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+		  const columnNumber = lines[lineNumber].indexOf(searchString);
+	  
+		  if (columnNumber !== -1) {
+			// Return 1-based line and column numbers
+			return { line: lineNumber + 1, column: columnNumber + 1 };
+		  }
+		}
+	  
+		// If not found, return null
+		return null;
+	  }
 })();

package/hdoc-validate.js

@@ -1,3 +1,5 @@
+const e = require("express");
+
 (() => {
 	const axios = require("axios");
 	const cheerio = require("cheerio");
@@ -31,14 +33,14 @@
 
 	const excludeLink = async (url) => {
 		if (exclude_links[url]) return true;
-
 		for (let key in exclude_links) {
-			if (key.endsWith("*")) {
-				key = key.substring(0, key.length - 1);
-				if (url.startsWith(key)) return true;
+			if (Object.hasOwn(exclude_links, key)) {
+				if (key.endsWith("*")) {
+					key = key.substring(0, key.length - 1);
+					if (url.startsWith(key)) return true;
+				}
 			}
 		}
-
 		return false;
 	};
 
@@ -50,17 +52,25 @@
 			`.${sourceFile.extension}`,
 			"",
 		);
+
+		const markdown_path = getMDPathFromHtmlPath(sourceFile);
 		const translate_output = translator.translate(text, spellcheck_options);
 		if (Object.keys(translate_output).length) {
 			for (const key in translate_output) {
 				if (Object.hasOwn(translate_output, key)) {
-					const error_message = `Line ${key} - British spelling:`;
+					// key is the line of text 
+					let error_message = `British spelling:`;
 					for (let i = 0; i < translate_output[key].length; i++) {
 						for (const spelling in translate_output[key][i]) {
 							if (
 								Object.hasOwn(translate_output[key][i], spelling) &&
 								typeof translate_output[key][i][spelling].details === "string"
 							) {
+								const link_location = hdoc.find_string_in_string(text.split('\n')[key - 1], spelling);
+								if (link_location !== null)
+									error_message = `${markdown_path}:${key}:${link_location.column} - ${error_message}`;
+								else
+									error_message = `${markdown_path}:${key} - ${error_message}`;
 								if (!excludes[source_path]) {
 									errors[sourceFile.relativePath].push(
 										`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`,
@@ -325,7 +335,7 @@
 	};
 
 	const checkRedirects = async (source_path) => {
-		const errors = [];
+		const redir_errors = [];
 		for (const key in redirects) {
 			if (Object.hasOwn(redirects, key)) {
 				if (
@@ -333,7 +343,7 @@
 					redirects[key].code !== 308 &&
 					redirects[key].code !== 410
 				)
-					errors.push(`Invalid redirect code: ${redirects[key].code}`);
+					redir_errors.push(`Invalid redirect code: ${redirects[key].code}`);
 
 				if (redirects[key].location) {
 					const redir_locations = [
@@ -352,13 +362,13 @@
 						}
 					}
 					if (!redir_location_ok)
-						errors.push(
+						redir_errors.push(
 							`Redirect location does not exist: ${redirects[key].location}`,
 						);
 				}
 			}
 		}
-		return errors;
+		return redir_errors;
 	};
 
 	const checkRedirect = (source_path, nav_path) => {
@@ -422,7 +432,19 @@
 		}
 	};
 
+	const getMDPathFromHtmlPath = (htmlFile) => {
+		const markdownPath = htmlFile.relativePath.replace(`.${htmlFile.extension}`, '.md');
+		if (!fs.existsSync(markdownPath)) {
+			// No matching markdown
+			return htmlFile.relativePath;
+		}
+		return markdownPath;
+	}
+
 	const checkLinks = async (source_path, htmlFile, links, hdocbook_config) => {
+		const markdown_path = getMDPathFromHtmlPath(htmlFile);
+		const markdown_content = fs.readFileSync(markdown_path, 'utf8');
+
 		for (let i = 0; i < links.length; i++) {
 			// Validate that link is a valid URL first
 			const valid_url = hdoc.valid_url(links[i]);
@@ -443,95 +465,93 @@
 					//Flat Anchor - validate we have a same-file hit
 					isHashAnchor(htmlFile, links[i]);
 				} else {
-					errors[htmlFile.relativePath].push(
-						`Root relative links should start with a forward-slash: ${links[i]}`,
-					);
+					const error_message = processErrorMessage(`Root relative links should start with a forward-slash: ${links[i]}`, markdown_path, markdown_content, links[i]);
+					errors[htmlFile.relativePath].push(error_message);
 				}
 			} else {
 				messages[htmlFile.relativePath].push(
 					`Link is a properly formatted external URL: ${links[i]}`,
 				);
-
+				
 				// Skip if it's the auto-generated edit url, as these could be part of a private repo which would return a 404
 				if (
 					hdocbook_config.publicSource !== undefined &&
 					links[i] ===
-						hdoc
-							.get_github_api_path(
-								hdocbook_config.publicSource,
-								htmlFile.relativePath,
-							)
-							.edit_path.replace(path.extname(htmlFile.relativePath), ".md")
+					hdoc
+					.get_github_api_path(
+						hdocbook_config.publicSource,
+						htmlFile.relativePath,
+					)
+					.edit_path.replace(path.extname(htmlFile.relativePath), ".md")
 				) {
 					continue;
 				}
-
+				
 				if (valid_url.protocol === "mailto:") {
 					continue;
 				}
-
+				
 				// Skip if the link is excluded in the project config
-				if (excludeLink(links[i])) {
+				const skip_link = await excludeLink(links[i]);
+				if (skip_link) {
 					messages[htmlFile.relativePath].push(
 						`Skipping link validation for: ${links[i]}`,
 					);
 					continue;
 				}
 
+
 				if (
 					links[i].toLowerCase().includes("docs.hornbill.com") ||
 					links[i].toLowerCase().includes("docs-internal.hornbill.com")
 				) {
-					errors[htmlFile.relativePath].push(
-						`Links to Hornbill Docs should rooted and not fully-qualified: ${links[i]}`,
-					);
+					const error_message = processErrorMessage(`Hornbill Docs links should not be fully-qualified: ${links[i]}`, markdown_path, markdown_content, links[i]);
+					errors[htmlFile.relativePath].push( error_message );
 					continue;
 				}
 
 				try {
-					await axios.get(links[i], {
-						httpsAgent: agent,
-					});
+					await axios.get(links[i]);
 					messages[htmlFile.relativePath].push(
 						`Link is a valid external URL: ${links[i]}`,
 					);
 				} catch (e) {
-					// Handle errors
-					errors[htmlFile.relativePath].push(
-						`Link is not responding: ${links[i]} - [${e.message}]`,
-					);
+					const error_message = processErrorMessage(`External link is not responding: ${links[i]}`, markdown_path, markdown_content, links[i]);
+					errors[htmlFile.relativePath].push(error_message);
 				}
 			}
 		}
 	};
 
 	const checkImages = async (source_path, htmlFile, links) => {
+		const markdown_path = getMDPathFromHtmlPath(htmlFile);
+		const markdown_content = fs.readFileSync(markdown_path, 'utf8');
 		for (let i = 0; i < links.length; i++) {
 			// Validate that image is a valid URL first
 			if (!hdoc.valid_url(links[i])) {
 				// Could be a relative path, check image exists
-				doesFileExist(source_path, htmlFile, links[i]);
+				doesFileExist(source_path, htmlFile, links[i], markdown_path, markdown_content);
 			} else {
 				messages[htmlFile.relativePath].push(
 					`Image link is a properly formatted external URL: ${links[i]}`,
 				);
 				// Do a Get to the URL to see if it exists
 				try {
-					const res = await axios.get(links[i]);
+					await axios.get(links[i]);
 					messages[htmlFile.relativePath].push(
 						`Image link is a valid external URL: ${links[i]}`,
 					);
 				} catch (e) {
 					// Handle errors
-					errors[htmlFile.relativePath].push(
-						`Unexpected Error from external image link: ${links[i]} - ${e.message}`,
-					);
+					const error_message = processErrorMessage(`External image link error: ${links[i]} - ${e.message}`, markdown_path, markdown_content, links[i]);
+					errors[htmlFile.relativePath].push(error_message);
 				}
 			}
 		}
 	};
 
 	const checkTags = async (htmlFile) => {
+		const markdown_path = getMDPathFromHtmlPath(htmlFile);
 		// Check if file  is excluded from tag check
 		const file_no_ext = htmlFile.relativePath.replace(
 			path.extname(htmlFile.relativePath),
@@ -554,7 +574,7 @@
 				error_msg += h1_tags[i].text();
 				if (i < h1_tags.length - 1) error_msg += "; ";
 			}
-			errors[htmlFile.relativePath].push(error_msg);
+			errors[htmlFile.relativePath].push(`${markdown_path} - ${error_msg}`);
 		}
 	};
 
@@ -580,10 +600,14 @@
 	};
 
 	const isRelativePath = (source_path, html_path, relative_path) => {
+		const markdown_path = getMDPathFromHtmlPath(html_path);
+		const markdown_content = fs.readFileSync(markdown_path, 'utf8');
+
 		const rel_path_ext = path.extname(relative_path);
 		const response = {
 			is_rel_path: false,
 			has_md_extension: rel_path_ext === ".md",
+			has_html_extension: rel_path_ext === ".htm" || rel_path_ext === ".html",
 		};
 		const supported_relpaths = [
 			`${path.sep}index.htm`,
@@ -627,10 +651,9 @@
 				}
 			}
 		}
-		if (response.has_md_extension) {
-			errors[html_path.relativePath].push(
-				`Relative link contains MD extension, but should not: ${clean_relative_path}`,
-			);
+		if (response.has_md_extension || response.has_html_extension) {
+			const error_message = processErrorMessage(`Relative link has ${rel_path_ext} extension, but should not: ${relative_path}`, markdown_path, markdown_content, relative_path);
+			errors[html_path.relativePath].push(error_message);
 			return;
 		}
 		if (response.is_rel_path) {
@@ -647,16 +670,27 @@
 				: clean_relative_path;
 		const redir = checkRedirect(source_path, relpath);
 		if (redir.exists) {
-			if (redir.error !== null)
-				errors[html_path.relativePath].push(redir.error);
+			if (redir.error !== null) {
+				const error_message = processErrorMessage(`${redir.error}: ${relative_path}`, markdown_path, markdown_content, clean_relative_path);
+				errors[html_path.relativePath].push(error_message);
+			}
 		} else {
-			errors[html_path.relativePath].push(
-				`Link path does not exist: ${clean_relative_path}`,
-			);
+			const error_message = processErrorMessage(`Link path does not exist: ${relative_path}`, markdown_path, markdown_content, clean_relative_path);
+			errors[html_path.relativePath].push(error_message);
 		}
 	};
 
-	const doesFileExist = (source_path, html_path, relative_path) => {
+	const processErrorMessage = (message, md_path, content, search) => {
+		const link_location = hdoc.find_string_in_string(content, search);
+		let error_message = message;
+		if (link_location !== null)
+			error_message = `${md_path}:${link_location.line}:${link_location.column} - ${error_message}`;
+		else
+			error_message = `${md_path} - ${error_message}`;
+		return error_message;
+	};
+	
+	const doesFileExist = (source_path, html_path, relative_path, markdown_path, markdown_content) => {
 		// Remove explicit anchor links and _books prefix
 		const clean_relative_path = relative_path
 			.split("#")[0]
@@ -669,9 +703,8 @@
 			!fs.existsSync(`${file_path}.htm`) &&
 			!fs.existsSync(`${file_path}.html`)
 		) {
-			errors[html_path.relativePath].push(
-				`Book resource does not exist: ${clean_relative_path}`,
-			);
+			const error_message = processErrorMessage(`Book resource does not exist: ${clean_relative_path}`, markdown_path, markdown_content, relative_path);
+			errors[html_path.relativePath].push(error_message);
 			return false;
 		}
 		messages[html_path.relativePath].push(
@@ -935,9 +968,8 @@
 			let error_count = 0;
 			for (const key in errors) {
 				if (Object.hasOwn(errors, key) && errors[key].length > 0) {
-					console.error(`\r\n${errors[key].length} error(s) in ${key}`);
 					for (let i = 0; i < errors[key].length; i++) {
-						console.error(` - ${errors[key][i]}`);
+						console.error(`${errors[key][i]}`);
 						error_count++;
 					}
 				}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "hdoc-tools",
-	"version": "0.23.0",
+	"version": "0.24.1",
 	"description": "Hornbill HDocBook Development Support Tool",
 	"main": "hdoc.js",
 	"bin": {