First go at wrapping map

Author: langsamu

src/TermWrapper.ts

@@ -2,6 +2,7 @@ import type { DataFactory, DatasetCore, Quad_Object, Quad_Subject, Term } from "
 import type { ITermMapping } from "./type/ITermMapping.js"
 import type { IValueMapping } from "./type/IValueMapping.js"
 import { WrappingSet } from "./WrappingSet.js"
+import { WrappingMap } from "./WrappingMap.js"
 
 
 export class TermWrapper {
@@ -92,6 +93,10 @@ export class TermWrapper {
         return new WrappingSet(this, p, valueMapping, termMapping)
     }
 
+    protected map<TKey, TValue>(p: string, valueMapping: IValueMapping<[TKey, TValue]>, termMapping: ITermMapping<[TKey, TValue]>): Map<TKey, TValue> {
+        return new WrappingMap(this, p, valueMapping, termMapping)
+    }
+
     private static isQuadSubject(term: Term): term is Quad_Subject {
         return ["NamedNode", "BlankNode", "Quad", "Variable"].includes(term.termType)
     }

src/WrappingMap.ts

@@ -0,0 +1,114 @@
+import { TermWrapper } from "./TermWrapper.js"
+import type { IValueMapping } from "./type/IValueMapping.js"
+import type { ITermMapping } from "./type/ITermMapping.js"
+import type { Quad, Quad_Object, Quad_Subject } from "@rdfjs/types"
+
+export class WrappingMap<TKey, TValue> implements Map<TKey, TValue> {
+    constructor(private readonly subject: TermWrapper, private readonly predicate: string, private readonly valueMapping: IValueMapping<[TKey, TValue]>, private readonly termMapping: ITermMapping<[TKey, TValue]>) {
+    }
+
+    clear(): void {
+        for (const q of this.matches) {
+            this.subject.dataset.delete(q)
+        }
+    }
+
+    delete(k: TKey): boolean {
+        const p = this.subject.factory.namedNode(this.predicate)
+
+        for (const entry of this) {
+            if (entry[0] !== k) {
+                continue
+            }
+
+            this.subject.dataset.delete(
+                this.subject.factory.quad(
+                    this.subject.term as Quad_Subject,
+                    p,
+                    this.termMapping(entry, this.subject.dataset, this.subject.factory)!.term as Quad_Object))
+
+            return true
+        }
+
+        return false
+    }
+
+    forEach(callback: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void, thisArg?: any): void {
+        for (const [key, value] of this) {
+            callback.call(thisArg, value, key, this)
+        }
+    }
+
+    get(k: TKey): TValue | undefined {
+        for (const [key, value] of this) {
+            if (key !== k) {
+                continue
+            }
+
+            return value
+        }
+
+        return undefined
+    }
+
+    has(k: TKey): boolean {
+        return this.get(k) !== undefined
+    }
+
+    set(k: TKey, v: TValue): this {
+        this.delete(k)
+        this.add(k, v)
+
+        return this
+    }
+
+    get size(): number {
+        return [...this.matches].length
+    }
+
+    set size(_: number) {
+        throw new Error("not supported")
+    }
+
+    * entries(): MapIterator<[TKey, TValue]> {
+        for (const quad of this.matches) {
+            yield this.valueMapping(new TermWrapper(quad.object, this.subject.dataset, this.subject.factory))
+        }
+    }
+
+    * keys(): MapIterator<TKey> {
+        for (const [key,] of this) {
+            yield key
+        }
+    }
+
+    * values(): MapIterator<TValue> {
+        for (const [, value] of this) {
+            yield value
+        }
+    }
+
+    [Symbol.iterator](): MapIterator<[TKey, TValue]> {
+        return this.entries()
+    }
+
+    get [Symbol.toStringTag](): string {
+        return "WrappingMap"
+    }
+
+    private get matches(): Iterable<Quad> {
+        const p = this.subject.factory.namedNode(this.predicate)
+
+        return this.subject.dataset.match(this.subject.term, p)
+    }
+
+    private add(k: TKey, v: TValue) {
+        const p = this.subject.factory.namedNode(this.predicate)
+
+        this.subject.dataset.add(
+            this.subject.factory.quad(
+                this.subject.term as Quad_Subject,
+                p,
+                this.termMapping([k, v], this.subject.dataset, this.subject.factory)!.term as Quad_Object))
+    }
+}

test/unit/wrapping_map.test.ts

@@ -0,0 +1,132 @@
+import { describe, it } from "node:test"
+import { TermWrapper } from "rdfjs-wrapper"
+import { DataFactory, Literal } from "n3"
+import { datasetFromRdf } from "./util/datasetFromRdf.js"
+import assert from "node:assert"
+
+class Wrapper extends TermWrapper {
+    public get dict(): Map<string, string> {
+        return this.map(
+            "p",
+            ({term}) => [
+                (term as Literal).language,
+                (term as Literal).value
+            ],
+            ([key, value], dataset, factory) =>
+                new TermWrapper(factory.literal(value, key), dataset, factory)
+        )
+    }
+}
+
+describe("Wrapping map", () => {
+    describe("size", () => {
+        it("get", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@hu, "o3"@he .`
+            const wrapper = new Wrapper("s", datasetFromRdf(rdf), DataFactory)
+
+            assert.strictEqual(wrapper.dict.size, 3)
+        })
+        it("set not supported", () => {
+            const rdf = `<s> <p> <o> .`
+            const wrapper = new Wrapper("s", datasetFromRdf(rdf), DataFactory)
+
+            assert.throws(() => {
+                (wrapper.dict as any)["size"] = undefined!
+            }, /^Error: not supported$/)
+        })
+    })
+
+    describe("general", () => {
+        it("get", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const wrapper = new Wrapper("s", datasetFromRdf(rdf), DataFactory)
+
+            assert.strictEqual(wrapper.dict.get("en"), "o1")
+            assert.strictEqual(wrapper.dict.get("fr"), "o2")
+        })
+        it("clear", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            wrapper.dict.clear()
+
+            assert.strictEqual(dataset.size, 0)
+        })
+        it("delete reports positive", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            assert.strictEqual(wrapper.dict.delete("en"), true)
+        })
+        it("delete reports negative", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            assert.strictEqual(wrapper.dict.delete("XX"), false)
+        })
+        it("delete deletes", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            wrapper.dict.delete("en")
+
+            assert.strictEqual(wrapper.dict.has("en"), false)
+        })
+        it("delete reports negative", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            wrapper.dict.delete("XX")
+
+            assert.strictEqual(wrapper.dict.has("en"), true)
+            assert.strictEqual(wrapper.dict.has("fr"), true)
+        })
+        it("forEach", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            const actual = {} as any
+            wrapper.dict.forEach((value, key) => {
+                actual[key] = value
+            })
+
+            assert.deepStrictEqual(actual, {en: "o1", fr: "o2"})
+        })
+        it("set", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            wrapper.dict.set("en", "ox")
+
+            assert.deepStrictEqual(wrapper.dict.get("en"), "ox")
+        })
+        it("keys", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            assert.deepStrictEqual([...wrapper.dict.keys()], ["en", "fr"])
+        })
+        it("values", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            assert.deepStrictEqual([...wrapper.dict.values()], ["o1", "o2"])
+        })
+        it("toStringTag", () => {
+            const rdf = `<s> <p> "o1"@en, "o2"@fr .`
+            const dataset = datasetFromRdf(rdf)
+            const wrapper = new Wrapper("s", dataset, DataFactory)
+
+            assert.strictEqual(wrapper.dict.toString(), "[object WrappingMap]")
+        })
+    })
+})