yini-cli 1.3.1-beta → 1.3.2-beta

package/README.md

@@ -256,6 +256,6 @@ In this project on GitHub, the `libs` directory contains third party software an
 ---
 
 **^YINI ≡**  
-> YINI — Clear, Structured Configuration Files.  
+> Readable like INI. Structured like JSON. No indentation surprises.  
 
 [yini-lang.org](https://yini-lang.org/?utm_source=github&utm_medium=referral&utm_campaign=yini_cli&utm_content=readme_footer) · [YINI on GitHub](https://github.com/YINI-lang)  

package/dist/commands/parseCommand.d.ts

@@ -13,4 +13,13 @@ export interface IParseCommandOptions extends IGlobalOptions {
     bestEffort?: boolean;
     overwrite?: boolean;
 }
+/**
+ * Will return true if:
+ *   * --overwrite was not explicitly given
+ *   * destination exists
+ *   * destination is newer than source
+ * @returns
+ */
+export declare const shouldSkipBecauseDestNewer: (file: string, optionOverwrite?: boolean | undefined, outputFile?: string) => boolean;
+export declare const isAllowWriteOutput: (srcPath: string, destPath: string, newContent: string, overwrite?: boolean) => boolean;
 export declare const parseFile: (file: string, commandOptions: IParseCommandOptions) => void;

package/dist/commands/parseCommand.js

@@ -5,6 +5,51 @@ import YINI from 'yini-parser';
 import { getSerializer } from '../serializers/index.js';
 import { debugPrint, printObject } from '../utils/print.js';
 // -------------------------------------------------------------------------
+/**
+ * Will return true if:
+ *   * --overwrite was not explicitly given
+ *   * destination exists
+ *   * destination is newer than source
+ * @returns
+ */
+export const shouldSkipBecauseDestNewer = (file, optionOverwrite, 
+// optionVerbose?: boolean | undefined,
+outputFile = '') => {
+    if (outputFile && optionOverwrite === undefined) {
+        const resolved = path.resolve(outputFile);
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+            const srcStat = fs.statSync(file);
+            const destStat = fs.statSync(resolved);
+            if (destStat.mtimeMs > srcStat.mtimeMs) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+export const isAllowWriteOutput = (srcPath, destPath, newContent, overwrite) => {
+    if (!fs.existsSync(destPath)) {
+        return true;
+    }
+    if (overwrite === true) {
+        return true;
+    }
+    if (overwrite === false) {
+        throw new Error(`File "${destPath}" already exists. Overwriting disabled (--no-overwrite).`);
+    }
+    const srcStat = fs.statSync(srcPath);
+    const destStat = fs.statSync(destPath);
+    if (destStat.mtimeMs > srcStat.mtimeMs) {
+        reportAction('skip', destPath, `newer than source "${srcPath}"`);
+        return false;
+    }
+    const existing = fs.readFileSync(destPath, 'utf-8');
+    if (existing === newContent) {
+        reportAction('skip', destPath, 'output unchanged');
+        return false;
+    }
+    return true;
+};
 const reportAction = (action, file, reason) => {
     let txt = '';
     if (reason) {
@@ -82,69 +127,67 @@ const resolveOutputFormat = (options) => {
     }
     return 'json';
 };
-/*
-const renderOutput = (parsed: unknown, style: TOutputStyle): string => {
-    switch (style) {
-        case 'JS-style':
-            return toPrettyJS(parsed)
-
-        case 'JSON-compact':
-            return JSON.stringify(parsed)
-
-        case 'Pretty-JSON':
-        default:
-            return toPrettyJSON(parsed)
-    }
-}
-*/
+/**
+ * Returns true if the parsed result appears to contain usable output data.
+ *
+ * This is used by the CLI to distinguish between:
+ * - parse runs that reported errors but still recovered meaningful data, and
+ * - parse runs that failed so badly that no useful parsed structure was produced.
+ *
+ * A value is considered meaningful only if it is:
+ * - not null or undefined,
+ * - an object,
+ * - and contains at least one own top-level property.
+ *
+ * @param value The parsed result data to inspect.
+ * @returns True if the parsed result looks usable for output; otherwise false.
+ */
+const hasMeaningfulParsedData = (value) => {
+    if (value == null)
+        return false;
+    if (typeof value !== 'object')
+        return false;
+    return Object.keys(value).length > 0;
+};
 const doParseFile = (file, commandOptions, outputFormat, outputFile = '') => {
-    let preferredFailLevel = commandOptions.bestEffort
-        ? 'ignore-errors'
-        : 'auto';
-    let includeMetaData = false;
     debugPrint('File = ' + file);
     debugPrint('outputFormat = ' + outputFormat);
     const parseOptions = {
         strictMode: commandOptions.strict ?? false,
         failLevel: commandOptions.bestEffort ? 'ignore-errors' : 'auto',
-        includeMetadata: false,
+        includeMetadata: true,
+        includeDiagnostics: true,
     };
-    // If --best-effort then override fail-level.
-    // if (commandOptions.bestEffort) {
-    //     parseOptions.failLevel = 'ignore-errors'
-    // }
+    // Check early if should skip before parsing,
+    // saves a lot of time in some cases.
+    if (shouldSkipBecauseDestNewer(file, commandOptions.overwrite, 
+    // commandOptions.verbose,
+    outputFile)) {
+        if (commandOptions.verbose) {
+            const resolved = path.resolve(outputFile);
+            reportAction('skip', resolved, `newer than source "${file}"`);
+        }
+        return;
+    }
     try {
-        const parsed = YINI.parseFile(file, parseOptions);
+        const parsedWithMeta = YINI.parseFile(file, parseOptions);
+        const errorCount = parsedWithMeta?.meta?.diagnostics?.errors?.errorCount ?? 0;
+        const parsedData = parsedWithMeta.result;
+        const hasUsableOutput = hasMeaningfulParsedData(parsedData);
+        if (errorCount > 0 &&
+            !commandOptions.bestEffort &&
+            (commandOptions.strict || !hasUsableOutput)) {
+            process.exit(1);
+        }
         const serializer = getSerializer(outputFormat);
-        const output = serializer.serialize(parsed);
+        const output = serializer.serialize(parsedData);
         if (outputFile) {
             const resolved = path.resolve(outputFile);
-            const canWrite = enforceWritePolicy(file, resolved, commandOptions.overwrite);
-            if (!canWrite) {
-                if (commandOptions.verbose) {
-                    console.log(`skip    Skipping write to "${resolved}"`);
-                }
+            if (!isAllowWriteOutput(file, resolved, output, commandOptions.overwrite)) {
                 return;
             }
-            // Double check, if the file was actually changed by comparing the contents.
-            if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
-                const existing = fs.readFileSync(resolved, 'utf-8');
-                // Only write the output file if the content actually changed.
-                // Prevents constantly showing meaningless rewrites, in some cases.
-                if (existing === output) {
-                    if (commandOptions.verbose) {
-                        // console.log(
-                        //     `skip    Output unchanged. Skipping write: "${resolved}"`,
-                        // )
-                        reportAction('skip', resolved, 'output unchanged');
-                    }
-                    return;
-                }
-            }
-            // Write JSON output to file instead of stdout.
             fs.writeFileSync(resolved, output, 'utf-8');
             if (commandOptions.verbose) {
-                // console.log(`write    Output written to file: "${outputFile}"`)
                 reportAction('write', resolved);
             }
         }
@@ -158,29 +201,3 @@ const doParseFile = (file, commandOptions, outputFormat, outputFile = '') => {
         process.exit(1);
     }
 };
-const enforceWritePolicy = (srcPath, destPath, overwrite) => {
-    if (!fs.existsSync(destPath)) {
-        return true; // File does not exist, OK to write.
-    }
-    const srcStat = fs.statSync(srcPath);
-    const destStat = fs.statSync(destPath);
-    // Only strictly newer triggers skip overwrite.
-    const destIsNewer = destStat.mtimeMs > srcStat.mtimeMs;
-    if (overwrite === true) {
-        return true; // Explicit overwrite, OK.
-    }
-    if (overwrite === false) {
-        throw new Error(`File "${destPath}" already exists. Overwriting disabled (--no-overwrite).`);
-    }
-    // Default policy (overwrite undefined).
-    if (destIsNewer) {
-        // console.warn(
-        //     // `Destination file "${destPath}" is newer than source. Use --overwrite to force.`,
-        //     //`Warning: destination file "${destPath}" is newer than source. Skipping write. Use --overwrite to force.`,
-        //     `Warning: destination "${destPath}" is newer than source "${srcPath}". Skipping write. Use --overwrite to force.`,
-        // )
-        reportAction('skip', destPath, `newer than source "${srcPath}"`);
-        return false;
-    }
-    return true;
-};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yini-cli",
-    "version": "1.3.1-beta",
+    "version": "1.3.2-beta",
     "description": "CLI tool for validating and converting YINI configuration files - an INI-like format with real structure, nested sections and strict or lenient modes.",
     "keywords": [
         "yini",
@@ -74,7 +74,7 @@
         "commander": "^14.0.1",
         "xmlbuilder2": "^4.0.3",
         "yaml": "^2.8.2",
-        "yini-parser": "^1.4.0-beta"
+        "yini-parser": "^1.4.1-beta"
     },
     "devDependencies": {
         "@eslint/js": "^9.31.0",