Add keepIndentStep option to parse

Author: yjp20

docs-slate

@@ -116,6 +116,12 @@ export function resolveBlockMap(
       offset = valueNode.range![2]
       const pair = new Pair(keyNode, valueNode)
       if (ctx.options.keepSourceTokens) pair.srcToken = collItem
+      if (ctx.options.keepIndentStep) {
+        pair.indentStep =
+          valueProps.hasNewline && value && 'indent' in value
+            ? ' '.repeat(value.indent - bm.indent)
+            : ''
+      }
       map.items.push(pair)
     } else {
       // key with no value

src/compose/resolve-block-map.ts

@@ -229,4 +229,4 @@ export function resolveFlowCollection(
   }
 
   return coll
-}
+}

src/compose/resolve-flow-collection.ts

@@ -18,6 +18,14 @@ export class Pair<
   /** The CST token that was composed into this pair.  */
   declare srcToken?: CollectionItem
 
+  /**
+   * The indentStep between the key and the value.
+   *
+   * If the value is in flow / on the same line as the key,
+   * the indentStep will be an empty string.
+   */
+  indentStep?: string
+
   constructor(key: NodeOf<K>, value: NodeOf<V> | null = null) {
     this.key = key
     this.value = value
@@ -46,4 +54,4 @@ export class Pair<
       ? stringifyPair(this, ctx, onComment, onChompKeep)
       : JSON.stringify(this)
   }
-}
+}

src/nodes/Pair.ts

@@ -68,6 +68,17 @@ export type ParseOptions = {
    * Default: `true`
    */
   uniqueKeys?: boolean | ((a: Node, b: Node) => boolean)
+
+  /**
+   * Include a `indentStep` value on each parsed `Pair`.
+   *
+   * This helps keep the original indentation and formatting after making
+   * transformations to the document. Currently, this only adds formatting
+   * information to Pairs found in block maps.
+   *
+   * Default: `false`
+   */
+  keepIndentStep?: boolean
 }
 
 export type DocumentOptions = {

src/options.ts

@@ -168,4 +168,4 @@ export function stringify(
   return node instanceof Scalar || str[0] === '{' || str[0] === '['
     ? `${props} ${str}`
     : `${props}\n${ctx.indent}${str}`
-}
+}

src/stringify/stringify.ts

@@ -7,17 +7,21 @@ import { stringify } from './stringify.ts'
 import { indentComment, lineComment } from './stringifyComment.ts'
 
 export function stringifyPair(
-  { key, value }: Readonly<Pair>,
+  { key, value, indentStep }: Readonly<Pair>,
   ctx: StringifyContext,
   onComment?: () => void,
   onChompKeep?: () => void
 ): string {
   const {
     indent,
-    indentStep,
     noValues,
     options: { commentString, indentSeq, simpleKeys }
   } = ctx
+
+  // Use the indentStep that is on the Node by default,
+  // since that is preserved from the original document.
+  indentStep ??= ctx.indentStep
+
   if (simpleKeys) {
     if (key.comment) {
       throw new Error('With simple keys, key nodes cannot have comments')
@@ -153,7 +157,8 @@ export function stringifyPair(
         }
         if (sp0 === -1 || nl0 < sp0) hasPropsLine = true
       }
-      if (!hasPropsLine) ws = `\n${ctx.indent}`
+      if (!hasPropsLine && (indentStep.length > 0 || !value.flow))
+        ws = `\n${ctx.indent}`
     }
   } else if (valueStr === '' || valueStr[0] === '\n') {
     ws = ''
@@ -169,4 +174,4 @@ export function stringifyPair(
   }
 
   return str
-}
+}

src/stringify/stringifyPair.ts

@@ -1036,6 +1036,179 @@ describe('custom indent', () => {
   })
 })
 
+describe('keepIndentStep: true', () => {
+  test('keep object indentation', () => {
+    const src = source`
+      key:
+              super: indented
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('keep array indentation', () => {
+    const src = source`
+      key:
+      - name: foo
+      - name: bar
+      - name: bam
+      - name: baz
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('keep complex indentation', () => {
+    const src = source`
+      key:
+              super:
+              - name: foo
+              - name: bar
+              - name: bam
+              - name: baz
+                metadata:
+                    foo: why
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('handles multiline seq flow on same line', () => {
+    const src = source`
+      key: [
+        aaaaaaaa,
+        bbbbbbbb,
+        cccccccc,
+        dddddddd,
+        eeeeeeee,
+        ffffffff,
+        gggggggg,
+        hhhhhhhh
+      ]
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+  test('handles multiline flow on same line', () => {
+    const src = source`
+      key: !tag {
+        one: aaaaaaaa,
+        two: bbbbbbbb,
+        three: cccccccc,
+        four: dddddddd,
+        five: eeeeeeee
+      }
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('handles multiline flow on next line', () => {
+    const src = source`
+      key:
+           !tag {
+             one: aaaaaaaa,
+             two: bbbbbbbb,
+             three: cccccccc,
+             four: dddddddd,
+             five: eeeeeeee
+           }
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('handles multiline flow on next line', () => {
+    const src = source`
+      key:
+           !tag {
+             one: aaaaaaaa,
+             two: bbbbbbbb,
+             three: cccccccc,
+             four: dddddddd,
+             five: eeeeeeee
+           }
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('handles explicit key map with no indent', () => {
+    const src = source`
+      foo:
+        ? [ key ]
+        : !tag
+        - foo
+        - bar
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('handles explicit key map with indent', () => {
+    const src = source`
+      foo:
+          ? [ key ]
+          : !tag
+                - foo
+                - bar
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('comment after key, value on next line', () => {
+    const src = source`
+      key: # comment
+             value: indented
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(
+      source`
+        key:
+               # comment
+               value: indented
+      `
+    )
+  })
+
+  test('comment on value line', () => {
+    const src = source`
+      key:
+              value: indented # comment
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('comment before nested key at value indent level', () => {
+    const src = source`
+      key:
+              # comment
+              super: indented
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    expect(doc.toString()).toBe(src)
+  })
+
+  test('nesting parsed node under a new key preserves inner indentation', () => {
+    const src = source`
+      a:
+            b: 1
+            c: 2
+    `
+    const doc = YAML.parseDocument(src, { keepIndentStep: true })
+    const wrapper = YAML.parseDocument('outer: null')
+    wrapper.set('outer', doc.value)
+    expect(wrapper.toString()).toBe(source`
+      outer:
+        a:
+              b: 1
+              c: 2
+    `)
+  })
+})
+
 describe('indentSeq: false', () => {
   let obj: unknown
   beforeEach(() => {