aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/sdlang/ast.d
diff options
context:
space:
mode:
authorRalph Amissah <ralph@amissah.com>2016-10-01 13:54:14 -0400
committerRalph Amissah <ralph@amissah.com>2019-04-10 15:14:13 -0400
commit1cc6a04b8bce82fa83b62d919bf8bdf14cad0b92 (patch)
treed8c44fa4acb7f588640b2be4117e26bbb864221c /src/sdlang/ast.d
parentheader, body split a more reliable regex solution (diff)
update sdlang, start looking to using dub remote dependenciesdoc-reform_v0.0.6
Diffstat (limited to 'src/sdlang/ast.d')
-rw-r--r--src/sdlang/ast.d1275
1 files changed, 1193 insertions, 82 deletions
diff --git a/src/sdlang/ast.d b/src/sdlang/ast.d
index 7ad1c30..87dd0bd 100644
--- a/src/sdlang/ast.d
+++ b/src/sdlang/ast.d
@@ -9,13 +9,6 @@ import std.conv;
import std.range;
import std.string;
-version(sdlangUnittest)
-version(unittest)
-{
- import std.stdio;
- import std.exception;
-}
-
import sdlang.exception;
import sdlang.token;
import sdlang.util;
@@ -27,7 +20,7 @@ class Attribute
private Tag _parent;
/// Get parent tag. To set a parent, attach this Attribute to its intended
- /// parent tag by calling 'Tag.add(...)', or by passing it to
+ /// parent tag by calling `Tag.add(...)`, or by passing it to
/// the parent tag's constructor.
@property Tag parent()
{
@@ -35,11 +28,20 @@ class Attribute
}
private string _namespace;
+ /++
+ This tag's namespace. Empty string if no namespace.
+
+ Note that setting this value is O(n) because internal lookup structures
+ need to be updated.
+
+ Note also, that setting this may change where this tag is ordered among
+ its parent's list of tags.
+ +/
@property string namespace()
{
return _namespace;
}
- /// Not particularly efficient, but it works.
+ ///ditto
@property void namespace(string value)
{
if(_parent && _namespace != value)
@@ -61,12 +63,22 @@ class Attribute
}
private string _name;
- /// Not including namespace. Use 'fullName' if you want the namespace included.
+ /++
+ This attribute's name, not including namespace.
+
+ Use `getFullName().toString` if you want the namespace included.
+
+ Note that setting this value is O(n) because internal lookup structures
+ need to be updated.
+
+ Note also, that setting this may change where this attribute is ordered
+ among its parent's list of tags.
+ +/
@property string name()
{
return _name;
}
- /// Not the most efficient, but it works.
+ ///ditto
@property void name(string value)
{
if(_parent && _name != value)
@@ -96,9 +108,17 @@ class Attribute
_name = value;
}
+ /// This tag's name, including namespace if one exists.
+ deprecated("Use 'getFullName().toString()'")
@property string fullName()
{
- return _namespace==""? _name : text(_namespace, ":", _name);
+ return getFullName().toString();
+ }
+
+ /// This tag's name, including namespace if one exists.
+ FullName getFullName()
+ {
+ return FullName(_namespace, _name);
}
this(string namespace, string name, Value value, Location location = Location(0, 0, 0))
@@ -117,7 +137,14 @@ class Attribute
this.value = value;
}
- /// Removes 'this' from its parent, if any. Returns 'this' for chaining.
+ /// Copy this Attribute.
+ /// The clone does $(B $(I not)) have a parent, even if the original does.
+ Attribute clone()
+ {
+ return new Attribute(_namespace, _name, value, location);
+ }
+
+ /// Removes `this` from its parent, if any. Returns `this` for chaining.
/// Inefficient ATM, but it works.
Attribute remove()
{
@@ -190,14 +217,31 @@ class Attribute
}
}
+/// Deep-copy an array of Tag or Attribute.
+/// The top-level clones are $(B $(I not)) attached to any parent, even if the originals are.
+T[] clone(T)(T[] arr) if(is(T==Tag) || is(T==Attribute))
+{
+ T[] newArr;
+ newArr.length = arr.length;
+
+ foreach(i; 0..arr.length)
+ newArr[i] = arr[i].clone();
+
+ return newArr;
+}
+
class Tag
{
+ /// File/Line/Column/Index information for where this tag was located in
+ /// its original SDLang file.
Location location;
+
+ /// Access all this tag's values, as an array of type `sdlang.token.Value`.
Value[] values;
private Tag _parent;
/// Get parent tag. To set a parent, attach this Tag to its intended
- /// parent tag by calling 'Tag.add(...)', or by passing it to
+ /// parent tag by calling `Tag.add(...)`, or by passing it to
/// the parent tag's constructor.
@property Tag parent()
{
@@ -205,13 +249,24 @@ class Tag
}
private string _namespace;
+ /++
+ This tag's namespace. Empty string if no namespace.
+
+ Note that setting this value is O(n) because internal lookup structures
+ need to be updated.
+
+ Note also, that setting this may change where this tag is ordered among
+ its parent's list of tags.
+ +/
@property string namespace()
{
return _namespace;
}
- /// Not particularly efficient, but it works.
+ ///ditto
@property void namespace(string value)
{
+ //TODO: Can we do this in-place, without removing/adding and thus
+ // modyfying the internal order?
if(_parent && _namespace != value)
{
// Remove
@@ -231,18 +286,31 @@ class Tag
}
private string _name;
- /// Not including namespace. Use 'fullName' if you want the namespace included.
+ /++
+ This tag's name, not including namespace.
+
+ Use `getFullName().toString` if you want the namespace included.
+
+ Note that setting this value is O(n) because internal lookup structures
+ need to be updated.
+
+ Note also, that setting this may change where this tag is ordered among
+ its parent's list of tags.
+ +/
@property string name()
{
return _name;
}
- /// Not the most efficient, but it works.
+ ///ditto
@property void name(string value)
{
+ //TODO: Seriously? Can't we at least do the "*" modification *in-place*?
+
if(_parent && _name != value)
{
_parent.updateId++;
+ // Not the most efficient, but it works.
void removeFromGroupedLookup(string ns)
{
// Remove from _parent._tags[ns]
@@ -259,6 +327,7 @@ class Tag
_name = value;
// Add to new locations in _parent._tags
+ //TODO: Can we re-insert while preserving the original order?
_parent._tags[_namespace][_name] ~= this;
_parent._tags["*"][_name] ~= this;
}
@@ -267,11 +336,18 @@ class Tag
}
/// This tag's name, including namespace if one exists.
+ deprecated("Use 'getFullName().toString()'")
@property string fullName()
{
- return _namespace==""? _name : text(_namespace, ":", _name);
+ return getFullName().toString();
}
-
+
+ /// This tag's name, including namespace if one exists.
+ FullName getFullName()
+ {
+ return FullName(_namespace, _name);
+ }
+
// Tracks dirtiness. This is incremented every time a change is made which
// could invalidate existing ranges. This way, the ranges can detect when
// they've been invalidated.
@@ -307,6 +383,15 @@ class Tag
this.add(children);
}
+ /// Deep-copy this Tag.
+ /// The clone does $(B $(I not)) have a parent, even if the original does.
+ Tag clone()
+ {
+ auto newTag = new Tag(_namespace, _name, values.dup, allAttributes.clone(), allTags.clone());
+ newTag.location = location;
+ return newTag;
+ }
+
private Attribute[] allAttributes; // In same order as specified in SDL file.
private Tag[] allTags; // In same order as specified in SDL file.
private string[] allNamespaces; // In same order as specified in SDL file.
@@ -318,8 +403,8 @@ class Tag
private Tag[][string][string] _tags; // tags[namespace or "*"][name][i]
/// Adds a Value, Attribute, Tag (or array of such) as a member/child of this Tag.
- /// Returns 'this' for chaining.
- /// Throws 'SDLangValidationException' if trying to add an Attribute or Tag
+ /// Returns `this` for chaining.
+ /// Throws `ValidationException` if trying to add an Attribute or Tag
/// that already has a parent.
Tag add(Value val)
{
@@ -342,7 +427,7 @@ class Tag
{
if(attr._parent)
{
- throw new SDLangValidationException(
+ throw new ValidationException(
"Attribute is already attached to a parent tag. "~
"Use Attribute.remove() before adding it to another tag."
);
@@ -376,7 +461,7 @@ class Tag
{
if(tag._parent)
{
- throw new SDLangValidationException(
+ throw new ValidationException(
"Tag is already attached to a parent tag. "~
"Use Tag.remove() before adding it to another tag."
);
@@ -405,7 +490,7 @@ class Tag
return this;
}
- /// Removes 'this' from its parent, if any. Returns 'this' for chaining.
+ /// Removes `this` from its parent, if any. Returns `this` for chaining.
/// Inefficient ATM, but it works.
Tag remove()
{
@@ -488,6 +573,7 @@ class Tag
frontIndex = 0;
if(
+ tag !is null &&
namespace in mixin("tag."~membersGrouped) &&
name in mixin("tag."~membersGrouped~"[namespace]")
)
@@ -506,7 +592,7 @@ class Tag
@property bool empty()
{
- return frontIndex == endIndex;
+ return tag is null || frontIndex == endIndex;
}
private size_t frontIndex;
@@ -517,7 +603,7 @@ class Tag
void popFront()
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
frontIndex++;
}
@@ -530,7 +616,7 @@ class Tag
void popBack()
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
endIndex--;
}
@@ -565,7 +651,7 @@ class Tag
r.endIndex > this.endIndex ||
r.frontIndex > r.endIndex
)
- throw new SDLangRangeException("Slice out of range");
+ throw new DOMRangeException(tag, "Slice out of range");
return r;
}
@@ -573,7 +659,7 @@ class Tag
T opIndex(size_t index)
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
return mixin("tag."~membersGrouped~"[namespace][name][frontIndex+index]");
}
@@ -595,14 +681,20 @@ class Tag
this.isMaybe = isMaybe;
frontIndex = 0;
- if(namespace == "*")
- initialEndIndex = mixin("tag."~allMembers~".length");
- else if(namespace in mixin("tag."~memberIndicies))
- initialEndIndex = mixin("tag."~memberIndicies~"[namespace].length");
+ if(tag is null)
+ endIndex = 0;
else
- initialEndIndex = 0;
+ {
+
+ if(namespace == "*")
+ initialEndIndex = mixin("tag."~allMembers~".length");
+ else if(namespace in mixin("tag."~memberIndicies))
+ initialEndIndex = mixin("tag."~memberIndicies~"[namespace].length");
+ else
+ initialEndIndex = 0;
- endIndex = initialEndIndex;
+ endIndex = initialEndIndex;
+ }
}
invariant()
@@ -615,7 +707,7 @@ class Tag
@property bool empty()
{
- return frontIndex == endIndex;
+ return tag is null || frontIndex == endIndex;
}
private size_t frontIndex;
@@ -626,7 +718,7 @@ class Tag
void popFront()
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
frontIndex++;
}
@@ -639,7 +731,7 @@ class Tag
void popBack()
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
endIndex--;
}
@@ -676,7 +768,7 @@ class Tag
r.endIndex > this.endIndex ||
r.frontIndex > r.endIndex
)
- throw new SDLangRangeException("Slice out of range");
+ throw new DOMRangeException(tag, "Slice out of range");
return r;
}
@@ -684,7 +776,7 @@ class Tag
T opIndex(size_t index)
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
if(namespace == "*")
return mixin("tag."~allMembers~"[ frontIndex+index ]");
@@ -697,7 +789,7 @@ class Tag
{
if(frontIndex != 0 || endIndex != initialEndIndex)
{
- throw new SDLangRangeException(
+ throw new DOMRangeException(tag,
"Cannot lookup tags/attributes by name on a subset of a range, "~
"only across the entire tag. "~
"Please make sure you haven't called popFront or popBack on this "~
@@ -706,10 +798,10 @@ class Tag
}
if(!isMaybe && empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
if(!isMaybe && name !in this)
- throw new SDLangRangeException(`No such `~T.stringof~` named: "`~name~`"`);
+ throw new DOMRangeException(tag, `No such `~T.stringof~` named: "`~name~`"`);
return ThisNamedMemberRange(tag, namespace, name, updateId);
}
@@ -718,7 +810,7 @@ class Tag
{
if(frontIndex != 0 || endIndex != initialEndIndex)
{
- throw new SDLangRangeException(
+ throw new DOMRangeException(tag,
"Cannot lookup tags/attributes by name on a subset of a range, "~
"only across the entire tag. "~
"Please make sure you haven't called popFront or popBack on this "~
@@ -726,6 +818,9 @@ class Tag
);
}
+ if(tag is null)
+ return false;
+
return
namespace in mixin("tag."~membersGrouped) &&
name in mixin("tag."~membersGrouped~"[namespace]") &&
@@ -769,7 +864,7 @@ class Tag
void popFront()
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
frontIndex++;
}
@@ -782,7 +877,7 @@ class Tag
void popBack()
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
endIndex--;
}
@@ -818,7 +913,7 @@ class Tag
r.endIndex > this.endIndex ||
r.frontIndex > r.endIndex
)
- throw new SDLangRangeException("Slice out of range");
+ throw new DOMRangeException(tag, "Slice out of range");
return r;
}
@@ -826,7 +921,7 @@ class Tag
NamespaceAccess opIndex(size_t index)
{
if(empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
auto namespace = tag.allNamespaces[frontIndex+index];
return NamespaceAccess(
@@ -839,10 +934,10 @@ class Tag
NamespaceAccess opIndex(string namespace)
{
if(!isMaybe && empty)
- throw new SDLangRangeException("Range is empty");
+ throw new DOMRangeException(tag, "Range is empty");
if(!isMaybe && namespace !in this)
- throw new SDLangRangeException(`No such namespace: "`~namespace~`"`);
+ throw new DOMRangeException(tag, `No such namespace: "`~namespace~`"`);
return NamespaceAccess(
namespace,
@@ -866,7 +961,7 @@ class Tag
}
}
- struct NamespaceAccess
+ static struct NamespaceAccess
{
string name;
AttributeRange attributes;
@@ -879,25 +974,66 @@ class Tag
static assert(isRandomAccessRange!TagRange);
static assert(isRandomAccessRange!NamespaceRange);
- /// Access all attributes that don't have a namespace
+ /++
+ Access all attributes that don't have a namespace
+
+ Returns a random access range of `Attribute` objects that supports
+ numeric-indexing, string-indexing, slicing and length.
+
+ Since SDLang allows multiple attributes with the same name,
+ string-indexing returns a random access range of all attributes
+ with the given name.
+
+ The string-indexing does $(B $(I not)) support namespace prefixes.
+ Use `namespace[string]`.`attributes` or `all`.`attributes` for that.
+
+ See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+ for a high-level overview (and examples) of how to use this.
+ +/
@property AttributeRange attributes()
{
return AttributeRange(this, "", false);
}
- /// Access all direct-child tags that don't have a namespace
+ /++
+ Access all direct-child tags that don't have a namespace.
+
+ Returns a random access range of `Tag` objects that supports
+ numeric-indexing, string-indexing, slicing and length.
+
+ Since SDLang allows multiple tags with the same name, string-indexing
+ returns a random access range of all immediate child tags with the
+ given name.
+
+ The string-indexing does $(B $(I not)) support namespace prefixes.
+ Use `namespace[string]`.`attributes` or `all`.`attributes` for that.
+
+ See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+ for a high-level overview (and examples) of how to use this.
+ +/
@property TagRange tags()
{
return TagRange(this, "", false);
}
- /// Access all namespaces in this tag, and the attributes/tags within them.
+ /++
+ Access all namespaces in this tag, and the attributes/tags within them.
+
+ Returns a random access range of `NamespaceAccess` elements that supports
+ numeric-indexing, string-indexing, slicing and length.
+
+ See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+ for a high-level overview (and examples) of how to use this.
+ +/
@property NamespaceRange namespaces()
{
return NamespaceRange(this, false);
}
/// Access all attributes and tags regardless of namespace.
+ ///
+ /// See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+ /// for a better understanding (and examples) of how to use this.
@property NamespaceAccess all()
{
// "*" isn't a valid namespace name, so we can use it to indicate "all namespaces"
@@ -942,14 +1078,972 @@ class Tag
}
}
- /// Access 'attributes', 'tags', 'namespaces' and 'all' like normal,
+ /// Access `attributes`, `tags`, `namespaces` and `all` like normal,
/// except that looking up a non-existant name/namespace with
- /// opIndex(string) results in an empty array instead of a thrown SDLangRangeException.
+ /// opIndex(string) results in an empty array instead of
+ /// a thrown `sdlang.exception.DOMRangeException`.
+ ///
+ /// See $(LINK2 https://github.com/Abscissa/SDLang-D/blob/master/HOWTO.md#tag-and-attribute-api-summary, API Overview)
+ /// for a more information (and examples) of how to use this.
@property MaybeAccess maybe()
{
return MaybeAccess(this);
}
+ // Internal implementations for the get/expect functions further below:
+
+ private Tag getTagImpl(FullName tagFullName, Tag defaultValue=null, bool useDefaultValue=true)
+ {
+ auto tagNS = tagFullName.namespace;
+ auto tagName = tagFullName.name;
+
+ // Can find namespace?
+ if(tagNS !in _tags)
+ {
+ if(useDefaultValue)
+ return defaultValue;
+ else
+ throw new TagNotFoundException(this, tagFullName, "No tags found in namespace '"~namespace~"'");
+ }
+
+ // Can find tag in namespace?
+ if(tagName !in _tags[tagNS] || _tags[tagNS][tagName].length == 0)
+ {
+ if(useDefaultValue)
+ return defaultValue;
+ else
+ throw new TagNotFoundException(this, tagFullName, "Can't find tag '"~tagFullName.toString()~"'");
+ }
+
+ // Return last matching tag found
+ return _tags[tagNS][tagName][$-1];
+ }
+
+ private T getValueImpl(T)(T defaultValue, bool useDefaultValue=true)
+ if(isValueType!T)
+ {
+ // Find value
+ foreach(value; this.values)
+ {
+ if(value.type == typeid(T))
+ return value.get!T();
+ }
+
+ // No value of type T found
+ if(useDefaultValue)
+ return defaultValue;
+ else
+ {
+ throw new ValueNotFoundException(
+ this,
+ FullName(this.namespace, this.name),
+ typeid(T),
+ "No value of type "~T.stringof~" found."
+ );
+ }
+ }
+
+ private T getAttributeImpl(T)(FullName attrFullName, T defaultValue, bool useDefaultValue=true)
+ if(isValueType!T)
+ {
+ auto attrNS = attrFullName.namespace;
+ auto attrName = attrFullName.name;
+
+ // Can find namespace and attribute name?
+ if(attrNS !in this._attributes || attrName !in this._attributes[attrNS])
+ {
+ if(useDefaultValue)
+ return defaultValue;
+ else
+ {
+ throw new AttributeNotFoundException(
+ this, this.getFullName(), attrFullName, typeid(T),
+ "Can't find attribute '"~FullName.combine(attrNS, attrName)~"'"
+ );
+ }
+ }
+
+ // Find value with chosen type
+ foreach(attr; this._attributes[attrNS][attrName])
+ {
+ if(attr.value.type == typeid(T))
+ return attr.value.get!T();
+ }
+
+ // Chosen type not found
+ if(useDefaultValue)
+ return defaultValue;
+ else
+ {
+ throw new AttributeNotFoundException(
+ this, this.getFullName(), attrFullName, typeid(T),
+ "Can't find attribute '"~FullName.combine(attrNS, attrName)~"' of type "~T.stringof
+ );
+ }
+ }
+
+ // High-level interfaces for get/expect funtions:
+
+ /++
+ Lookup a child tag by name. Returns null if not found.
+
+ Useful if you only expect one, and only one, child tag of a given name.
+ Only looks for immediate child tags of `this`, doesn't search recursively.
+
+ If you expect multiple tags by the same name and want to get them all,
+ use `maybe`.`tags[string]` instead.
+
+ The name can optionally include a namespace, as in `"namespace:name"`.
+ Or, you can search all namespaces using `"*:name"`. Use an empty string
+ to search for anonymous tags, or `"namespace:"` for anonymous tags inside
+ a namespace. Wildcard searching is only supported for namespaces, not names.
+ Use `maybe`.`tags[0]` if you don't care about the name.
+
+ If there are multiple tags by the chosen name, the $(B $(I last tag)) will
+ always be chosen. That is, this function considers later tags with the
+ same name to override previous ones.
+
+ If the tag cannot be found, and you provides a default value, the default
+ value is returned. Otherwise null is returned. If you'd prefer an
+ exception thrown, use `expectTag` instead.
+ +/
+ Tag getTag(string fullTagName, Tag defaultValue=null)
+ {
+ auto parsedName = FullName.parse(fullTagName);
+ parsedName.ensureNoWildcardName(
+ "Instead, use 'Tag.maybe.tags[0]', 'Tag.maybe.all.tags[0]' or 'Tag.maybe.namespace[ns].tags[0]'."
+ );
+ return getTagImpl(parsedName, defaultValue);
+ }
+
+ ///
+ @("Tag.getTag")
+ unittest
+ {
+ import std.exception;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo 1
+ foo 2 // getTag considers this to override the first foo
+
+ ns1:foo 3
+ ns1:foo 4 // getTag considers this to override the first ns1:foo
+ ns2:foo 33
+ ns2:foo 44 // getTag considers this to override the first ns2:foo
+ `);
+ assert( root.getTag("foo" ).values[0].get!int() == 2 );
+ assert( root.getTag("ns1:foo").values[0].get!int() == 4 );
+ assert( root.getTag("*:foo" ).values[0].get!int() == 44 ); // Search all namespaces
+
+ // Not found
+ // If you'd prefer an exception, use `expectTag` instead.
+ assert( root.getTag("doesnt-exist") is null );
+
+ // Default value
+ auto foo = root.getTag("foo");
+ assert( root.getTag("doesnt-exist", foo) is foo );
+ }
+
+ /++
+ Lookup a child tag by name. Throws if not found.
+
+ Useful if you only expect one, and only one, child tag of a given name.
+ Only looks for immediate child tags of `this`, doesn't search recursively.
+
+ If you expect multiple tags by the same name and want to get them all,
+ use `tags[string]` instead.
+
+ The name can optionally include a namespace, as in `"namespace:name"`.
+ Or, you can search all namespaces using `"*:name"`. Use an empty string
+ to search for anonymous tags, or `"namespace:"` for anonymous tags inside
+ a namespace. Wildcard searching is only supported for namespaces, not names.
+ Use `tags[0]` if you don't care about the name.
+
+ If there are multiple tags by the chosen name, the $(B $(I last tag)) will
+ always be chosen. That is, this function considers later tags with the
+ same name to override previous ones.
+
+ If no such tag is found, an `sdlang.exception.TagNotFoundException` will
+ be thrown. If you'd rather receive a default value, use `getTag` instead.
+ +/
+ Tag expectTag(string fullTagName)
+ {
+ auto parsedName = FullName.parse(fullTagName);
+ parsedName.ensureNoWildcardName(
+ "Instead, use 'Tag.tags[0]', 'Tag.all.tags[0]' or 'Tag.namespace[ns].tags[0]'."
+ );
+ return getTagImpl(parsedName, null, false);
+ }
+
+ ///
+ @("Tag.expectTag")
+ unittest
+ {
+ import std.exception;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo 1
+ foo 2 // expectTag considers this to override the first foo
+
+ ns1:foo 3
+ ns1:foo 4 // expectTag considers this to override the first ns1:foo
+ ns2:foo 33
+ ns2:foo 44 // expectTag considers this to override the first ns2:foo
+ `);
+ assert( root.expectTag("foo" ).values[0].get!int() == 2 );
+ assert( root.expectTag("ns1:foo").values[0].get!int() == 4 );
+ assert( root.expectTag("*:foo" ).values[0].get!int() == 44 ); // Search all namespaces
+
+ // Not found
+ // If you'd rather receive a default value than an exception, use `getTag` instead.
+ assertThrown!TagNotFoundException( root.expectTag("doesnt-exist") );
+ }
+
+ /++
+ Retrieve a value of type T from `this` tag. Returns a default value if not found.
+
+ Useful if you only expect one value of type T from this tag. Only looks for
+ values of `this` tag, it does not search child tags. If you wish to search
+ for a value in a child tag (for example, if this current tag is a root tag),
+ try `getTagValue`.
+
+ If you want to get more than one value from this tag, use `values` instead.
+
+ If this tag has multiple values, the $(B $(I first)) value matching the
+ requested type will be returned. Ie, Extra values in the tag are ignored.
+
+ You may provide a default value to be returned in case no value of
+ the requested type can be found. If you don't provide a default value,
+ `T.init` will be used.
+
+ If you'd rather an exception be thrown when a value cannot be found,
+ use `expectValue` instead.
+ +/
+ T getValue(T)(T defaultValue = T.init) if(isValueType!T)
+ {
+ return getValueImpl!T(defaultValue, true);
+ }
+
+ ///
+ @("Tag.getValue")
+ unittest
+ {
+ import std.exception;
+ import std.math;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo 1 true 2 false
+ `);
+ auto foo = root.getTag("foo");
+ assert( foo.getValue!int() == 1 );
+ assert( foo.getValue!bool() == true );
+
+ // Value found, default value ignored.
+ assert( foo.getValue!int(999) == 1 );
+
+ // No strings found
+ // If you'd prefer an exception, use `expectValue` instead.
+ assert( foo.getValue!string("Default") == "Default" );
+ assert( foo.getValue!string() is null );
+
+ // No floats found
+ assert( foo.getValue!float(99.9).approxEqual(99.9) );
+ assert( foo.getValue!float().isNaN() );
+ }
+
+ /++
+ Retrieve a value of type T from `this` tag. Throws if not found.
+
+ Useful if you only expect one value of type T from this tag. Only looks
+ for values of `this` tag, it does not search child tags. If you wish to
+ search for a value in a child tag (for example, if this current tag is a
+ root tag), try `expectTagValue`.
+
+ If you want to get more than one value from this tag, use `values` instead.
+
+ If this tag has multiple values, the $(B $(I first)) value matching the
+ requested type will be returned. Ie, Extra values in the tag are ignored.
+
+ An `sdlang.exception.ValueNotFoundException` will be thrown if no value of
+ the requested type can be found. If you'd rather receive a default value,
+ use `getValue` instead.
+ +/
+ T expectValue(T)() if(isValueType!T)
+ {
+ return getValueImpl!T(T.init, false);
+ }
+
+ ///
+ @("Tag.expectValue")
+ unittest
+ {
+ import std.exception;
+ import std.math;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo 1 true 2 false
+ `);
+ auto foo = root.getTag("foo");
+ assert( foo.expectValue!int() == 1 );
+ assert( foo.expectValue!bool() == true );
+
+ // No strings or floats found
+ // If you'd rather receive a default value than an exception, use `getValue` instead.
+ assertThrown!ValueNotFoundException( foo.expectValue!string() );
+ assertThrown!ValueNotFoundException( foo.expectValue!float() );
+ }
+
+ /++
+ Lookup a child tag by name, and retrieve a value of type T from it.
+ Returns a default value if not found.
+
+ Useful if you only expect one value of type T from a given tag. Only looks
+ for immediate child tags of `this`, doesn't search recursively.
+
+ This is a shortcut for `getTag().getValue()`, except if the tag isn't found,
+ then instead of a null reference error, it will return the requested
+ `defaultValue` (or T.init by default).
+ +/
+ T getTagValue(T)(string fullTagName, T defaultValue = T.init) if(isValueType!T)
+ {
+ auto tag = getTag(fullTagName);
+ if(!tag)
+ return defaultValue;
+
+ return tag.getValue!T(defaultValue);
+ }
+
+ ///
+ @("Tag.getTagValue")
+ unittest
+ {
+ import std.exception;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo 1 "a" 2 "b"
+ foo 3 "c" 4 "d" // getTagValue considers this to override the first foo
+
+ bar "hi"
+ bar 379 // getTagValue considers this to override the first bar
+ `);
+ assert( root.getTagValue!int("foo") == 3 );
+ assert( root.getTagValue!string("foo") == "c" );
+
+ // Value found, default value ignored.
+ assert( root.getTagValue!int("foo", 999) == 3 );
+
+ // Tag not found
+ // If you'd prefer an exception, use `expectTagValue` instead.
+ assert( root.getTagValue!int("doesnt-exist", 999) == 999 );
+ assert( root.getTagValue!int("doesnt-exist") == 0 );
+
+ // The last "bar" tag doesn't have an int (only the first "bar" tag does)
+ assert( root.getTagValue!string("bar", "Default") == "Default" );
+ assert( root.getTagValue!string("bar") is null );
+
+ // Using namespaces:
+ root = parseSource(`
+ ns1:foo 1 "a" 2 "b"
+ ns1:foo 3 "c" 4 "d"
+ ns2:foo 11 "aa" 22 "bb"
+ ns2:foo 33 "cc" 44 "dd"
+
+ ns1:bar "hi"
+ ns1:bar 379 // getTagValue considers this to override the first bar
+ `);
+ assert( root.getTagValue!int("ns1:foo") == 3 );
+ assert( root.getTagValue!int("*:foo" ) == 33 ); // Search all namespaces
+
+ assert( root.getTagValue!string("ns1:foo") == "c" );
+ assert( root.getTagValue!string("*:foo" ) == "cc" ); // Search all namespaces
+
+ // The last "bar" tag doesn't have a string (only the first "bar" tag does)
+ assert( root.getTagValue!string("*:bar", "Default") == "Default" );
+ assert( root.getTagValue!string("*:bar") is null );
+ }
+
+ /++
+ Lookup a child tag by name, and retrieve a value of type T from it.
+ Throws if not found,
+
+ Useful if you only expect one value of type T from a given tag. Only
+ looks for immediate child tags of `this`, doesn't search recursively.
+
+ This is a shortcut for `expectTag().expectValue()`.
+ +/
+ T expectTagValue(T)(string fullTagName) if(isValueType!T)
+ {
+ return expectTag(fullTagName).expectValue!T();
+ }
+
+ ///
+ @("Tag.expectTagValue")
+ unittest
+ {
+ import std.exception;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo 1 "a" 2 "b"
+ foo 3 "c" 4 "d" // expectTagValue considers this to override the first foo
+
+ bar "hi"
+ bar 379 // expectTagValue considers this to override the first bar
+ `);
+ assert( root.expectTagValue!int("foo") == 3 );
+ assert( root.expectTagValue!string("foo") == "c" );
+
+ // The last "bar" tag doesn't have a string (only the first "bar" tag does)
+ // If you'd rather receive a default value than an exception, use `getTagValue` instead.
+ assertThrown!ValueNotFoundException( root.expectTagValue!string("bar") );
+
+ // Tag not found
+ assertThrown!TagNotFoundException( root.expectTagValue!int("doesnt-exist") );
+
+ // Using namespaces:
+ root = parseSource(`
+ ns1:foo 1 "a" 2 "b"
+ ns1:foo 3 "c" 4 "d"
+ ns2:foo 11 "aa" 22 "bb"
+ ns2:foo 33 "cc" 44 "dd"
+
+ ns1:bar "hi"
+ ns1:bar 379 // expectTagValue considers this to override the first bar
+ `);
+ assert( root.expectTagValue!int("ns1:foo") == 3 );
+ assert( root.expectTagValue!int("*:foo" ) == 33 ); // Search all namespaces
+
+ assert( root.expectTagValue!string("ns1:foo") == "c" );
+ assert( root.expectTagValue!string("*:foo" ) == "cc" ); // Search all namespaces
+
+ // The last "bar" tag doesn't have a string (only the first "bar" tag does)
+ assertThrown!ValueNotFoundException( root.expectTagValue!string("*:bar") );
+
+ // Namespace not found
+ assertThrown!TagNotFoundException( root.expectTagValue!int("doesnt-exist:bar") );
+ }
+
+ /++
+ Lookup an attribute of `this` tag by name, and retrieve a value of type T
+ from it. Returns a default value if not found.
+
+ Useful if you only expect one attribute of the given name and type.
+
+ Only looks for attributes of `this` tag, it does not search child tags.
+ If you wish to search for a value in a child tag (for example, if this
+ current tag is a root tag), try `getTagAttribute`.
+
+ If you expect multiple attributes by the same name and want to get them all,
+ use `maybe`.`attributes[string]` instead.
+
+ The attribute name can optionally include a namespace, as in
+ `"namespace:name"`. Or, you can search all namespaces using `"*:name"`.
+ (Note that unlike tags. attributes can't be anonymous - that's what
+ values are.) Wildcard searching is only supported for namespaces, not names.
+ Use `maybe`.`attributes[0]` if you don't care about the name.
+
+ If this tag has multiple attributes, the $(B $(I first)) attribute
+ matching the requested name and type will be returned. Ie, Extra
+ attributes in the tag are ignored.
+
+ You may provide a default value to be returned in case no attribute of
+ the requested name and type can be found. If you don't provide a default
+ value, `T.init` will be used.
+
+ If you'd rather an exception be thrown when an attribute cannot be found,
+ use `expectAttribute` instead.
+ +/
+ T getAttribute(T)(string fullAttributeName, T defaultValue = T.init) if(isValueType!T)
+ {
+ auto parsedName = FullName.parse(fullAttributeName);
+ parsedName.ensureNoWildcardName(
+ "Instead, use 'Attribute.maybe.tags[0]', 'Attribute.maybe.all.tags[0]' or 'Attribute.maybe.namespace[ns].tags[0]'."
+ );
+ return getAttributeImpl!T(parsedName, defaultValue);
+ }
+
+ ///
+ @("Tag.getAttribute")
+ unittest
+ {
+ import std.exception;
+ import std.math;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo z=0 X=1 X=true X=2 X=false
+ `);
+ auto foo = root.getTag("foo");
+ assert( foo.getAttribute!int("X") == 1 );
+ assert( foo.getAttribute!bool("X") == true );
+
+ // Value found, default value ignored.
+ assert( foo.getAttribute!int("X", 999) == 1 );
+
+ // Attribute name not found
+ // If you'd prefer an exception, use `expectValue` instead.
+ assert( foo.getAttribute!int("doesnt-exist", 999) == 999 );
+ assert( foo.getAttribute!int("doesnt-exist") == 0 );
+
+ // No strings found
+ assert( foo.getAttribute!string("X", "Default") == "Default" );
+ assert( foo.getAttribute!string("X") is null );
+
+ // No floats found
+ assert( foo.getAttribute!float("X", 99.9).approxEqual(99.9) );
+ assert( foo.getAttribute!float("X").isNaN() );
+
+
+ // Using namespaces:
+ root = parseSource(`
+ foo ns1:z=0 ns1:X=1 ns1:X=2 ns2:X=3 ns2:X=4
+ `);
+ foo = root.getTag("foo");
+ assert( foo.getAttribute!int("ns2:X") == 3 );
+ assert( foo.getAttribute!int("*:X") == 1 ); // Search all namespaces
+
+ // Namespace not found
+ assert( foo.getAttribute!int("doesnt-exist:X", 999) == 999 );
+
+ // No attribute X is in the default namespace
+ assert( foo.getAttribute!int("X", 999) == 999 );
+
+ // Attribute name not found
+ assert( foo.getAttribute!int("ns1:doesnt-exist", 999) == 999 );
+ }
+
+ /++
+ Lookup an attribute of `this` tag by name, and retrieve a value of type T
+ from it. Throws if not found.
+
+ Useful if you only expect one attribute of the given name and type.
+
+ Only looks for attributes of `this` tag, it does not search child tags.
+ If you wish to search for a value in a child tag (for example, if this
+ current tag is a root tag), try `expectTagAttribute`.
+
+ If you expect multiple attributes by the same name and want to get them all,
+ use `attributes[string]` instead.
+
+ The attribute name can optionally include a namespace, as in
+ `"namespace:name"`. Or, you can search all namespaces using `"*:name"`.
+ (Note that unlike tags. attributes can't be anonymous - that's what
+ values are.) Wildcard searching is only supported for namespaces, not names.
+ Use `attributes[0]` if you don't care about the name.
+
+ If this tag has multiple attributes, the $(B $(I first)) attribute
+ matching the requested name and type will be returned. Ie, Extra
+ attributes in the tag are ignored.
+
+ An `sdlang.exception.AttributeNotFoundException` will be thrown if no
+ value of the requested type can be found. If you'd rather receive a
+ default value, use `getAttribute` instead.
+ +/
+ T expectAttribute(T)(string fullAttributeName) if(isValueType!T)
+ {
+ auto parsedName = FullName.parse(fullAttributeName);
+ parsedName.ensureNoWildcardName(
+ "Instead, use 'Attribute.tags[0]', 'Attribute.all.tags[0]' or 'Attribute.namespace[ns].tags[0]'."
+ );
+ return getAttributeImpl!T(parsedName, T.init, false);
+ }
+
+ ///
+ @("Tag.expectAttribute")
+ unittest
+ {
+ import std.exception;
+ import std.math;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo z=0 X=1 X=true X=2 X=false
+ `);
+ auto foo = root.getTag("foo");
+ assert( foo.expectAttribute!int("X") == 1 );
+ assert( foo.expectAttribute!bool("X") == true );
+
+ // Attribute name not found
+ // If you'd rather receive a default value than an exception, use `getAttribute` instead.
+ assertThrown!AttributeNotFoundException( foo.expectAttribute!int("doesnt-exist") );
+
+ // No strings found
+ assertThrown!AttributeNotFoundException( foo.expectAttribute!string("X") );
+
+ // No floats found
+ assertThrown!AttributeNotFoundException( foo.expectAttribute!float("X") );
+
+
+ // Using namespaces:
+ root = parseSource(`
+ foo ns1:z=0 ns1:X=1 ns1:X=2 ns2:X=3 ns2:X=4
+ `);
+ foo = root.getTag("foo");
+ assert( foo.expectAttribute!int("ns2:X") == 3 );
+ assert( foo.expectAttribute!int("*:X") == 1 ); // Search all namespaces
+
+ // Namespace not found
+ assertThrown!AttributeNotFoundException( foo.expectAttribute!int("doesnt-exist:X") );
+
+ // No attribute X is in the default namespace
+ assertThrown!AttributeNotFoundException( foo.expectAttribute!int("X") );
+
+ // Attribute name not found
+ assertThrown!AttributeNotFoundException( foo.expectAttribute!int("ns1:doesnt-exist") );
+ }
+
+ /++
+ Lookup a child tag and attribute by name, and retrieve a value of type T
+ from it. Returns a default value if not found.
+
+ Useful if you only expect one attribute of type T from given
+ the tag and attribute names. Only looks for immediate child tags of
+ `this`, doesn't search recursively.
+
+ This is a shortcut for `getTag().getAttribute()`, except if the tag isn't
+ found, then instead of a null reference error, it will return the requested
+ `defaultValue` (or T.init by default).
+ +/
+ T getTagAttribute(T)(string fullTagName, string fullAttributeName, T defaultValue = T.init) if(isValueType!T)
+ {
+ auto tag = getTag(fullTagName);
+ if(!tag)
+ return defaultValue;
+
+ return tag.getAttribute!T(fullAttributeName, defaultValue);
+ }
+
+ ///
+ @("Tag.getTagAttribute")
+ unittest
+ {
+ import std.exception;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo X=1 X="a" X=2 X="b"
+ foo X=3 X="c" X=4 X="d" // getTagAttribute considers this to override the first foo
+
+ bar X="hi"
+ bar X=379 // getTagAttribute considers this to override the first bar
+ `);
+ assert( root.getTagAttribute!int("foo", "X") == 3 );
+ assert( root.getTagAttribute!string("foo", "X") == "c" );
+
+ // Value found, default value ignored.
+ assert( root.getTagAttribute!int("foo", "X", 999) == 3 );
+
+ // Tag not found
+ // If you'd prefer an exception, use `expectTagAttribute` instead of `getTagAttribute`
+ assert( root.getTagAttribute!int("doesnt-exist", "X", 999) == 999 );
+ assert( root.getTagAttribute!int("doesnt-exist", "X") == 0 );
+ assert( root.getTagAttribute!int("foo", "doesnt-exist", 999) == 999 );
+ assert( root.getTagAttribute!int("foo", "doesnt-exist") == 0 );
+
+ // The last "bar" tag doesn't have a string (only the first "bar" tag does)
+ assert( root.getTagAttribute!string("bar", "X", "Default") == "Default" );
+ assert( root.getTagAttribute!string("bar", "X") is null );
+
+
+ // Using namespaces:
+ root = parseSource(`
+ ns1:foo X=1 X="a" X=2 X="b"
+ ns1:foo X=3 X="c" X=4 X="d"
+ ns2:foo X=11 X="aa" X=22 X="bb"
+ ns2:foo X=33 X="cc" X=44 X="dd"
+
+ ns1:bar attrNS:X="hi"
+ ns1:bar attrNS:X=379 // getTagAttribute considers this to override the first bar
+ `);
+ assert( root.getTagAttribute!int("ns1:foo", "X") == 3 );
+ assert( root.getTagAttribute!int("*:foo", "X") == 33 ); // Search all namespaces
+
+ assert( root.getTagAttribute!string("ns1:foo", "X") == "c" );
+ assert( root.getTagAttribute!string("*:foo", "X") == "cc" ); // Search all namespaces
+
+ // bar's attribute X is't in the default namespace
+ assert( root.getTagAttribute!int("*:bar", "X", 999) == 999 );
+ assert( root.getTagAttribute!int("*:bar", "X") == 0 );
+
+ // The last "bar" tag's "attrNS:X" attribute doesn't have a string (only the first "bar" tag does)
+ assert( root.getTagAttribute!string("*:bar", "attrNS:X", "Default") == "Default" );
+ assert( root.getTagAttribute!string("*:bar", "attrNS:X") is null);
+ }
+
+ /++
+ Lookup a child tag and attribute by name, and retrieve a value of type T
+ from it. Throws if not found.
+
+ Useful if you only expect one attribute of type T from given
+ the tag and attribute names. Only looks for immediate child tags of
+ `this`, doesn't search recursively.
+
+ This is a shortcut for `expectTag().expectAttribute()`.
+ +/
+ T expectTagAttribute(T)(string fullTagName, string fullAttributeName) if(isValueType!T)
+ {
+ return expectTag(fullTagName).expectAttribute!T(fullAttributeName);
+ }
+
+ ///
+ @("Tag.expectTagAttribute")
+ unittest
+ {
+ import std.exception;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo X=1 X="a" X=2 X="b"
+ foo X=3 X="c" X=4 X="d" // expectTagAttribute considers this to override the first foo
+
+ bar X="hi"
+ bar X=379 // expectTagAttribute considers this to override the first bar
+ `);
+ assert( root.expectTagAttribute!int("foo", "X") == 3 );
+ assert( root.expectTagAttribute!string("foo", "X") == "c" );
+
+ // The last "bar" tag doesn't have an int attribute named "X" (only the first "bar" tag does)
+ // If you'd rather receive a default value than an exception, use `getAttribute` instead.
+ assertThrown!AttributeNotFoundException( root.expectTagAttribute!string("bar", "X") );
+
+ // Tag not found
+ assertThrown!TagNotFoundException( root.expectTagAttribute!int("doesnt-exist", "X") );
+
+ // Using namespaces:
+ root = parseSource(`
+ ns1:foo X=1 X="a" X=2 X="b"
+ ns1:foo X=3 X="c" X=4 X="d"
+ ns2:foo X=11 X="aa" X=22 X="bb"
+ ns2:foo X=33 X="cc" X=44 X="dd"
+
+ ns1:bar attrNS:X="hi"
+ ns1:bar attrNS:X=379 // expectTagAttribute considers this to override the first bar
+ `);
+ assert( root.expectTagAttribute!int("ns1:foo", "X") == 3 );
+ assert( root.expectTagAttribute!int("*:foo", "X") == 33 ); // Search all namespaces
+
+ assert( root.expectTagAttribute!string("ns1:foo", "X") == "c" );
+ assert( root.expectTagAttribute!string("*:foo", "X") == "cc" ); // Search all namespaces
+
+ // bar's attribute X is't in the default namespace
+ assertThrown!AttributeNotFoundException( root.expectTagAttribute!int("*:bar", "X") );
+
+ // The last "bar" tag's "attrNS:X" attribute doesn't have a string (only the first "bar" tag does)
+ assertThrown!AttributeNotFoundException( root.expectTagAttribute!string("*:bar", "attrNS:X") );
+
+ // Tag's namespace not found
+ assertThrown!TagNotFoundException( root.expectTagAttribute!int("doesnt-exist:bar", "attrNS:X") );
+ }
+
+ /++
+ Lookup a child tag by name, and retrieve all values from it.
+
+ This just like using `getTag()`.`values`, except if the tag isn't found,
+ it safely returns null (or an optional array of default values) instead of
+ a dereferencing null error.
+
+ Note that, unlike `getValue`, this doesn't discriminate by the value's
+ type. It simply returns all values of a single tag as a `Value[]`.
+
+ If you'd prefer an exception thrown when the tag isn't found, use
+ `expectTag`.`values` instead.
+ +/
+ Value[] getTagValues(string fullTagName, Value[] defaultValues = null)
+ {
+ auto tag = getTag(fullTagName);
+ if(tag)
+ return tag.values;
+ else
+ return defaultValues;
+ }
+
+ ///
+ @("getTagValues")
+ unittest
+ {
+ import std.exception;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo 1 "a" 2 "b"
+ foo 3 "c" 4 "d" // getTagValues considers this to override the first foo
+ `);
+ assert( root.getTagValues("foo") == [Value(3), Value("c"), Value(4), Value("d")] );
+
+ // Tag not found
+ // If you'd prefer an exception, use `expectTag.values` instead.
+ assert( root.getTagValues("doesnt-exist") is null );
+ assert( root.getTagValues("doesnt-exist", [ Value(999), Value("Not found") ]) ==
+ [ Value(999), Value("Not found") ] );
+ }
+
+ /++
+ Lookup a child tag by name, and retrieve all attributes in a chosen
+ (or default) namespace from it.
+
+ This just like using `getTag()`.`attributes` (or
+ `getTag()`.`namespace[...]`.`attributes`, or `getTag()`.`all`.`attributes`),
+ except if the tag isn't found, it safely returns an empty range instead
+ of a dereferencing null error.
+
+ If provided, the `attributeNamespace` parameter can be either the name of
+ a namespace, or an empty string for the default namespace (the default),
+ or `"*"` to retreive attributes from all namespaces.
+
+ Note that, unlike `getAttributes`, this doesn't discriminate by the
+ value's type. It simply returns the usual `attributes` range.
+
+ If you'd prefer an exception thrown when the tag isn't found, use
+ `expectTag`.`attributes` instead.
+ +/
+ auto getTagAttributes(string fullTagName, string attributeNamespace = null)
+ {
+ auto tag = getTag(fullTagName);
+ if(tag)
+ {
+ if(attributeNamespace && attributeNamespace in tag.namespaces)
+ return tag.namespaces[attributeNamespace].attributes;
+ else if(attributeNamespace == "*")
+ return tag.all.attributes;
+ else
+ return tag.attributes;
+ }
+
+ return AttributeRange(null, null, false);
+ }
+
+ ///
+ @("getTagAttributes")
+ unittest
+ {
+ import std.exception;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo X=1 X=2
+
+ // getTagAttributes considers this to override the first foo
+ foo X1=3 X2="c" namespace:bar=7 X3=4 X4="d"
+ `);
+
+ auto fooAttrs = root.getTagAttributes("foo");
+ assert( !fooAttrs.empty );
+ assert( fooAttrs.length == 4 );
+ assert( fooAttrs[0].name == "X1" && fooAttrs[0].value == Value(3) );
+ assert( fooAttrs[1].name == "X2" && fooAttrs[1].value == Value("c") );
+ assert( fooAttrs[2].name == "X3" && fooAttrs[2].value == Value(4) );
+ assert( fooAttrs[3].name == "X4" && fooAttrs[3].value == Value("d") );
+
+ fooAttrs = root.getTagAttributes("foo", "namespace");
+ assert( !fooAttrs.empty );
+ assert( fooAttrs.length == 1 );
+ assert( fooAttrs[0].name == "bar" && fooAttrs[0].value == Value(7) );
+
+ fooAttrs = root.getTagAttributes("foo", "*");
+ assert( !fooAttrs.empty );
+ assert( fooAttrs.length == 5 );
+ assert( fooAttrs[0].name == "X1" && fooAttrs[0].value == Value(3) );
+ assert( fooAttrs[1].name == "X2" && fooAttrs[1].value == Value("c") );
+ assert( fooAttrs[2].name == "bar" && fooAttrs[2].value == Value(7) );
+ assert( fooAttrs[3].name == "X3" && fooAttrs[3].value == Value(4) );
+ assert( fooAttrs[4].name == "X4" && fooAttrs[4].value == Value("d") );
+
+ // Tag not found
+ // If you'd prefer an exception, use `expectTag.attributes` instead.
+ assert( root.getTagValues("doesnt-exist").empty );
+ }
+
+ @("*: Disallow wildcards for names")
+ unittest
+ {
+ import std.exception;
+ import std.math;
+ import sdlang.parser;
+
+ auto root = parseSource(`
+ foo 1 X=2
+ ns:foo 3 ns:X=4
+ `);
+ auto foo = root.getTag("foo");
+ auto nsfoo = root.getTag("ns:foo");
+
+ // Sanity check
+ assert( foo !is null );
+ assert( foo.name == "foo" );
+ assert( foo.namespace == "" );
+
+ assert( nsfoo !is null );
+ assert( nsfoo.name == "foo" );
+ assert( nsfoo.namespace == "ns" );
+
+ assert( foo.getValue !int() == 1 );
+ assert( foo.expectValue !int() == 1 );
+ assert( nsfoo.getValue !int() == 3 );
+ assert( nsfoo.expectValue!int() == 3 );
+
+ assert( root.getTagValue !int("foo") == 1 );
+ assert( root.expectTagValue!int("foo") == 1 );
+ assert( root.getTagValue !int("ns:foo") == 3 );
+ assert( root.expectTagValue!int("ns:foo") == 3 );
+
+ assert( foo.getAttribute !int("X") == 2 );
+ assert( foo.expectAttribute !int("X") == 2 );
+ assert( nsfoo.getAttribute !int("ns:X") == 4 );
+ assert( nsfoo.expectAttribute!int("ns:X") == 4 );
+
+ assert( root.getTagAttribute !int("foo", "X") == 2 );
+ assert( root.expectTagAttribute!int("foo", "X") == 2 );
+ assert( root.getTagAttribute !int("ns:foo", "ns:X") == 4 );
+ assert( root.expectTagAttribute!int("ns:foo", "ns:X") == 4 );
+
+ // No namespace
+ assertThrown!ArgumentException( root.getTag ("*") );
+ assertThrown!ArgumentException( root.expectTag("*") );
+
+ assertThrown!ArgumentException( root.getTagValue !int("*") );
+ assertThrown!ArgumentException( root.expectTagValue!int("*") );
+
+ assertThrown!ArgumentException( foo.getAttribute !int("*") );
+ assertThrown!ArgumentException( foo.expectAttribute !int("*") );
+ assertThrown!ArgumentException( root.getTagAttribute !int("*", "X") );
+ assertThrown!ArgumentException( root.expectTagAttribute!int("*", "X") );
+ assertThrown!ArgumentException( root.getTagAttribute !int("foo", "*") );
+ assertThrown!ArgumentException( root.expectTagAttribute!int("foo", "*") );
+
+ // With namespace
+ assertThrown!ArgumentException( root.getTag ("ns:*") );
+ assertThrown!ArgumentException( root.expectTag("ns:*") );
+
+ assertThrown!ArgumentException( root.getTagValue !int("ns:*") );
+ assertThrown!ArgumentException( root.expectTagValue!int("ns:*") );
+
+ assertThrown!ArgumentException( nsfoo.getAttribute !int("ns:*") );
+ assertThrown!ArgumentException( nsfoo.expectAttribute !int("ns:*") );
+ assertThrown!ArgumentException( root.getTagAttribute !int("ns:*", "ns:X") );
+ assertThrown!ArgumentException( root.expectTagAttribute!int("ns:*", "ns:X") );
+ assertThrown!ArgumentException( root.getTagAttribute !int("ns:foo", "ns:*") );
+ assertThrown!ArgumentException( root.expectTagAttribute!int("ns:foo", "ns:*") );
+
+ // With wildcard namespace
+ assertThrown!ArgumentException( root.getTag ("*:*") );
+ assertThrown!ArgumentException( root.expectTag("*:*") );
+
+ assertThrown!ArgumentException( root.getTagValue !int("*:*") );
+ assertThrown!ArgumentException( root.expectTagValue!int("*:*") );
+
+ assertThrown!ArgumentException( nsfoo.getAttribute !int("*:*") );
+ assertThrown!ArgumentException( nsfoo.expectAttribute !int("*:*") );
+ assertThrown!ArgumentException( root.getTagAttribute !int("*:*", "*:X") );
+ assertThrown!ArgumentException( root.expectTagAttribute!int("*:*", "*:X") );
+ assertThrown!ArgumentException( root.getTagAttribute !int("*:foo", "*:*") );
+ assertThrown!ArgumentException( root.expectTagAttribute!int("*:foo", "*:*") );
+ }
+
override bool opEquals(Object o)
{
auto t = cast(Tag)o;
@@ -981,9 +2075,10 @@ class Tag
return allTags == t.allTags;
}
- /// Treats 'this' as the root tag. Note that root tags cannot have
+ /// Treats `this` as the root tag. Note that root tags cannot have
/// values or attributes, and cannot be part of a namespace.
- /// If this isn't a valid root tag, 'SDLangValidationException' will be thrown.
+ /// If this isn't a valid root tag, `sdlang.exception.ValidationException`
+ /// will be thrown.
string toSDLDocument()(string indent="\t", int indentLevel=0)
{
Appender!string sink;
@@ -996,21 +2091,21 @@ class Tag
if(isOutputRange!(Sink,char))
{
if(values.length > 0)
- throw new SDLangValidationException("Root tags cannot have any values, only child tags.");
+ throw new ValidationException("Root tags cannot have any values, only child tags.");
if(allAttributes.length > 0)
- throw new SDLangValidationException("Root tags cannot have any attributes, only child tags.");
+ throw new ValidationException("Root tags cannot have any attributes, only child tags.");
if(_namespace != "")
- throw new SDLangValidationException("Root tags cannot have a namespace.");
+ throw new ValidationException("Root tags cannot have a namespace.");
foreach(tag; allTags)
tag.toSDLString(sink, indent, indentLevel);
}
- /// Output this entire tag in SDL format. Does *not* treat 'this' as
+ /// Output this entire tag in SDL format. Does $(B $(I not)) treat `this` as
/// a root tag. If you intend this to be the root of a standard SDL
- /// document, use 'toSDLDocument' instead.
+ /// document, use `toSDLDocument` instead.
string toSDLString()(string indent="\t", int indentLevel=0)
{
Appender!string sink;
@@ -1023,10 +2118,10 @@ class Tag
if(isOutputRange!(Sink,char))
{
if(_name == "" && values.length == 0)
- throw new SDLangValidationException("Anonymous tags must have at least one value.");
+ throw new ValidationException("Anonymous tags must have at least one value.");
if(_name == "" && _namespace != "")
- throw new SDLangValidationException("Anonymous tags cannot have a namespace.");
+ throw new ValidationException("Anonymous tags cannot have a namespace.");
// Indent
foreach(i; 0..indentLevel)
@@ -1080,7 +2175,7 @@ class Tag
sink.put("\n");
}
- /// Not the most efficient, but it works.
+ /// Outputs full information on the tag.
string toDebugString()
{
import std.algorithm : sort;
@@ -1129,7 +2224,7 @@ class Tag
}
}
-version(sdlangUnittest)
+version(unittest)
{
private void testRandomAccessRange(R, E)(R range, E[] expected, bool function(E, E) equals=null)
{
@@ -1269,12 +2364,11 @@ version(sdlangUnittest)
}
}
-version(sdlangUnittest)
+@("*: Test sdlang ast")
unittest
{
+ import std.exception;
import sdlang.parser;
- writeln("Unittesting sdlang ast...");
- stdout.flush();
Tag root;
root = parseSource("");
@@ -1473,26 +2567,26 @@ unittest
testRandomAccessRange(root.all.tags["blue"], [blue3, blue5]);
testRandomAccessRange(root.all.tags["orange"], [orange]);
- assertThrown!SDLangRangeException(root.tags["foobar"]);
- assertThrown!SDLangRangeException(root.all.tags["foobar"]);
- assertThrown!SDLangRangeException(root.attributes["foobar"]);
- assertThrown!SDLangRangeException(root.all.attributes["foobar"]);
+ assertThrown!DOMRangeException(root.tags["foobar"]);
+ assertThrown!DOMRangeException(root.all.tags["foobar"]);
+ assertThrown!DOMRangeException(root.attributes["foobar"]);
+ assertThrown!DOMRangeException(root.all.attributes["foobar"]);
// DMD Issue #12585 causes a segfault in these two tests when using 2.064 or 2.065,
// so work around it.
- //assertThrown!SDLangRangeException(root.namespaces["foobar"].tags["foobar"]);
- //assertThrown!SDLangRangeException(root.namespaces["foobar"].attributes["foobar"]);
+ //assertThrown!DOMRangeException(root.namespaces["foobar"].tags["foobar"]);
+ //assertThrown!DOMRangeException(root.namespaces["foobar"].attributes["foobar"]);
bool didCatch = false;
try
auto x = root.namespaces["foobar"].tags["foobar"];
- catch(SDLangRangeException e)
+ catch(DOMRangeException e)
didCatch = true;
assert(didCatch);
didCatch = false;
try
auto x = root.namespaces["foobar"].attributes["foobar"];
- catch(SDLangRangeException e)
+ catch(DOMRangeException e)
didCatch = true;
assert(didCatch);
@@ -1799,16 +2893,33 @@ unittest
assert("" !in people.namespaces);
assert("foobar" !in people.namespaces);
testRandomAccessRange(people.all.attributes, cast(Attribute[])[]);
+
+ // Test clone()
+ auto rootClone = root.clone();
+ assert(rootClone !is root);
+ assert(rootClone.parent is null);
+ assert(rootClone.name == root.name);
+ assert(rootClone.namespace == root.namespace);
+ assert(rootClone.location == root.location);
+ assert(rootClone.values == root.values);
+ assert(rootClone.toSDLDocument() == root.toSDLDocument());
+
+ auto peopleClone = people.clone();
+ assert(peopleClone !is people);
+ assert(peopleClone.parent is null);
+ assert(peopleClone.name == people.name);
+ assert(peopleClone.namespace == people.namespace);
+ assert(peopleClone.location == people.location);
+ assert(peopleClone.values == people.values);
+ assert(peopleClone.toSDLString() == people.toSDLString());
}
// Regression test, issue #11: https://github.com/Abscissa/SDLang-D/issues/11
-version(sdlangUnittest)
+@("*: Regression test issue #11")
unittest
{
import sdlang.parser;
- writeln("ast: Regression test issue #11...");
- stdout.flush();
-
+
auto root = parseSource(
`//
a`);