@mcpher/gas-fakes 2.5.2 → 2.5.4

package/src/services/xmlservice/fakedoctype.js

@@ -0,0 +1,68 @@
+import { FakeContent } from './fakecontent.js';
+import * as Enums from '../enums/xmlenums.js';
+
+export class FakeDocType extends FakeContent {
+  constructor(name, publicId = null, systemId = null) {
+    super(Enums.ContentTypes.DOCTYPE);
+    this._name = name || '';
+    this._publicId = publicId || '';
+    this._systemId = systemId || '';
+    this._internalSubset = '';
+    this._parent = null;
+  }
+
+  getElementName() {
+    return this._name;
+  }
+
+  getInternalSubset() {
+    return this._internalSubset;
+  }
+
+  getPublicId() {
+    return this._publicId;
+  }
+
+  getSystemId() {
+    return this._systemId;
+  }
+
+  getValue() {
+    return '';
+  }
+
+  setElementName(name) {
+    this._name = name || '';
+    return this;
+  }
+
+  setInternalSubset(data) {
+    if (data === null || data === undefined) {
+      throw new Error("Argument cannot be null: data");
+    }
+    this._internalSubset = data;
+    return this;
+  }
+
+  setPublicId(id) {
+    this._publicId = id || '';
+    return this;
+  }
+
+  setSystemId(id) {
+    this._systemId = id || '';
+    return this;
+  }
+
+  detach() {
+    return super.detach();
+  }
+
+  getParentElement() {
+    return super.getParentElement();
+  }
+
+  toString() {
+    return `[DocType: ${this._name}]`;
+  }
+}

package/src/services/xmlservice/fakedocument.js

@@ -1,20 +1,117 @@
-/**
- * Fake Document class for XmlService
- */
+import { FakeElement } from './fakeelement.js';
+import { FakeDocType } from './fakedoctype.js';
+
 export class FakeDocument {
-  constructor(rootElement) {
+  constructor(rootElement = null) {
+    this._content = [];
     this._rootElement = rootElement;
+    if (rootElement) {
+      this._content.push(rootElement);
+      if (typeof rootElement.setParentElement === 'function') {
+        rootElement.setParentElement(this);
+      }
+    }
   }
-
-  /**
-   * Returns the root element of the document.
-   * @return {FakeElement} The root element.
-   */
-  getRootElement() {
-    return this._rootElement;
+  getRootElement() { return this._rootElement; }
+  setRootElement(element) {
+    if (this._rootElement) {
+      const idx = this._content.indexOf(this._rootElement);
+      if (idx !== -1) {
+        this._content[idx] = element;
+      }
+      if (typeof this._rootElement.setParentElement === 'function') {
+        this._rootElement.setParentElement(null);
+      }
+    } else {
+      this._content.push(element);
+    }
+    this._rootElement = element;
+    if (element && typeof element.setParentElement === 'function') {
+      element.setParentElement(this);
+    }
+    return this;
+  }
+  hasRootElement() { return !!this._rootElement; }
+  detachRootElement() {
+    const root = this._rootElement;
+    if (root) {
+      const idx = this._content.indexOf(root);
+      if (idx !== -1) this._content.splice(idx, 1);
+      if (typeof root.setParentElement === 'function') {
+        root.setParentElement(null);
+      }
+      this._rootElement = null;
+    }
+    return root;
+  }
+  getDocType() {
+    return this._content.find(c => c instanceof FakeDocType) || null;
+  }
+  setDocType(doctype) {
+    const existing = this.getDocType();
+    if (existing) {
+      const idx = this._content.indexOf(existing);
+      this._content[idx] = doctype;
+    } else {
+      this._content.unshift(doctype);
+    }
+    if (doctype && typeof doctype.setParentElement === 'function') {
+      doctype.setParentElement(this);
+    }
+    return this;
+  }
+  addContent(content, index = null) {
+    if (content instanceof FakeElement) {
+      if (this.hasRootElement()) {
+        throw new Error("XmlService: Document already has a root element");
+      }
+      this._rootElement = content;
+    }
+    if (content && typeof content.setParentElement === 'function') {
+      content.setParentElement(this);
+    }
+    if (index === null) {
+      this._content.push(content);
+    } else {
+      this._content.splice(index, 0, content);
+    }
+    return this;
+  }
+  cloneContent() {
+    return [...this._content];
+  }
+  getAllContent() { return [...this._content]; }
+  getContent(index) { return this._content[index] || null; }
+  getContentSize() { return this._content.length; }
+  getDescendants() {
+    const descendants = [];
+    const traverse = (node) => {
+      descendants.push(node);
+      if (node instanceof FakeElement) {
+        node.getChildren().forEach(child => traverse(child));
+      }
+    };
+    this._content.forEach(c => traverse(c));
+    return descendants;
+  }
+  removeContent(contentOrIndex) {
+    if (typeof contentOrIndex === 'number') {
+      const removed = this._content.splice(contentOrIndex, 1)[0];
+      if (removed === this._rootElement) this._rootElement = null;
+      return removed || null;
+    } else {
+      const idx = this._content.indexOf(contentOrIndex);
+      if (idx !== -1) {
+        this._content.splice(idx, 1);
+        if (contentOrIndex === this._rootElement) this._rootElement = null;
+        return true;
+      }
+      return false;
+    }
   }
-
   toString() {
-    return `[Document:  No DOCTYPE declaration, Root is [Element: <${this._rootElement.getName()}/>]]`;
+    const rootName = this._rootElement ? this._rootElement.getName() : '';
+    const hasDocType = this.getDocType() ? 'has DOCTYPE declaration' : 'No DOCTYPE declaration';
+    return `[Document:  ${hasDocType}, Root is [Element: <${rootName}/>]]`;
   }
 }

package/src/services/xmlservice/fakeelement.js

@@ -1,128 +1,343 @@
+import { FakeAttribute } from './fakeattribute.js';
+import { FakeContent } from './fakecontent.js';
+import { FakeText } from './faketext.js';
+import * as Enums from '../enums/xmlenums.js';
+
 /**
- * Fake Element class for XmlService
+ * Represents a fake XML Element node.
+ * Inherits from FakeContent.
  */
-export class FakeElement {
+export class FakeElement extends FakeContent {
+  /**
+   * @param {string} name - The qualified name (e.g., "ns:tag").
+   * @param {Object} data - Initial data structure (attributes, children, #text).
+   * @param {FakeContent | null} parent - The parent element.
+   */
   constructor(name, data = {}, parent = null) {
+    super(Enums.ContentTypes.ELEMENT);
+    
     const parts = name.split(':');
     this._localName = parts.pop();
     this._prefix = parts.length > 0 ? parts[0] : "";
     this._qualifiedName = name;
-    this._data = data; // This holds children and attributes
+    this._data = data || {};
     this._parent = parent;
+    this._namespace = null;
+    this._content = [];
+    this._contentInitialized = false;
   }
 
-  /**
-   * Returns the local name of the element.
-   * @return {string} The local name of the element.
-   */
+  // --- Core Properties & Getters ---
+
   getName() {
     return this._localName;
   }
 
-  /**
-   * Returns the full qualified name of the element.
-   * (Not part of GAS public API, but useful internally)
-   */
   getQualifiedName() {
     return this._qualifiedName;
   }
 
-  /**
-   * Returns the text content of the element.
-   * @return {string} The text content of the element.
-   */
-  getText() {
-    if (typeof this._data === 'string') return this._data;
+  getNamespace(prefix) {
+    if (prefix === undefined) {
+      return this._namespace;
+    }
+    if (this._namespace && this._namespace.getPrefix() === prefix) {
+      return this._namespace;
+    }
+    return null;
+  }
+
+  setNamespace(namespace) {
+    this._namespace = namespace;
+    return this;
+  }
+
+  setName(name) {
+    this._localName = name;
+    this._qualifiedName = this._prefix ? `${this._prefix}:${name}` : name;
+    return this;
+  }
+
+  // --- Lazy Content Loader ---
+
+  _ensureContent() {
+    if (this._contentInitialized) return;
+    this._contentInitialized = true;
+    this._content = [];
+    if (!this._data || typeof this._data !== 'object') return;
+
+    // Load text if present
+    if (this._data['#text']) {
+      const textNode = new FakeText(this._data['#text']);
+      textNode.setParentElement(this);
+      this._content.push(textNode);
+    }
+
+    // Load child elements
+    Object.keys(this._data).forEach(key => {
+      if (key.startsWith('@_') || key === '#text') return;
+      const childData = this._data[key];
+      if (Array.isArray(childData)) {
+        childData.forEach(d => {
+          const childEl = new FakeElement(key, d, this);
+          this._content.push(childEl);
+        });
+      } else {
+        const childEl = new FakeElement(key, childData, this);
+        this._content.push(childEl);
+      }
+    });
+  }
+
+  _syncData() {
+    const attrs = {};
     if (this._data && typeof this._data === 'object') {
-      // fast-xml-parser with alwaysCreateTextNode: true puts text in #text
-      return this._data['#text'] || '';
+      Object.keys(this._data).forEach(key => {
+        if (key.startsWith('@_')) {
+          attrs[key] = this._data[key];
+        }
+      });
     }
-    return '';
+    this._data = attrs;
+
+    this._content.forEach(c => {
+      if (c instanceof FakeElement) {
+        const key = c.getQualifiedName();
+        if (!this._data[key]) {
+          this._data[key] = c._data;
+        } else if (Array.isArray(this._data[key])) {
+          this._data[key].push(c._data);
+        } else {
+          this._data[key] = [this._data[key], c._data];
+        }
+      } else {
+        const textVal = c.getText ? c.getText() : (c.getValue ? c.getValue() : "");
+        if (!this._data['#text']) {
+          this._data['#text'] = textVal;
+        } else {
+          this._data['#text'] += textVal;
+        }
+      }
+    });
+  }
+
+  // --- Content Accessors ---
+
+  getText() {
+    this._ensureContent();
+    return this._content
+      .filter(c => c.getType() === Enums.ContentTypes.TEXT || c.getType() === Enums.ContentTypes.CDATA)
+      .map(c => c.getValue())
+      .join('');
   }
 
-  /**
-   * Returns the value of the element.
-   * @return {string} The value of the element.
-   */
   getValue() {
     return this.getText();
   }
 
-  /**
-   * Returns the first child element with the given name.
-   * @param {string} name The name of the child element.
-   * @param {FakeNamespace} namespace Optional namespace.
-   * @return {FakeElement} The child element, or null if not found.
-   */
+  // --- Child/Descendant Navigation ---
+
   getChild(name, namespace) {
     const children = this.getChildren(name, namespace);
     return children.length > 0 ? children[0] : null;
   }
 
-  /**
-   * Returns all child elements.
-   * @param {string} name Optional name of the child elements.
-   * @param {FakeNamespace} namespace Optional namespace.
-   * @return {FakeElement[]} The child elements.
-   */
   getChildren(name, namespace) {
+    this._ensureContent();
+    let result = this._content.filter(c => c instanceof FakeElement);
+    if (name) {
+      let targetKey = name;
+      if (namespace) {
+        const prefix = namespace.getPrefix();
+        targetKey = prefix ? `${prefix}:${name}` : name;
+      }
+      result = result.filter(c => c.getQualifiedName() === targetKey);
+    }
+    return result;
+  }
+
+  getChildText(name, namespace) {
+    const child = this.getChild(name, namespace);
+    return child ? child.getText() : '';
+  }
+
+  getDescendants() {
+    this._ensureContent();
+    const descendants = [];
+    const traverse = (node) => {
+      descendants.push(node);
+      if (node instanceof FakeElement) {
+        node._ensureContent();
+        node._content.forEach(child => traverse(child));
+      }
+    };
+    this._content.forEach(c => traverse(c));
+    return descendants;
+  }
+
+  // --- Attribute Management ---
+
+  getAttribute(name, namespace = null) {
+    if (!this._data || typeof this._data !== 'object') return null;
+    const attrValue = this._data[`@_${name}`];
+    if (attrValue === undefined) return null;
+    return new FakeAttribute(name, String(attrValue), namespace);
+  }
+
+  getAttributes() {
     if (!this._data || typeof this._data !== 'object') return [];
+    return Object.keys(this._data)
+      .filter(key => key.startsWith('@_'))
+      .map(key => {
+        const name = key.slice(2);
+        return new FakeAttribute(name, String(this._data[key]));
+      });
+  }
 
-    // Determine the target key to look for
-    let targetKey = name;
-    if (name && namespace) {
-      const prefix = namespace.getPrefix();
-      targetKey = prefix ? `${prefix}:${name}` : name;
-    } else if (name && name.includes(':')) {
-      // If user passed "ns:child", it might work in our fake even if not in GAS
-      targetKey = name;
+  setAttribute(name, value, namespace = null) {
+    if (typeof name === 'object') {
+      const attr = name;
+      this._data[`@_${attr.getName()}`] = String(attr.getValue());
+    } else {
+      this._data[`@_${name}`] = String(value);
     }
+    return this;
+  }
 
-    if (targetKey) {
-      const childData = this._data[targetKey];
-      if (!childData) return [];
-      if (Array.isArray(childData)) {
-        return childData.map(d => new FakeElement(targetKey, d, this));
+  removeAttribute(name, namespace = null) {
+    const key = typeof name === 'object' ? `@_${name.getName()}` : `@_${name}`;
+    if (this._data && this._data[key] !== undefined) {
+      delete this._data[key];
+      return true;
+    }
+    return false;
+  }
+
+  // --- Text Content Management ---
+
+  setText(text) {
+    this._ensureContent();
+    this._content = this._content.filter(c => c.getType() !== Enums.ContentTypes.TEXT && c.getType() !== Enums.ContentTypes.CDATA);
+    const textNode = new FakeText(text);
+    textNode.setParentElement(this);
+    this._content.push(textNode);
+    this._syncData();
+    return this;
+  }
+
+  // --- Parent/Structure Management ---
+
+  setParentElement(parent) {
+    this._parent = parent;
+  }
+
+  getParentElement() {
+    return this._parent;
+  }
+
+  isRootElement() {
+    return this._parent === null;
+  }
+
+  isAncestorOf(element) {
+    let current = element.getParentElement();
+    while (current) {
+      if (current === this) return true;
+      current = current.getParentElement();
+    }
+    return false;
+  }
+
+  getDocument() {
+    let current = this;
+    while (current._parent) {
+      if (current._parent.constructor && current._parent.constructor.name === 'FakeDocument') {
+        return current._parent;
       }
-      return [new FakeElement(targetKey, childData, this)];
+      current = current._parent;
     }
+    return null;
+  }
 
-    // Return all children (non-attribute keys and not #text)
-    return Object.keys(this._data)
-      .filter(key => !key.startsWith('@_') && key !== '#text')
-      .flatMap(key => {
-        const d = this._data[key];
-        if (Array.isArray(d)) {
-          return d.map(item => new FakeElement(key, item, this));
-        }
-        return new FakeElement(key, d, this);
-      });
+  detach() {
+    return super.detach();
   }
 
-  /**
-   * Returns the attribute with the given name.
-   * @param {string} name The name of the attribute.
-   * @return {object} An object with a getValue() method.
-   */
-  getAttribute(name) {
-    if (!this._data || typeof this._data !== 'object') return null;
-    const attrValue = this._data[`@_${name}`];
-    if (attrValue === undefined) return null;
-    return {
-      getName: () => name,
-      getValue: () => String(attrValue)
-    };
+  // --- Content Manipulation ---
+
+  addChild(element) {
+    return this.addContent(element);
   }
 
-  /**
-   * Returns the text content of the first child element with the given name.
-   * @param {string} name The name of the child element.
-   * @param {FakeNamespace} namespace Optional namespace.
-   * @return {string} The text content, or empty string if not found.
-   */
-  getChildText(name, namespace) {
-    const child = this.getChild(name, namespace);
-    return child ? child.getText() : '';
+  addContent(content, index = null) {
+    this._ensureContent();
+    if (typeof content.setParentElement === 'function') {
+      content.setParentElement(this);
+    }
+    if (index === null) {
+      this._content.push(content);
+    } else {
+      this._content.splice(index, 0, content);
+    }
+    this._syncData();
+    return this;
+  }
+
+  removeContent(contentOrIndex) {
+    this._ensureContent();
+    if (contentOrIndex === undefined) {
+      const old = [...this._content];
+      this._content = [];
+      this._syncData();
+      return old;
+    }
+    if (typeof contentOrIndex === 'number') {
+      const removed = this._content.splice(contentOrIndex, 1)[0];
+      if (removed) {
+        removed.setParentElement(null);
+        this._syncData();
+      }
+      return removed || null;
+    } else {
+      const idx = this._content.indexOf(contentOrIndex);
+      if (idx !== -1) {
+        this._content.splice(idx, 1);
+        contentOrIndex.setParentElement(null);
+        this._syncData();
+        return true;
+      }
+      return false;
+    }
+  }
+
+  cloneContent() {
+    this._ensureContent();
+    return this._content.map(c => {
+      if (c instanceof FakeElement) {
+        return new FakeElement(c.getQualifiedName(), JSON.parse(JSON.stringify(c._data)));
+      } else if (c.getType) {
+        const text = c.getText ? c.getText() : (c.getValue ? c.getValue() : "");
+        if (c.asCdata()) return new FakeCdata(text);
+        if (c.asComment()) return new FakeComment(text);
+        if (c.asText()) return new FakeText(text);
+      }
+      return c;
+    });
+  }
+
+  getAllContent() {
+    this._ensureContent();
+    return [...this._content];
+  }
+
+  getContent(index) {
+    this._ensureContent();
+    return this._content[index] || null;
+  }
+
+  getContentSize() {
+    this._ensureContent();
+    return this._content.length;
   }
 
   toString() {

package/src/services/xmlservice/fakeentityref.js

@@ -0,0 +1,54 @@
+import { FakeContent } from './fakecontent.js';
+import * as Enums from '../enums/xmlenums.js';
+
+export class FakeEntityRef extends FakeContent {
+  constructor(name = '', publicId = null, systemId = null) {
+    super(Enums.ContentTypes.ENTITYREF);
+    this._name = name;
+    this._publicId = publicId;
+    this._systemId = systemId;
+  }
+
+  getName() {
+    return this._name;
+  }
+
+  setName(name) {
+    this._name = name;
+    return this;
+  }
+
+  getPublicId() {
+    return this._publicId;
+  }
+
+  setPublicId(id) {
+    this._publicId = id;
+    return this;
+  }
+
+  getSystemId() {
+    return this._systemId;
+  }
+
+  setSystemId(id) {
+    this._systemId = id;
+    return this;
+  }
+
+  getValue() {
+    return '';
+  }
+
+  detach() {
+    return super.detach();
+  }
+
+  getParentElement() {
+    return super.getParentElement();
+  }
+
+  toString() {
+    return `[EntityRef: &${this._name};]`;
+  }
+}