properties-comparator 1.0.3 → 1.0.4

package/DOCUMENTATION.md

@@ -1,13 +1,13 @@
-
-# Node.js Properties File Comparison Utility
+# Node.js YAML and Properties File Comparison Utility
 
 ## Overview
 
-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.
+This utility parses and compares **.properties** and **.yml or .yaml (YAML)** files. It reads each file as key-value pairs, compares the values for each key across multiple files, and logs the results.
 
 ### Features:
-- Parse properties files into key-value objects.
-- Compare key values across multiple properties files.
+- Parse **.properties** files into key-value objects.
+- Parse **.yml or .yaml** (YAML) files into flattened key-value objects (supports nested keys).
+- Compare key values across multiple files (both **.properties** and **.yml or .yaml**).
 - Log detailed comparison results, including mismatches.
 
 ---
@@ -16,7 +16,7 @@ This utility provides functionality to parse and compare properties files in the
 
 ### Prerequisites
 - Node.js installed on your system.
-- Properties files in a valid key-value format.
+- Files in valid .properties or .yaml or .yml format.
 
 ---
 
@@ -53,23 +53,11 @@ Parses a properties file and returns an object representation of the key-value p
 
 #### Example:
 ```javascript
-// Assuming properties file contains:
-// key1=value1
-// key2=value2
-
 const properties = parsePropertiesFile('/path/to/properties/file');
 console.log(properties);
 // Output: { key1: 'value1', key2: 'value2' }
 ```
 
-#### Implementation:
-- Reads the file content using `fs.readFileSync`.
-- Splits lines by `
-` or `
-`.
-- Filters out empty lines and lines starting with `#`.
-- Processes valid lines into key-value pairs.
-
 ---
 
 ### `compareProperties(filePaths)`
@@ -82,15 +70,9 @@ Compares properties across multiple properties files and logs the results.
 #### Returns:
 - None. Outputs comparison results to the console.
 
-#### Behavior:
-- Parses each properties file into an object.
-- Collects all unique keys across files.
-- Compares values for each key across all files.
-- Logs whether values match or are mismatched. For mismatches, displays values for each file.
-
 #### Example:
 ```bash
-node script.js file1.properties file2.properties file3.properties
+node script.js file1.properties file2.yaml file3.yml
 ```
 
 #### Output Example:
@@ -121,6 +103,31 @@ The script expects file paths as command-line arguments:
 
 ---
 
+### Additional Functions
+
+#### `parseFile(filePath)`
+Detects file extension and parses `.properties`, `.yaml`, or `.yml` files. Returns an object with flattened key-value pairs or `{}` if unsupported.
+
+#### `parseYamlFile(filePath)`
+Parses a `.yml` or `.yaml` file into a flat key-value map. Returns an object with dot-notation keys for nested values.
+
+#### `compareFileData(filePaths)`
+Internally compares parsed data from multiple files. Returns an object with `mismatchCount` and detailed info for each key.
+
+#### `checkIfAllValuesMatch(filePaths)`
+Checks if all keys match across all provided files. Returns a boolean.
+
+#### `getMismatchFields(filePaths)`
+Returns an array of keys whose values differ across files.
+
+#### `compareFiles(filePaths)`
+Logs detailed comparison of key-value pairs across files. Prints a summary indicating mismatched keys.
+
+#### `run()`
+CLI entry point. Reads file paths, checks existence, and calls `compareFiles`.
+
+---
+
 ## Error Handling
 
 - **No File Paths Provided**: Logs an error and exits.
@@ -167,6 +174,7 @@ Key: key2 - Mismatched values:
 ## Dependencies
 
 - `fs` module (Node.js File System)
+- `js-yaml` module (Node.js YAML library)
 
 ---
 

package/README.md

@@ -1,5 +1,6 @@
 # properties-comparator
-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.
+This utility provides functionality to parse and compare **.properties** and **.yml or .yaml(YAML)** files in the format of key-value pairs. It reads these files, compares the values for each key across multiple files, and logs the results.
+
 
 Utility is available as NPM Package [https://www.npmjs.com/package/properties-comparator](https://www.npmjs.com/package/properties-comparator)
 
@@ -12,5 +13,8 @@ Utility is available as NPM Package [https://www.npmjs.com/package/properties-co
 
 ```properties-comparator <filePath1> <filePath2>```
 
+## Compiled on npm@11.1.0 & node v22.13.0
+`npm install -g npm@11.1.0`
+
 
 ### Check [Documentation](DOCUMENTATION.md) for more details

package/TEST.md

@@ -0,0 +1,15 @@
+# Automated testing with Jest 
+
+
+## Run Your Tests
+`npm init -y        # if you haven't created a package.json yet`
+`npm install --save-dev jest`
+
+`npm test`
+or
+`npx jest`
+
+
+### Check jest.config.js for testing configuration
+
+`npm test -- --coverage`

package/index.js

@@ -1,75 +1,253 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
+const fs = require("fs");
+const path = require("path");
+const yaml = require("js-yaml");
 
 /**
- * Parses a properties file into an object.
+ * Parses a .properties file into an object.
+ * Handles any file read/parse errors gracefully.
  * @param {string} filePath - The path to the properties file.
- * @returns {Object} - An object containing key-value pairs.
+ * @returns {Object} - Key-value pairs, or {} on error.
  */
 function parsePropertiesFile(filePath) {
-    return fs.readFileSync(filePath, 'utf-8')
-        .split(/\r?\n/)
-        .filter(line => line.trim() && !line.startsWith('#'))
-        .reduce((acc, line) => {
-            const [key, value] = line.split('=');
-            if (key && value !== undefined) {
-                acc[key.trim()] = value.trim();
-            }
-            return acc;
-        }, {});
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const result = {};
+
+    for (let line of lines) {
+      let trimmedLine = line.trim();
+
+      // 1) Skip empty lines or lines that *start* with '#'
+      if (!trimmedLine || trimmedLine.startsWith("#")) {
+        continue;
+      }
+
+      // 2) Remove inline comment: anything after the first '#'
+      const hashIndex = trimmedLine.indexOf("#");
+      if (hashIndex !== -1) {
+        trimmedLine = trimmedLine.slice(0, hashIndex).trim();
+      }
+
+      // 3) Split on the *first* '=' only
+      const eqIndex = trimmedLine.indexOf("=");
+      if (eqIndex === -1) {
+        // No '=' => Not a valid key-value line
+        continue;
+      }
+
+      const key = trimmedLine.slice(0, eqIndex).trim();
+      const value = trimmedLine.slice(eqIndex + 1).trim();
+
+      if (key) {
+        result[key] = value;
+      }
+    }
+
+    return result;
+  } catch (err) {
+    console.error(
+      `Error reading/parsing .properties file (${filePath}):`,
+      err.message
+    );
+    return {};
+  }
 }
 
 /**
- * Compares properties across multiple files.
+ * Flattens a nested object into a single-level object using dot-notation for nested keys.
+ * @param {Object} obj - The object to flatten.
+ * @param {string} [parentKey=''] - The current parent key (used in recursion).
+ * @param {Object} [res={}] - The accumulator object.
+ * @returns {Object} - A flattened key-value map.
+ */
+function flattenObject(obj, parentKey = "", res = {}) {
+  for (const [key, value] of Object.entries(obj || {})) {
+    const newKey = parentKey ? `${parentKey}.${key}` : key;
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      flattenObject(value, newKey, res);
+    } else {
+      // Ensure all values are strings for consistent comparison
+      res[newKey] = String(value);
+    }
+  }
+  return res;
+}
+
+/**
+ * Parses a .yml or .yaml file into a flat key-value map.
+ * Handles any file read/parse errors gracefully.
+ * @param {string} filePath - The path to the YAML file.
+ * @returns {Object} - A flattened key-value map, or {} on error.
+ */
+function parseYamlFile(filePath) {
+  try {
+    const fileContents = fs.readFileSync(filePath, "utf-8");
+    const data = yaml.load(fileContents);
+    return flattenObject(data);
+  } catch (err) {
+    console.error(
+      `Error reading/parsing YAML file (${filePath}):`,
+      err.message
+    );
+    return {};
+  }
+}
+
+/**
+ * Detects file extension and parses the file content into an object.
+ * Currently supports .properties, .yaml, and .yml.
+ * If extension is unsupported, logs a warning and returns {}.
+ * @param {string} filePath - The path to the file.
+ * @returns {Object} - Parsed content as a key-value map, or {} if unsupported.
+ */
+function parseFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+
+  switch (ext) {
+    case ".properties":
+      return parsePropertiesFile(filePath);
+    case ".yml":
+    case ".yaml":
+      return parseYamlFile(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.`
+      );
+      return {};
+  }
+}
+
+/**
+ * Internal helper that compares key-value data from multiple files
+ * and returns a structured result (without printing to console).
+ *
  * @param {string[]} filePaths - Array of file paths.
+ * @returns {{
+ *    mismatchCount: number,
+ *    mismatchDetails: {
+ *        key: string,
+ *        values: string[],
+ *        matched: boolean
+ *    }[]
+ * }}
  */
-function compareProperties(filePaths) {
-    const propertiesList = filePaths.map(parsePropertiesFile);
-    const allKeys = new Set(propertiesList.flatMap(Object.keys));
-
-    console.log('Comparing properties across files:\n');
-
-    allKeys.forEach(key => {
-        const values = propertiesList.map(props => props[key]?.replace(/\s+/g, '') || 'N/A');
-        const allMatch = values.every(value => value === values[0]);
-
-        if (allMatch) {
-            console.log(`Key: ${key} - Values match across all files.`);
-        } else {
-            console.log(`Key: ${key} - Mismatched values:`);
-            values.forEach((value, index) => {
-                console.log(`  File ${index + 1}: ${value}`);
-            });
-        }
-    });
+function compareFileData(filePaths) {
+  // Parse each file
+  const parsedObjects = filePaths.map(parseFile);
+
+  // Collect all unique keys
+  const allKeys = new Set(parsedObjects.flatMap((obj) => Object.keys(obj)));
+
+  const mismatchDetails = [];
+
+  // Compare values for each key across files
+  allKeys.forEach((key) => {
+    const values = parsedObjects.map(
+      (obj) => obj[key]?.replace(/\s+/g, "") || "N/A"
+    );
+    const matched = values.every((value) => value === values[0]);
+    mismatchDetails.push({ key, values, matched });
+  });
+
+  // Count mismatches
+  const mismatchCount = mismatchDetails.filter((d) => !d.matched).length;
+  return { mismatchCount, mismatchDetails };
 }
 
 /**
- * CLI entry point for comparing properties files.
+ * Helper function: checks if all values match across the provided files.
+ *
+ * @param {string[]} filePaths - Array of file paths.
+ * @returns {boolean} - True if all properties match across all files, false otherwise.
  */
-function run() {
-    const filePaths = process.argv.slice(2);
+function checkIfAllValuesMatch(filePaths) {
+  const { mismatchCount } = compareFileData(filePaths);
+  return mismatchCount === 0;
+}
 
-    if (filePaths.length === 0) {
-        console.error('Please provide the paths to the properties files as command-line arguments.');
-        process.exit(1);
-    }
+/**
+ * Helper function: returns a list of fields (keys) that do not match.
+ *
+ * @param {string[]} filePaths - Array of file paths.
+ * @returns {string[]} - List of mismatched keys.
+ */
+function getMismatchFields(filePaths) {
+  const { mismatchDetails } = compareFileData(filePaths);
+  return mismatchDetails
+    .filter((detail) => !detail.matched)
+    .map((detail) => detail.key);
+}
+
+/**
+ * CLI function: compares properties/keys across multiple files,
+ * prints details to the console, and provides a summary.
+ *
+ * @param {string[]} filePaths - Array of file paths.
+ */
+function compareFiles(filePaths) {
+  console.log("Comparing properties/keys across files:\n");
+
+  const { mismatchCount, mismatchDetails } = compareFileData(filePaths);
 
-    if (filePaths.every(fs.existsSync)) {
-        compareProperties(filePaths);
+  // Print detail for each key
+  mismatchDetails.forEach(({ key, values, matched }) => {
+    if (matched) {
+      console.log(`Key: ${key} - Values match: '${values[0]}'`);
     } else {
-        console.error('One or more properties files are missing. Ensure all specified properties files exist.');
+      console.log(`Key: ${key} - Mismatched values:`);
+      values.forEach((value, idx) => {
+        console.log(`  File ${idx + 1} (${filePaths[idx]}): ${value}`);
+      });
     }
+  });
+
+  // Summary
+  console.log("\n=== Summary ===");
+  if (mismatchCount === 0) {
+    console.log("All properties match across all files!");
+  } else {
+    console.log(`${mismatchCount} key(s) have mismatched values.`);
+  }
+}
+
+/**
+ * CLI entry point for comparing .properties and .yml/.yaml files.
+ */
+function run() {
+  const filePaths = process.argv.slice(2);
+
+  if (filePaths.length === 0) {
+    console.error("Please provide file paths as command-line arguments.");
+    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);
 }
 
 module.exports = {
-    parsePropertiesFile,
-    compareProperties,
-    run,
+  parsePropertiesFile,
+  parseYamlFile,
+  parseFile,
+  compareFileData,
+  checkIfAllValuesMatch,
+  getMismatchFields,
+  compareFiles,
+  run,
 };
 
 // If the script is executed directly, run the CLI
 if (require.main === module) {
-    run();
+  run();
 }

package/jest.config.js

@@ -0,0 +1,22 @@
+// 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'],
+  };
+  

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "properties-comparator",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "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.",
   "main": "index.js",
   "bin": {
     "properties-comparator": "./index.js"
   },
   "scripts": {
-    "test": "node index.js"
+    "test": "jest",
+    "run": "node index.js"
   },
   "repository": {
     "type": "git",
@@ -22,5 +23,11 @@
   "bugs": {
     "url": "https://github.com/zackria/properties-comparator/issues"
   },
-  "homepage": "https://github.com/zackria/properties-comparator#readme"
+  "homepage": "https://github.com/zackria/properties-comparator#readme",
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
 }