Merge pull request #160 from DecimalTurn/dev-spacing

Author: DecimalTurn

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Patching: Preserve inline comment alignment when patching existing TOML date values with regular JavaScript `Date` objects.
+
 ## [1.1.0] - 2026-04-15
 
 ### Added

benchmark/parse-benchmark.mjs

@@ -133,6 +133,24 @@ function resolveWorkspacePackage(packageName) {
   return modulePath;
 }
 
+function getParseOptions(implementationName) {
+  if (implementationName === 'smol-toml') {
+    return { maxDepth: 1010 };
+  }
+
+  return undefined;
+}
+
+function createParseRunner(TOML, implementationName) {
+  const parseOptions = getParseOptions(implementationName);
+
+  if (parseOptions == null) {
+    return (toml) => TOML.parse(toml);
+  }
+
+  return (toml) => TOML.parse(toml, parseOptions);
+}
+
 /**
  * Dynamically import a module, resolving ESM entry points for cached packages.
  * @param {string} modulePath - Absolute or relative path to the module
@@ -294,15 +312,15 @@ const allResults = [];
 /**
  * Warmup phase to allow V8 to optimize the code before benchmarking
  */
-async function warmupModule(TOML, benchmarks, implementationName) {
+async function warmupModule(parseToml, benchmarks, implementationName) {
   console.log(c.dim(`  🔥 Warming up ${implementationName}...`));
   const warmupIterations = 50;
 
   // Run multiple iterations to trigger V8 optimization
   for (let i = 0; i < warmupIterations; i++) {
     for (const { data } of benchmarks) {
       try {
-        TOML.parse(data);
+        parseToml(data);
       } catch (_) {
         // Ignore errors during warmup
       }
@@ -329,13 +347,15 @@ for (const implementation of implementationsToRun) {
     continue;
   }
 
+  const parseToml = createParseRunner(TOML, implementation.name);
+
   // Warmup phase to ensure fair V8 optimization
-  await warmupModule(TOML, benchmarks, implementation.name);
+  await warmupModule(parseToml, benchmarks, implementation.name);
 
   // Create benchmark suite
   const suite = new Suite(`${implementation.name}-parse`);
   benchmarks.forEach(({ name, data }) => {
-    suite.add(name, () => TOML.parse(data));
+    suite.add(name, () => parseToml(data));
   });
 
   // Run benchmarks

src/__tests__/patch.test.ts

@@ -1856,7 +1856,7 @@ test('should patch date field from example toml', () => {
 
     [owner]
     name = "Tom Preston-Werner"
-    dob = 1979-05-28T07:32:00Z     # First class dates? Why not?
+    dob = 1979-05-28T07:32:00Z # First class dates? Why not?
 
     [database]
     enabled = true
@@ -2188,6 +2188,170 @@ test('should patch offset datetime with milliseconds and preserve precision', ()
     ` + '\n');
 });
 
+test('should preserve aligned inline comments when patching mixed date kinds with regular Date values', () => {
+  const existing = dedent`
+    # Demo fixture covering TOML date and time value kinds
+    title = "Date parser demo"
+
+    [dates]
+    offset_date_time = 1979-05-28T07:32:00-08:00   # offset date-time
+    local_date_time  = 1979-05-28T07:32:00         # local date-time
+    local_date       = 1979-05-28                  # local date
+    local_time       = 07:32:00                    # local time
+
+    [events]
+    published_at     = 2026-04-17T09:15:30Z        # UTC timestamp
+    cutoff_time      = 18:45:00                    # time only
+    release_day      = 2026-05-02                  # date only
+    ` + '\n';
+
+  type Operation = { keyPath: string; changed: boolean };
+
+  const ONE_DAY_IN_MS = 24 * 60 * 60 * 1000;
+  const TIME_ONLY_RE = /^\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?$/u;
+  const value = parse(existing);
+  const operations: Operation[] = [];
+
+  const incrementDateValues = (input: Record<string, unknown>, pathParts: string[]) => {
+    for (const [key, nestedValue] of Object.entries(input)) {
+      const nextPath = [...pathParts, key];
+
+      if (nestedValue instanceof Date && TIME_ONLY_RE.test(nestedValue.toISOString())) {
+        operations.push({ keyPath: nextPath.join('.'), changed: false });
+        continue;
+      }
+
+      if (nestedValue instanceof Date) {
+        input[key] = new Date(nestedValue.getTime() + ONE_DAY_IN_MS);
+        operations.push({ keyPath: nextPath.join('.'), changed: true });
+        continue;
+      }
+
+      if (!nestedValue || typeof nestedValue !== 'object') {
+        continue;
+      }
+
+      incrementDateValues(nestedValue as Record<string, unknown>, nextPath);
+    }
+  };
+
+  incrementDateValues(value as Record<string, unknown>, []);
+
+  expect(operations.filter(operation => operation.changed).map(operation => operation.keyPath)).toEqual([
+    'dates.offset_date_time',
+    'dates.local_date_time',
+    'dates.local_date',
+    'events.published_at',
+    'events.release_day'
+  ]);
+
+  expect(operations.filter(operation => !operation.changed).map(operation => operation.keyPath)).toEqual([
+    'dates.local_time',
+    'events.cutoff_time'
+  ]);
+
+  const patched = patch(existing, value);
+
+  expect(patched).toEqual(dedent`
+    # Demo fixture covering TOML date and time value kinds
+    title = "Date parser demo"
+
+    [dates]
+    offset_date_time = 1979-05-29T07:32:00-08:00   # offset date-time
+    local_date_time  = 1979-05-29T07:32:00         # local date-time
+    local_date       = 1979-05-29                  # local date
+    local_time       = 07:32:00                    # local time
+
+    [events]
+    published_at     = 2026-04-18T09:15:30Z        # UTC timestamp
+    cutoff_time      = 18:45:00                    # time only
+    release_day      = 2026-05-03                  # date only
+    ` + '\n');
+});
+
+  test('should preserve aligned inline comments when patching single-line basic strings, arrays and numbers with same width', () => {
+    const existing = dedent`
+      # Demo fixture covering strings, arrays and number value kinds
+      title         = "Release plan"                    # single-line basic string
+      retry_count   = 3                                 # integer
+      error_rate    = 0.125                             # float
+      build_numbers = [1, 2, 3]                         # inline array
+
+      [service]
+      display_name  = "API"                             # string in table
+      ports         = [8080, 8081]                      # array in table
+      timeout_ms    = 1500                              # number in table
+      ` + '\n';
+
+    const value = parse(existing);
+
+    value.title = 'Sprint notes';
+    value.retry_count = 7;
+    value.error_rate = 0.875;
+    value.build_numbers = [2, 4, 6];
+    value.service.display_name = 'CLI';
+    value.service.ports = [9000, 9001];
+    value.service.timeout_ms = 2500;
+
+    const patched = patch(existing, value);
+
+    expect(patched).toEqual(dedent`
+      # Demo fixture covering strings, arrays and number value kinds
+      title         = "Sprint notes"                    # single-line basic string
+      retry_count   = 7                                 # integer
+      error_rate    = 0.875                             # float
+      build_numbers = [2, 4, 6]                         # inline array
+
+      [service]
+      display_name  = "CLI"                             # string in table
+      ports         = [9000, 9001]                      # array in table
+      timeout_ms    = 2500                              # number in table
+      ` + '\n');
+  });
+
+  // TODO: Implement comments alignment detection across lines to preserve
+  //      even when value width changes. This is currently not supported, 
+  //      so the test is skipped.
+  test.skip('should preserve aligned inline comments when patching single-line basic strings, arrays and numbers with different width', () => {
+    const existing = dedent`
+      # Demo fixture covering strings, arrays and number value kinds
+      title         = "Release plan"                    # single-line basic string
+      retry_count   = 3                                 # integer
+      error_rate    = 0.125                             # float
+      build_numbers = [1, 2, 3]                         # inline array
+
+      [service]
+      display_name  = "API"                             # string in table
+      ports         = [8080, 8081]                      # array in table
+      timeout_ms    = 1500                              # number in table
+      ` + '\n';
+
+    const value = parse(existing);
+
+    value.title = 'Release plan v2';
+    value.retry_count = 12;
+    value.error_rate = 0.5;
+    value.build_numbers = [1, 2, 3, 5, 8];
+    value.service.display_name = 'API Gateway';
+    value.service.ports = [8080, 8081, 8082];
+    value.service.timeout_ms = 25000;
+
+    const patched = patch(existing, value);
+
+    expect(patched).toEqual(dedent`
+      # Demo fixture covering strings, arrays and number value kinds
+      title         = "Release plan v2"                 # single-line basic string
+      retry_count   = 12                                # integer
+      error_rate    = 0.5                               # float
+      build_numbers = [1, 2, 3, 5, 8]                   # inline array
+
+      [service]
+      display_name  = "API Gateway"                     # string in table
+      ports         = [8080, 8081, 8082]                # array in table
+      timeout_ms    = 25000                             # number in table
+      ` + '\n');
+  });
+
 describe('should preserve all TOML date/time formats when patching', () => {
   const testCases = [
     {

src/patch.ts

@@ -173,12 +173,7 @@ function preserveFormatting(existing: Value, replacement: Value): void {
     // Update the replacement with the properly formatted date
     replacement.value = formattedDate;
     replacement.raw = formattedDate.toISOString();
-    
-    // Adjust the location information to match the new raw length
-    const lengthDiff = replacement.raw.length - originalRaw.length;
-    if (lengthDiff !== 0) {
-      replacement.loc.end.column = replacement.loc.start.column + replacement.raw.length;
-    }
+    replacement.loc.end.column = replacement.loc.start.column + replacement.raw.length;
   }
 
   // Preserve array trailing comma format