feat: Allow for pathlike aliases, à la *foo/42/bar

Author: eemeli

src/doc/Document.ts

@@ -424,11 +424,14 @@ export class Document<T extends Node = Node> {
       mapAsMap: mapAsMap === true,
       mapKeyWarned: false,
       maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100,
+      resolved: new WeakMap(),
       stringify
     }
     const res = toJS(this.contents, jsonArg ?? '', ctx)
-    if (typeof onAnchor === 'function')
-      for (const { count, res } of ctx.anchors.values()) onAnchor(res, count)
+    if (typeof onAnchor === 'function') {
+      for (const [node, { count }] of ctx.anchors)
+        onAnchor(ctx.resolved.get(node), count)
+    }
     return typeof reviver === 'function'
       ? applyReviver(reviver, { '': res }, '', res)
       : res

src/nodes/Alias.ts

@@ -8,6 +8,7 @@ import {
   isAlias,
   isCollection,
   isPair,
+  isScalar,
   Node,
   NodeBase,
   Range
@@ -24,6 +25,8 @@ export declare namespace Alias {
   }
 }
 
+const RESOLVE = Symbol('_resolve')
+
 export class Alias extends NodeBase {
   source: string
 
@@ -39,46 +42,72 @@ export class Alias extends NodeBase {
     })
   }
 
-  /**
-   * Resolve the value of this alias within `doc`, finding the last
-   * instance of the `source` anchor before this node.
-   */
-  resolve(doc: Document): Scalar | YAMLMap | YAMLSeq | undefined {
+  [RESOLVE](doc: Document) {
     let found: Scalar | YAMLMap | YAMLSeq | undefined = undefined
+    // @ts-expect-error - TS doesn't notice the assignment in the visitor
+    let root: Node & { anchor: string } = undefined
+    const pathLike = this.source.includes('/')
     visit(doc, {
       Node: (_key: unknown, node: Node) => {
         if (node === this) return visit.BREAK
-        if (node.anchor === this.source) found = node
+        const { anchor } = node
+        if (anchor === this.source) {
+          found = node
+        } else if (
+          doc.directives?.yaml.version === 'next' &&
+          anchor &&
+          pathLike &&
+          this.source.startsWith(anchor + '/') &&
+          (!root || root.anchor.length <= anchor.length)
+        ) {
+          root = node as Node & { anchor: string }
+        }
       }
     })
-    return found
+    if (found) return { node: found, root: found }
+
+    if (isCollection(root)) {
+      const parts = this.source.substring(root.anchor.length + 1).split('/')
+      const node = root.getIn(parts, true)
+      if (isCollection(node) || isScalar(node)) return { node, root }
+    }
+
+    return { node: undefined, root }
+  }
+
+  /**
+   * Resolve the value of this alias within `doc`, finding the last
+   * instance of the `source` anchor before this node.
+   */
+  resolve(doc: Document): Scalar | YAMLMap | YAMLSeq | undefined {
+    return this[RESOLVE](doc).node
   }
 
   toJSON(_arg?: unknown, ctx?: ToJSContext) {
     if (!ctx) return { source: this.source }
-    const { anchors, doc, maxAliasCount } = ctx
-    const source = this.resolve(doc)
-    if (!source) {
+    const { anchors, doc, maxAliasCount, resolved } = ctx
+    const { node, root } = this[RESOLVE](doc)
+    if (!node) {
       const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`
       throw new ReferenceError(msg)
     }
-    const data = anchors.get(source)
-    /* istanbul ignore if */
-    if (!data || data.res === undefined) {
-      const msg = 'This should not happen: Alias anchor was not resolved?'
-      throw new ReferenceError(msg)
-    }
+
     if (maxAliasCount >= 0) {
+      const data = anchors.get(root)
+      if (!data) {
+        const msg = 'This should not happen: Alias anchor was not resolved?'
+        throw new ReferenceError(msg)
+      }
       data.count += 1
-      if (data.aliasCount === 0)
-        data.aliasCount = getAliasCount(doc, source, anchors)
+      data.aliasCount ||= getAliasCount(doc, root, anchors)
       if (data.count * data.aliasCount > maxAliasCount) {
         const msg =
           'Excessive alias count indicates a resource exhaustion attack'
         throw new ReferenceError(msg)
       }
     }
-    return data.res
+
+    return resolved.get(node)
   }
 
   toString(
@@ -105,8 +134,8 @@ function getAliasCount(
   anchors: ToJSContext['anchors']
 ): number {
   if (isAlias(node)) {
-    const source = node.resolve(doc)
-    const anchor = anchors && source && anchors.get(source)
+    const { root } = node[RESOLVE](doc)
+    const anchor = root && anchors?.get(root)
     return anchor ? anchor.count * anchor.aliasCount : 0
   } else if (isCollection(node)) {
     let count = 0

src/nodes/toJS.ts

@@ -5,7 +5,6 @@ import { hasAnchor, Node } from './Node.js'
 export interface AnchorData {
   aliasCount: number
   count: number
-  res: unknown
 }
 
 export interface ToJSContext {
@@ -16,6 +15,7 @@ export interface ToJSContext {
   mapKeyWarned: boolean
   maxAliasCount: number
   onCreate?: (res: unknown) => void
+  resolved: WeakMap<Node, unknown>
 
   /** Requiring this directly in Pair would create circular dependencies */
   stringify: typeof stringify
@@ -35,16 +35,17 @@ export function toJS(value: any, arg: string | null, ctx?: ToJSContext): any {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-return
   if (Array.isArray(value)) return value.map((v, i) => toJS(v, String(i), ctx))
   if (value && typeof value.toJSON === 'function') {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-    if (!ctx || !hasAnchor(value)) return value.toJSON(arg, ctx)
-    const data: AnchorData = { aliasCount: 0, count: 1, res: undefined }
-    ctx.anchors.set(value, data)
-    ctx.onCreate = res => {
-      data.res = res
-      delete ctx.onCreate
+    if (ctx) {
+      if (hasAnchor(value)) ctx.anchors.set(value, { aliasCount: 0, count: 1 })
+      ctx.onCreate = res => {
+        ctx.onCreate = undefined
+        ctx.resolved.set(value, res)
+      }
     }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
     const res = value.toJSON(arg, ctx)
-    if (ctx.onCreate) ctx.onCreate(res)
+    if (ctx?.onCreate) ctx.onCreate(res)
     return res
   }
   if (typeof value === 'bigint' && !ctx?.keep) return Number(value)

tests/next.ts

@@ -0,0 +1,55 @@
+import { parse, parseDocument } from 'yaml'
+import { source } from './_utils'
+
+describe('relative-path alias', () => {
+  test('resolves a map value by key', () => {
+    const src = source`
+      - &a { foo: 1 }
+      - *a/foo
+    `
+    expect(parse(src, { version: 'next' })).toEqual([{ foo: 1 }, 1])
+  })
+
+  test('resolves a sequence value by index', () => {
+    const src = source`
+      - &a [ 2, 4, 8 ]
+      - *a/1
+    `
+    expect(parse(src, { version: 'next' })).toEqual([[2, 4, 8], 4])
+  })
+
+  test('resolves a deeper value', () => {
+    const src = source`
+      - &a { foo: [1, 42] }
+      - *a/foo/1
+    `
+    expect(parse(src, { version: 'next' })).toEqual([{ foo: [1, 42] }, 42])
+  })
+
+  test('resolves to an equal value', () => {
+    const src = source`
+      - &a { foo: [42] }
+      - *a/foo
+    `
+    const res = parse(src, { version: 'next' })
+    expect(res[1]).toBe(res[0].foo)
+  })
+
+  test('does not resolve an alias value', () => {
+    const src = source`
+      - &a { foo: *a }
+      - *a/foo
+    `
+    const doc = parseDocument(src, { version: 'next' })
+    expect(() => doc.toJS()).toThrow(ReferenceError)
+  })
+
+  test('does not resolve a later value', () => {
+    const src = source`
+      - *a/foo
+      - &a { foo: 1 }
+    `
+    const doc = parseDocument(src, { version: 'next' })
+    expect(() => doc.toJS()).toThrow(ReferenceError)
+  })
+})