@openrewrite/rewrite 8.69.0-20251211-160325 → 8.69.0-20251212-112414

package/src/yaml/tree.ts

@@ -0,0 +1,281 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {Markers} from "../markers";
+import {SourceFile, Tree} from "../tree";
+
+export interface Yaml extends Tree {
+    readonly prefix: string
+}
+
+export namespace Yaml {
+    export const Kind = {
+        Documents: "org.openrewrite.yaml.tree.Yaml$Documents",
+        Document: "org.openrewrite.yaml.tree.Yaml$Document",
+        DocumentEnd: "org.openrewrite.yaml.tree.Yaml$Document$End",
+        Mapping: "org.openrewrite.yaml.tree.Yaml$Mapping",
+        MappingEntry: "org.openrewrite.yaml.tree.Yaml$Mapping$Entry",
+        Scalar: "org.openrewrite.yaml.tree.Yaml$Scalar",
+        Sequence: "org.openrewrite.yaml.tree.Yaml$Sequence",
+        SequenceEntry: "org.openrewrite.yaml.tree.Yaml$Sequence$Entry",
+        Alias: "org.openrewrite.yaml.tree.Yaml$Alias",
+        Anchor: "org.openrewrite.yaml.tree.Yaml$Anchor",
+        Tag: "org.openrewrite.yaml.tree.Yaml$Tag"
+    } as const;
+
+    export enum ScalarStyle {
+        DOUBLE_QUOTED = "DOUBLE_QUOTED",
+        SINGLE_QUOTED = "SINGLE_QUOTED",
+        LITERAL = "LITERAL",
+        FOLDED = "FOLDED",
+        PLAIN = "PLAIN"
+    }
+
+    export enum TagKind {
+        LOCAL = "LOCAL",
+        IMPLICIT_GLOBAL = "IMPLICIT_GLOBAL",
+        EXPLICIT_GLOBAL = "EXPLICIT_GLOBAL"
+    }
+
+    /**
+     * Either a Scalar or an Alias can be a key in a mapping
+     */
+    export type YamlKey = Scalar | Alias;
+
+    /**
+     * Block types are Scalar, Mapping, Sequence, or Alias
+     */
+    export type Block = Scalar | Mapping | Sequence | Alias;
+
+    /**
+     * A YAML file containing multiple documents
+     */
+    export interface Documents extends SourceFile, Yaml {
+        readonly kind: typeof Kind.Documents;
+        readonly documents: Document[];
+        readonly suffix: string | undefined;
+    }
+
+    /**
+     * A single YAML document within a Documents container
+     */
+    export interface Document extends Yaml {
+        readonly kind: typeof Kind.Document;
+        /**
+         * True if the document explicitly starts with "---"
+         */
+        readonly explicit: boolean;
+        readonly block: Block;
+        readonly end: DocumentEnd;
+    }
+
+    /**
+     * Document end marker. May or may not be explicit ("...")
+     */
+    export interface DocumentEnd extends Yaml {
+        readonly kind: typeof Kind.DocumentEnd;
+        /**
+         * True if the document end is explicitly marked with "..."
+         */
+        readonly explicit: boolean;
+    }
+
+    /**
+     * A scalar value in YAML (string, number, boolean, etc.)
+     */
+    export interface Scalar extends Yaml {
+        readonly kind: typeof Kind.Scalar;
+        readonly style: ScalarStyle;
+        readonly anchor: Anchor | undefined;
+        readonly tag: Tag | undefined;
+        readonly value: string;
+    }
+
+    /**
+     * A YAML mapping (object/dictionary)
+     */
+    export interface Mapping extends Yaml {
+        readonly kind: typeof Kind.Mapping;
+        /**
+         * When non-null, indicates this is an inline mapping and contains the whitespace before '{'
+         */
+        readonly openingBracePrefix: string | undefined;
+        readonly entries: MappingEntry[];
+        /**
+         * When non-null, indicates this is an inline mapping and contains the whitespace before '}'
+         */
+        readonly closingBracePrefix: string | undefined;
+        readonly anchor: Anchor | undefined;
+        readonly tag: Tag | undefined;
+    }
+
+    /**
+     * A single key-value pair in a mapping
+     */
+    export interface MappingEntry extends Yaml {
+        readonly kind: typeof Kind.MappingEntry;
+        readonly key: YamlKey;
+        /**
+         * Whitespace before the mapping value indicator ':'
+         */
+        readonly beforeMappingValueIndicator: string;
+        readonly value: Block;
+    }
+
+    /**
+     * A YAML sequence (array/list)
+     */
+    export interface Sequence extends Yaml {
+        readonly kind: typeof Kind.Sequence;
+        /**
+         * When non-null, indicates this is an inline sequence and contains the whitespace before '['
+         */
+        readonly openingBracketPrefix: string | undefined;
+        readonly entries: SequenceEntry[];
+        /**
+         * When non-null, indicates this is an inline sequence and contains the whitespace before ']'
+         */
+        readonly closingBracketPrefix: string | undefined;
+        readonly anchor: Anchor | undefined;
+        readonly tag: Tag | undefined;
+    }
+
+    /**
+     * A single entry in a sequence
+     */
+    export interface SequenceEntry extends Yaml {
+        readonly kind: typeof Kind.SequenceEntry;
+        readonly block: Block;
+        /**
+         * True when this entry is part of a block sequence (uses '-')
+         * False when this entry is part of an inline sequence (uses '[' and ']')
+         */
+        readonly dash: boolean;
+        /**
+         * When non-null, contains the whitespace before the trailing comma in inline sequences
+         */
+        readonly trailingCommaPrefix: string | undefined;
+    }
+
+    /**
+     * An alias reference to an anchor (*anchorName)
+     */
+    export interface Alias extends Yaml {
+        readonly kind: typeof Kind.Alias;
+        readonly anchor: Anchor;
+    }
+
+    /**
+     * An anchor definition (&anchorName)
+     */
+    export interface Anchor extends Yaml {
+        readonly kind: typeof Kind.Anchor;
+        readonly postfix: string;
+        readonly key: string;
+    }
+
+    /**
+     * A YAML tag (!tag, !!tag, or !<tag>)
+     */
+    export interface Tag extends Yaml {
+        readonly kind: typeof Kind.Tag;
+        readonly name: string;
+        readonly suffix: string;
+        readonly tagKind: TagKind;
+    }
+}
+
+const yamlKindValues = new Set(Object.values(Yaml.Kind));
+
+export function isYaml(tree: any): tree is Yaml {
+    return yamlKindValues.has(tree?.kind);
+}
+
+export function isDocuments(yaml: Yaml): yaml is Yaml.Documents {
+    return yaml.kind === Yaml.Kind.Documents;
+}
+
+export function isDocument(yaml: Yaml): yaml is Yaml.Document {
+    return yaml.kind === Yaml.Kind.Document;
+}
+
+export function isDocumentEnd(yaml: Yaml): yaml is Yaml.DocumentEnd {
+    return yaml.kind === Yaml.Kind.DocumentEnd;
+}
+
+export function isScalar(yaml: Yaml): yaml is Yaml.Scalar {
+    return yaml.kind === Yaml.Kind.Scalar;
+}
+
+export function isMapping(yaml: Yaml): yaml is Yaml.Mapping {
+    return yaml.kind === Yaml.Kind.Mapping;
+}
+
+export function isMappingEntry(yaml: Yaml): yaml is Yaml.MappingEntry {
+    return yaml.kind === Yaml.Kind.MappingEntry;
+}
+
+export function isSequence(yaml: Yaml): yaml is Yaml.Sequence {
+    return yaml.kind === Yaml.Kind.Sequence;
+}
+
+export function isSequenceEntry(yaml: Yaml): yaml is Yaml.SequenceEntry {
+    return yaml.kind === Yaml.Kind.SequenceEntry;
+}
+
+export function isAlias(yaml: Yaml): yaml is Yaml.Alias {
+    return yaml.kind === Yaml.Kind.Alias;
+}
+
+export function isAnchor(yaml: Yaml): yaml is Yaml.Anchor {
+    return yaml.kind === Yaml.Kind.Anchor;
+}
+
+export function isTag(yaml: Yaml): yaml is Yaml.Tag {
+    return yaml.kind === Yaml.Kind.Tag;
+}
+
+export function isBlock(yaml: Yaml): yaml is Yaml.Block {
+    return isScalar(yaml) || isMapping(yaml) || isSequence(yaml) || isAlias(yaml);
+}
+
+export function isYamlKey(yaml: Yaml): yaml is Yaml.YamlKey {
+    return isScalar(yaml) || isAlias(yaml);
+}
+
+/**
+ * Gets the value from a YamlKey (either a Scalar or an Alias)
+ */
+export function getYamlKeyValue(key: Yaml.YamlKey): string {
+    if (isScalar(key)) {
+        return key.value;
+    } else {
+        return key.anchor.key;
+    }
+}
+
+/**
+ * Prints a tag according to its kind
+ */
+export function printTag(tag: Yaml.Tag): string {
+    switch (tag.tagKind) {
+        case Yaml.TagKind.LOCAL:
+            return `!${tag.name}`;
+        case Yaml.TagKind.IMPLICIT_GLOBAL:
+            return `!!${tag.name}`;
+        case Yaml.TagKind.EXPLICIT_GLOBAL:
+            return `!<${tag.name}>`;
+    }
+}

package/src/yaml/visitor.ts

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {mapAsync, updateIfChanged} from "../util";
+import {TreeVisitor} from "../visitor";
+import {SourceFile} from "../tree";
+import {isYaml, Yaml} from "./tree";
+
+export class YamlVisitor<P> extends TreeVisitor<Yaml, P> {
+    async isAcceptable(sourceFile: SourceFile): Promise<boolean> {
+        return isYaml(sourceFile);
+    }
+
+    protected async visitDocuments(documents: Yaml.Documents, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(documents.markers, p),
+            documents: await mapAsync(documents.documents, doc => this.visitDefined(doc, p) as Promise<Yaml.Document>)
+        };
+        return updateIfChanged(documents, updates);
+    }
+
+    protected async visitDocument(document: Yaml.Document, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(document.markers, p),
+            block: await this.visitDefined(document.block, p),
+            end: await this.visitDefined(document.end, p)
+        };
+        return updateIfChanged(document, updates);
+    }
+
+    protected async visitDocumentEnd(end: Yaml.DocumentEnd, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(end.markers, p)
+        };
+        return updateIfChanged(end, updates);
+    }
+
+    protected async visitMapping(mapping: Yaml.Mapping, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(mapping.markers, p),
+            tag: mapping.tag ? await this.visit(mapping.tag, p) : undefined,
+            anchor: mapping.anchor ? await this.visit(mapping.anchor, p) : undefined,
+            entries: await mapAsync(mapping.entries, entry => this.visitDefined(entry, p) as Promise<Yaml.MappingEntry>)
+        };
+        return updateIfChanged(mapping, updates);
+    }
+
+    protected async visitMappingEntry(entry: Yaml.MappingEntry, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(entry.markers, p),
+            key: await this.visitDefined(entry.key, p),
+            value: await this.visitDefined(entry.value, p)
+        };
+        return updateIfChanged(entry, updates);
+    }
+
+    protected async visitScalar(scalar: Yaml.Scalar, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(scalar.markers, p),
+            anchor: scalar.anchor ? await this.visit(scalar.anchor, p) : undefined,
+            tag: scalar.tag ? await this.visit(scalar.tag, p) : undefined
+        };
+        return updateIfChanged(scalar, updates);
+    }
+
+    protected async visitSequence(sequence: Yaml.Sequence, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(sequence.markers, p),
+            tag: sequence.tag ? await this.visit(sequence.tag, p) : undefined,
+            anchor: sequence.anchor ? await this.visit(sequence.anchor, p) : undefined,
+            entries: await mapAsync(sequence.entries, entry => this.visitDefined(entry, p) as Promise<Yaml.SequenceEntry>)
+        };
+        return updateIfChanged(sequence, updates);
+    }
+
+    protected async visitSequenceEntry(entry: Yaml.SequenceEntry, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(entry.markers, p),
+            block: await this.visitDefined(entry.block, p)
+        };
+        return updateIfChanged(entry, updates);
+    }
+
+    protected async visitAnchor(anchor: Yaml.Anchor, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(anchor.markers, p)
+        };
+        return updateIfChanged(anchor, updates);
+    }
+
+    protected async visitAlias(alias: Yaml.Alias, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(alias.markers, p),
+            anchor: await this.visitDefined(alias.anchor, p)
+        };
+        return updateIfChanged(alias, updates);
+    }
+
+    protected async visitTag(tag: Yaml.Tag, p: P): Promise<Yaml | undefined> {
+        const updates: any = {
+            markers: await this.visitMarkers(tag.markers, p)
+        };
+        return updateIfChanged(tag, updates);
+    }
+
+    protected accept(t: Yaml, p: P): Promise<Yaml | undefined> {
+        switch (t.kind) {
+            case Yaml.Kind.Documents:
+                return this.visitDocuments(t as Yaml.Documents, p);
+            case Yaml.Kind.Document:
+                return this.visitDocument(t as Yaml.Document, p);
+            case Yaml.Kind.DocumentEnd:
+                return this.visitDocumentEnd(t as Yaml.DocumentEnd, p);
+            case Yaml.Kind.Mapping:
+                return this.visitMapping(t as Yaml.Mapping, p);
+            case Yaml.Kind.MappingEntry:
+                return this.visitMappingEntry(t as Yaml.MappingEntry, p);
+            case Yaml.Kind.Scalar:
+                return this.visitScalar(t as Yaml.Scalar, p);
+            case Yaml.Kind.Sequence:
+                return this.visitSequence(t as Yaml.Sequence, p);
+            case Yaml.Kind.SequenceEntry:
+                return this.visitSequenceEntry(t as Yaml.SequenceEntry, p);
+            case Yaml.Kind.Anchor:
+                return this.visitAnchor(t as Yaml.Anchor, p);
+            case Yaml.Kind.Alias:
+                return this.visitAlias(t as Yaml.Alias, p);
+            case Yaml.Kind.Tag:
+                return this.visitTag(t as Yaml.Tag, p);
+            default:
+                throw new Error(`Unexpected YAML kind ${(t as any).kind}`);
+        }
+    }
+}