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

properties-comparator 1.0.4 → 1.0.5

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 (10) hide show

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 "fs";
+import path from "path";
+import yaml from "js-yaml";
 /**
  * Parses a .properties file into an object.
@@ -182,34 +183,238 @@ 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
   }
 }
@@ -217,26 +422,90 @@ function compareFiles(filePaths) {
  * CLI entry point for comparing .properties and .yml/.yaml files.
  */
 function run() {
-  const filePaths = process.argv.slice(2);
+  const args = process.argv.slice(2);
+  const options = {
+    format: "console",
+    outputFile: null,
+  };
+  // Parse arguments for format and output file
+  const filePaths = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--format" || args[i] === "-f") {
+      if (i + 1 < args.length) {
+        options.format = args[i + 1].toLowerCase();
+        i++; // Skip the next argument as it's the format value
+      }
+    } else if (args[i] === "--output" || args[i] === "-o") {
+      if (i + 1 < args.length) {
+        options.outputFile = args[i + 1];
+        i++; // Skip the next argument as it's the output file path
+      }
+    } else {
+      // Not an option, treat as file path
+      filePaths.push(path.resolve(args[i]));
+    }
+  }
   if (filePaths.length === 0) {
     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"
+    );
+    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
+ */
+async 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 +513,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,10 +1,11 @@
 {
   "name": "properties-comparator",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "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",
@@ -16,7 +17,9 @@
   },
   "keywords": [
     "properties",
-    "comparator"
+    "compare",
+    "yaml",
+    "configuration"
   ],
   "author": "Zack Dawood",
   "license": "MIT",
@@ -25,9 +28,15 @@
   },
   "homepage": "https://github.com/zackria/properties-comparator#readme",
   "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "jest": "^29.7.0"
+    "@babel/core": "^7.26.10",
+    "@babel/preset-env": "^7.26.9",
+    "babel-jest": "^29.7.0",
+    "jest": "^29.7.0",
+    "jest-environment-node": "^29.7.0"
   }
 }