Access.hx

/*
 * Copyright (C)2005-2019 Haxe Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

package haxe.xml;

private abstract NodeAccess(Xml) from Xml {
	@:op(a.b)
	public function resolve(name:String):Access {
		var x = this.elementsNamed(name).next();
		if (x == null) {
			var xname = if (this.nodeType == Xml.Document) "Document" else this.nodeName;
			throw xname + " is missing element " + name;
		}
		return new Access(x);
	}
}

private abstract AttribAccess(Xml) from Xml {
	@:op(a.b)
	public function resolve(name:String):String {
		if (this.nodeType == Xml.Document)
			throw "Cannot access document attribute " + name;
		var v = this.get(name);
		if (v == null)
			throw this.nodeName + " is missing attribute " + name;
		return v;
	}

	@:op(a.b)
	function _hx_set(name:String, value:String):String {
		if (this.nodeType == Xml.Document)
			throw "Cannot access document attribute " + name;
		this.set(name, value);
		return value;
	}
}

private abstract HasAttribAccess(Xml) from Xml {
	@:op(a.b)
	public function resolve(name:String):Bool {
		if (this.nodeType == Xml.Document)
			throw "Cannot access document attribute " + name;
		return this.exists(name);
	}
}

private abstract HasNodeAccess(Xml) from Xml {
	@:op(a.b)
	public function resolve(name:String):Bool {
		return this.elementsNamed(name).hasNext();
	}
}

private abstract NodeListAccess(Xml) from Xml {
	@:op(a.b)
	public function resolve(name:String):Array<Access> {
		var l = [];
		for (x in this.elementsNamed(name))
			l.push(new Access(x));
		return l;
	}
}

/**
	The `haxe.xml.Access` API helps providing a fast dot-syntax access to the
	most common `Xml` methods.
**/
abstract Access(Xml) {
	public var x(get, never):Xml;

	public inline function get_x()
		return this;

	/**
		The name of the current element. This is the same as `Xml.nodeName`.
	**/
	public var name(get, never):String;

	inline function get_name() {
		return if (this.nodeType == Xml.Document) "Document" else this.nodeName;
	}

	/**
		The inner PCDATA or CDATA of the node.

		An exception is thrown if there is no data or if there not only data
		but also other nodes.
	**/
	public var innerData(get, never):String;

	/**
		The XML string built with all the sub nodes, excluding the current one.
	**/
	public var innerHTML(get, never):String;

	/**
		Access to the first sub element with the given name.

		An exception is thrown if the element doesn't exists.
		Use `hasNode` to check the existence of a node.

		```haxe
		var access = new haxe.xml.Access(Xml.parse("<user><name>John</name></user>"));
		var user = access.node.user;
		var name = user.node.name;
		trace(name.innerData); // John

		// Uncaught Error: Document is missing element password
		var password = user.node.password;
		```
	**/
	public var node(get, never):NodeAccess;

	inline function get_node():NodeAccess
		return x;

	/**
		Access to the List of elements with the given name.
		```haxe
		var fast = new haxe.xml.Access(Xml.parse("
			<users>
				<user name='John'/>
				<user name='Andy'/>
				<user name='Dan'/>
			</users>"
		));

		var users = fast.node.users;
		for (user in users.nodes.user) {
			trace(user.att.name);
		}
		```
	**/
	public var nodes(get, never):NodeListAccess;

	inline function get_nodes():NodeListAccess
		return this;

	/**
		Access to a given attribute.

		An exception is thrown if the attribute doesn't exists.
		Use `has` to check the existence of an attribute.

		```haxe
		var f = new haxe.xml.Access(Xml.parse("<user name='Mark'></user>"));
		var user = f.node.user;
		if (user.has.name) {
			trace(user.att.name); // Mark
		}
		```
	**/
	public var att(get, never):AttribAccess;

	inline function get_att():AttribAccess
		return this;

	/**
		Check the existence of an attribute with the given name.
	**/
	public var has(get, never):HasAttribAccess;

	inline function get_has():HasAttribAccess
		return this;

	/**
		Check the existence of a sub node with the given name.

		```haxe
		var f = new haxe.xml.Access(Xml.parse("<user><age>31</age></user>"));
		var user = f.node.user;
		if (user.hasNode.age) {
			trace(user.node.age.innerData); // 31
		}
		```
	**/
	public var hasNode(get, never):HasNodeAccess;

	inline function get_hasNode():HasNodeAccess
		return x;

	/**
		The list of all sub-elements which are the nodes with type `Xml.Element`.
	**/
	public var elements(get, never):Iterator<Access>;

	inline function get_elements():Iterator<Access>
		return cast this.elements();

	public inline function new(x:Xml) {
		if (x.nodeType != Xml.Document && x.nodeType != Xml.Element)
			throw "Invalid nodeType " + x.nodeType;
		this = x;
	}

	function get_innerData() {
		var it = this.iterator();
		if (!it.hasNext())
			throw name + " does not have data";
		var v = it.next();
		if (it.hasNext()) {
			var n = it.next();
			// handle <spaces>CDATA<spaces>
			if (v.nodeType == Xml.PCData && n.nodeType == Xml.CData && StringTools.trim(v.nodeValue) == "") {
				if (!it.hasNext())
					return n.nodeValue;
				var n2 = it.next();
				if (n2.nodeType == Xml.PCData && StringTools.trim(n2.nodeValue) == "" && !it.hasNext())
					return n.nodeValue;
			}
			throw name + " does not only have data";
		}
		if (v.nodeType != Xml.PCData && v.nodeType != Xml.CData)
			throw name + " does not have data";
		return v.nodeValue;
	}

	function get_innerHTML() {
		var s = new StringBuf();
		for (x in this)
			s.add(x.toString());
		return s.toString();
	}
}