npm - properties-comparator - Versions diffs - 1.0.4 → 1.0.6 - Mend

properties-comparator 1.0.4 → 1.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/.github/workflows/sonarcloud.yml +75 -0
package/DOCUMENTATION.md +202 -69
package/PUBLISH.MD +3 -1
package/README.md +80 -9
package/TEST.md +48 -1
package/babel.config.js +3 -0
package/cli.js +61 -0
package/index.js +323 -32
package/jest.config.js +9 -22
package/package.json +20 -7
package/sonar-project.properties +19 -0
package/src/compareUtility.js +540 -0

package/index.js CHANGED Viewed

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-const fs = require("fs");
-const path = require("path");
-const yaml = require("js-yaml");
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import yaml from "js-yaml";
 /**
  * Parses a .properties file into an object.
@@ -114,7 +115,7 @@ function parseFile(filePath) {
     default:
       console.error(
         `Warning: Unsupported file extension "${ext}" for file "${filePath}". ` +
-          `Only .properties, .yml, or .yaml are supported. This file will be treated as empty.`
+        `Only .properties, .yml, or .yaml are supported. This file will be treated as empty.`
       );
       return {};
   }
@@ -146,7 +147,7 @@ function compareFileData(filePaths) {
   // Compare values for each key across files
   allKeys.forEach((key) => {
     const values = parsedObjects.map(
-      (obj) => obj[key]?.replace(/\s+/g, "") || "N/A"
+      (obj) => obj[key]?.replaceAll(/\s+/g, "") || "N/A"
     );
     const matched = values.every((value) => value === values[0]);
     mismatchDetails.push({ key, values, matched });
@@ -182,61 +183,349 @@ function getMismatchFields(filePaths) {
 }
 /**
- * CLI function: compares properties/keys across multiple files,
- * prints details to the console, and provides a summary.
+ * Generates an HTML report for the comparison results.
  *
- * @param {string[]} filePaths - Array of file paths.
+ * @param {Array} filePaths - Array of file paths that were compared
+ * @param {Object} comparisonData - The output from compareFileData function
+ * @returns {string} - HTML document as string
  */
-function compareFiles(filePaths) {
-  console.log("Comparing properties/keys across files:\n");
+function generateHtmlReport(filePaths, comparisonData) {
+  const { mismatchCount, mismatchDetails } = comparisonData;
+  const fileNames = filePaths.map((fp) => path.basename(fp));
+  // Start HTML document
+  let html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Properties Comparison Report</title>
+  <style>
+    body { font-family: Arial, sans-serif; margin: 20px; line-height: 1.6; color: #333; }
+    h1, h2 { color: #0066cc; }
+    table { border-collapse: collapse; width: 100%; margin-bottom: 20px; }
+    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+    th { background-color: #f2f2f2; }
+    tr:nth-child(even) { background-color: #f9f9f9; }
+    tr:hover { background-color: #f2f2f2; }
+    .mismatch { background-color: #ffe6e6; }
+    .matched { background-color: #e6ffe6; }
+    .value-mismatch { color: #cc0000; font-weight: bold; }
+    .summary { margin: 20px 0; padding: 15px; border-radius: 5px; }
+    .summary.success { background-color: #e6ffe6; border: 1px solid #99cc99; }
+    .summary.error { background-color: #ffe6e6; border: 1px solid #cc9999; }
+    .file-list { margin-bottom: 20px; }
+  </style>
+</head>
+<body>
+  <h1>Properties Comparison Report</h1>
+  <div class="file-list">
+    <h2>Files Compared:</h2>
+    <ol>
+      ${fileNames
+      .map(
+        (name, idx) => `<li>${name} <small>(${filePaths[idx]})</small></li>`
+      )
+      .join("\n      ")}
+    </ol>
+  </div>
-  const { mismatchCount, mismatchDetails } = compareFileData(filePaths);
+  <h2>Comparison Results</h2>
+  <table>
+    <tr>
+      <th>Key</th>
+      <th>Matched</th>
+      ${fileNames
+      .map((name, idx) => `<th>File ${idx + 1}: ${name}</th>`)
+      .join("\n      ")}
+    </tr>`;
-  // Print detail for each key
+  // Add table rows for each key
   mismatchDetails.forEach(({ key, values, matched }) => {
-    if (matched) {
-      console.log(`Key: ${key} - Values match: '${values[0]}'`);
-    } else {
-      console.log(`Key: ${key} - Mismatched values:`);
-      values.forEach((value, idx) => {
-        console.log(`  File ${idx + 1} (${filePaths[idx]}): ${value}`);
-      });
-    }
+    html += `\n    <tr class="${matched ? "matched" : "mismatch"}">
+      <td>${key}</td>
+      <td>${matched ? "Yes" : "No"}</td>`;
+    // Add values from each file
+    values.forEach((value, idx) => {
+      const cellClass = matched ? "" : "value-mismatch";
+      html += `\n      <td class="${cellClass}">${value === "N/A" ? "<em>N/A</em>" : value
+        }</td>`;
+    });
+    html += `\n    </tr>`;
+  });
+  html += `\n  </table>
+  <div class="summary ${mismatchCount === 0 ? "success" : "error"}">
+    <h2>Summary</h2>`;
+  if (mismatchCount === 0) {
+    html += `\n    <p>All properties match across all files!</p>`;
+  } else {
+    html += `\n    <p>${mismatchCount} key(s) have mismatched values.</p>
+    <p><strong>Mismatched keys:</strong> ${mismatchDetails
+        .filter((detail) => !detail.matched)
+        .map((detail) => detail.key)
+        .join(", ")}</p>`;
+  }
+  html += `\n  </div>
+</body>
+</html>`;
+  return html;
+}
+/**
+ * Generates a Markdown report for the comparison results.
+ *
+ * @param {Array} filePaths - Array of file paths that were compared
+ * @param {Object} comparisonData - The output from compareFileData function
+ * @returns {string} - Markdown document as string
+ */
+function generateMarkdownReport(filePaths, comparisonData) {
+  const { mismatchCount, mismatchDetails } = comparisonData;
+  const fileNames = filePaths.map((fp) => path.basename(fp));
+  let markdown = `# Properties Comparison Report\n\n`;
+  // Files compared
+  markdown += `## Files Compared\n\n`;
+  filePaths.forEach((fp, idx) => {
+    markdown += `${idx + 1}. ${fileNames[idx]} (${fp})\n`;
+  });
+  // Comparison results table
+  markdown += `\n## Comparison Results\n\n`;
+  // Table header
+  markdown += `| Key | Matched | ${fileNames
+    .map((name, idx) => `File ${idx + 1}: ${name}`)
+    .join(" | ")} |\n`;
+  markdown += `| --- | --- | ${fileNames.map(() => "---").join(" | ")} |\n`;
+  // Table content
+  mismatchDetails.forEach(({ key, values, matched }) => {
+    markdown += `| ${key} | ${matched ? "Yes" : "No"} | ${values
+      .map((v) => (v === "N/A" ? "*N/A*" : v))
+      .join(" | ")} |\n`;
   });
   // Summary
-  console.log("\n=== Summary ===");
+  markdown += `\n## Summary\n\n`;
   if (mismatchCount === 0) {
-    console.log("All properties match across all files!");
+    markdown += `✅ All properties match across all files!\n`;
   } else {
-    console.log(`${mismatchCount} key(s) have mismatched values.`);
+    markdown += `❌ ${mismatchCount} key(s) have mismatched values.\n\n`;
+    markdown += `**Mismatched keys:** ${mismatchDetails
+      .filter((detail) => !detail.matched)
+      .map((detail) => detail.key)
+      .join(", ")}\n`;
   }
+  return markdown;
+}
+/**
+ * CLI function: compares properties/keys across multiple files,
+ * prints details to the console in a tabular format, and provides a summary.
+ *
+ * @param {string[]} filePaths - Array of file paths.
+ * @param {Object} options - Options for the comparison.
+ * @param {string} [options.format] - Output format ('console', 'html', or 'markdown').
+ * @param {string} [options.outputFile] - Path to save the report (for html and markdown).
+ */
+function compareFiles(filePaths, options = {}) {
+  const format = options.format || "console";
+  const outputFile = options.outputFile;
+  const comparisonData = compareFileData(filePaths);
+  if (format === "console") {
+    console.log("Comparing properties/keys across files:\n");
+    // Prepare data for tabular output
+    const tableData = comparisonData.mismatchDetails.map(
+      ({ key, values, matched }) => {
+        const valueColumns = values.reduce((acc, value, idx) => {
+          acc[`File ${idx + 1}`] = value;
+          return acc;
+        }, {});
+        return {
+          Key: key,
+          Matched: matched ? "Yes" : "No",
+          ...valueColumns,
+        };
+      }
+    );
+    // Print the table
+    console.table(tableData);
+    // Custom print for mismatched rows
+    console.log("\n=== Highlighted Mismatched Rows ===");
+    comparisonData.mismatchDetails.forEach(({ key, values, matched }) => {
+      if (!matched) {
+        const coloredValues = values.map((value, idx) =>
+          chalk.red(`File ${idx + 1}: ${value}`)
+        );
+        console.log(
+          chalk.yellow(`Key: ${key}`),
+          "|",
+          coloredValues.join(" | ")
+        );
+      }
+    });
+    // Summary
+    console.log("\n=== Summary ===");
+    if (comparisonData.mismatchCount === 0) {
+      console.log("All properties match across all files!");
+    } else {
+      console.log(
+        `${comparisonData.mismatchCount} key(s) have mismatched values.`
+      );
+      const mismatchedKeys = comparisonData.mismatchDetails
+        .filter((detail) => !detail.matched)
+        .map((detail) => detail.key);
+      console.log("Mismatched keys:", mismatchedKeys.join(", "));
+    }
+  } else if (format === "html") {
+    const htmlReport = generateHtmlReport(filePaths, comparisonData);
+    if (outputFile) {
+      fs.writeFileSync(outputFile, htmlReport);
+      console.log(`HTML report saved to: ${outputFile}`);
+    } else {
+      console.log(htmlReport);
+    }
+  } else if (format === "markdown") {
+    const markdownReport = generateMarkdownReport(filePaths, comparisonData);
+    if (outputFile) {
+      fs.writeFileSync(outputFile, markdownReport);
+      console.log(`Markdown report saved to: ${outputFile}`);
+    } else {
+      console.log(markdownReport);
+    }
+  } else {
+    console.error(
+      `Unsupported format: ${format}. Using console output instead.`
+    );
+    compareFiles(filePaths); // Fallback to console output
+  }
+}
+/**
+ * Prints the usage information for the CLI.
+ */
+function printUsage() {
+  console.error("Please provide file paths as command-line arguments.");
+  console.error(
+    "Usage: properties-comparator [options] file1 file2 [file3...]"
+  );
+  console.error("Options:");
+  console.error(
+    "  --format, -f <format>   Output format: console, html, or markdown"
+  );
+  console.error(
+    "  --output, -o <file>     Output file for html or markdown reports"
+  );
+}
+/**
+ * Parses command-line arguments.
+ * @param {string[]} args - Array of command-line arguments.
+ * @returns {{ filePaths: string[], options: Object }} - Parsed paths and options.
+ */
+function parseArgs(args) {
+  const options = {
+    format: "console",
+    outputFile: null,
+  };
+  const filePaths = [];
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === "--format" || args[i] === "-f") {
+      if (i + 1 < args.length) {
+        options.format = args[i + 1].toLowerCase();
+        i += 2;
+      } else {
+        i++;
+      }
+    } else if (args[i] === "--output" || args[i] === "-o") {
+      if (i + 1 < args.length) {
+        options.outputFile = args[i + 1];
+        i += 2;
+      } else {
+        i++;
+      }
+    } else {
+      filePaths.push(path.resolve(args[i]));
+      i++;
+    }
+  }
+  return { filePaths, options };
 }
 /**
  * CLI entry point for comparing .properties and .yml/.yaml files.
  */
 function run() {
-  const filePaths = process.argv.slice(2);
+  const { filePaths, options } = parseArgs(process.argv.slice(2));
   if (filePaths.length === 0) {
-    console.error("Please provide file paths as command-line arguments.");
+    printUsage();
+    process.exit(1);
+  } else if (filePaths.length === 1) {
+    console.error("Please provide at least two file paths for comparison.");
     process.exit(1);
   }
-  // Optionally, check if all files exist
   const missing = filePaths.filter((fp) => !fs.existsSync(fp));
   if (missing.length > 0) {
     console.error(`The following file(s) do not exist: ${missing.join(", ")}`);
-    // We continue anyway, or we can decide to exit.
-    // For now, let's exit to avoid unexpected comparisons:
     process.exit(1);
   }
-  compareFiles(filePaths);
+  compareFiles(filePaths, options);
+}
+/**
+ * API function to compare properties between two files.
+ * @param {string} file1 - Path to the first file
+ * @param {string} file2 - Path to the second file
+ * @param {Object} options - Comparison options
+ * @returns {Object} Comparison results in a structured format
+ */
+function compareProperties(file1, file2, options = {}) {
+  const filePaths = [file1, file2];
+  const comparisonData = compareFileData(filePaths);
+  // Process the output based on options
+  if (options.output) {
+    if (options.json) {
+      fs.writeFileSync(options.output, JSON.stringify(comparisonData, null, 2));
+    } else {
+      const format = path.extname(options.output).toLowerCase() === '.md' ? 'markdown' : 'html';
+      const report = format === 'markdown'
+        ? generateMarkdownReport(filePaths, comparisonData)
+        : generateHtmlReport(filePaths, comparisonData);
+      fs.writeFileSync(options.output, report);
+    }
+    if (options.verbose) {
+      console.log(`Comparison report saved to ${options.output}`);
+    }
+  }
+  return comparisonData;
 }
-module.exports = {
+export {
   parsePropertiesFile,
   parseYamlFile,
   parseFile,
@@ -244,10 +533,12 @@ module.exports = {
   checkIfAllValuesMatch,
   getMismatchFields,
   compareFiles,
-  run,
+  generateHtmlReport,
+  generateMarkdownReport,
+  compareProperties, // Add the new function to exports
 };
 // If the script is executed directly, run the CLI
-if (require.main === module) {
+if (import.meta.url === `file://${process.argv[1]}`) {
   run();
 }

package/jest.config.js CHANGED Viewed

@@ -1,22 +1,9 @@
-// jest.config.js
-module.exports = {
-    // Tell Jest to collect coverage information
-    collectCoverage: true,
-    // Or specify which files to collect coverage from
-    collectCoverageFrom: ['src/**/*.js'], // adjust for your source folder
-    // Optionally set coverage thresholds
-    coverageThreshold: {
-      global: {
-        branches: 80,
-        functions: 80,
-        lines: 80,
-        statements: 80,
-      },
-    },
-    // Customize output directory or coverage reporters if desired
-    coverageDirectory: 'coverage',
-    coverageReporters: ['json', 'lcov', 'text', 'clover'],
-  };
+export default {
+  testEnvironment: "node", // Use Node.js environment
+  transform: {
+    "^.+\\.js$": "babel-jest", // Transform ES modules with Babel
+  },
+  transformIgnorePatterns: [
+    "/node_modules/(?!(chalk|ansi-styles|supports-color|strip-ansi|ansi-regex)/)", // Allow specific ES module packages to be transformed
+  ],
+};

package/package.json CHANGED Viewed

@@ -1,14 +1,16 @@
 {
   "name": "properties-comparator",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "This utility provides functionality to parse and compare properties files in the format of key-value pairs. It reads properties files, compares the values for each key across multiple files, and logs the results.",
+  "type": "module",
   "main": "index.js",
   "bin": {
-    "properties-comparator": "./index.js"
+    "properties-comparator": "./cli.js"
   },
   "scripts": {
     "test": "jest",
-    "run": "node index.js"
+    "run": "node index.js",
+    "clean": "rm -rf node_modules coverage"
   },
   "repository": {
     "type": "git",
@@ -16,7 +18,9 @@
   },
   "keywords": [
     "properties",
-    "comparator"
+    "compare",
+    "yaml",
+    "configuration"
   ],
   "author": "Zack Dawood",
   "license": "MIT",
@@ -25,9 +29,18 @@
   },
   "homepage": "https://github.com/zackria/properties-comparator#readme",
   "dependencies": {
-    "js-yaml": "^4.1.0"
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "js-yaml": "^4.1.1"
   },
   "devDependencies": {
-    "jest": "^29.7.0"
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
+    "babel-jest": "^30.2.0",
+    "jest": "^30.2.0",
+    "jest-environment-node": "^30.2.0"
+  },
+  "overrides": {
+    "test-exclude": "^7.0.1"
   }
-}
+}

package/sonar-project.properties ADDED Viewed

@@ -0,0 +1,19 @@
+sonar.projectKey=zackria_properties-comparator
+sonar.organization=zackria
+# This is the name and version displayed in the SonarCloud UI.
+#sonar.projectName=properties-comparator
+#sonar.projectVersion=1.0.6
+# Path is relative to the sonarproject.properties file. Replace "\" by "/" on Windows.
+sonar.sources=index.js,cli.js,src
+sonar.tests=test
+sonar.test.inclusions=test/**/*.test.js
+# Encoding of the source code. Default is default system encoding
+sonar.sourceEncoding=UTF-8
+# JavaScript-specific configurations
+sonar.javascript.lcov.reportPaths=coverage/lcov.info
+sonar.exclusions=node_modules/**, coverage/**, index.js
+sonar.cpd.exclusions=index.js