public void TryParseNullResolver()
{
Assert.Throws(typeof(ArgumentNullException), () =>
{
XamlTypeName.TryParse("Foo", null, out dummy);
});
}
public void Parse()
{
//Get all inside brackets
if (value.Length > 1 && (value[0] != '{' || value[value.Length - 1] != '}'))
{
throw new XamlParseException("Invalid markup extension attribute. It should begin with '{{' and end with '}}'");
}
value = value.Substring(1, value.Length - 2);
Name = ReadUntil(' ', true);
XamlTypeName xtn;
if (!XamlTypeName.TryParse(Name, nsResolver, out xtn))
{
throw Error("Failed to parse type name '{0}'", Name);
}
var xtnFirst = new XamlTypeName(xtn.Namespace, xtn.Name + "Extension", xtn.TypeArguments);
var xtFirst = sctx.GetXamlType(xtnFirst);
//if type with Extension postfix is not resolved or unknown we try to get it without the prefix
Type = ((xtFirst == null || xtFirst.IsUnknown) ? null : xtFirst) ??
sctx.GetXamlType(xtn) ??
new XamlType(xtn.Namespace, xtn.Name, null, sctx);
ParseArgument();
}
public void TryParseInvalidGenericName()
{
var r = new MyNSResolver();
r.Add("x", "urn:foo");
Assert.IsFalse(XamlTypeName.TryParse("x:Foo()", r, out dummy), "#1");
}
public void TryParseNullName()
{
Assert.Throws(typeof(ArgumentNullException), () =>
{
XamlTypeName.TryParse(null, new MyNSResolver(), out dummy);
});
}
public void TryParseGenericName()
{
var r = new MyNSResolver();
r.Add("x", "urn:foo");
Assert.IsTrue(XamlTypeName.TryParse("x:Foo(x:Foo,x:Bar)", r, out dummy), "#1");
Assert.AreEqual(2, dummy.TypeArguments.Count, "#2");
}
public void TryParseColon()
{
var r = new MyNSResolver();
r.Add("a", "urn:foo");
Assert.IsFalse(XamlTypeName.TryParse(":", r, out dummy), "#1");
Assert.IsFalse(XamlTypeName.TryParse("a:", r, out dummy), "#2");
Assert.IsFalse(XamlTypeName.TryParse(":b", r, out dummy), "#3");
}
public void TryParseFillEmpty()
{
var r = new MyNSResolver();
Assert.IsTrue(XamlTypeName.TryParse("Foo", r, out dummy), "#1");
Assert.IsNotNull(dummy, "#2");
Assert.AreEqual(String.Empty, dummy.Namespace, "#2-2");
Assert.AreEqual("Foo", dummy.Name, "#2-3");
}
public void TryParseResolveSuccess()
{
var r = new MyNSResolver();
r.Add("x", "urn:foo");
Assert.IsTrue(XamlTypeName.TryParse("x:Foo", r, out dummy), "#1");
Assert.IsNotNull(dummy, "#2");
Assert.AreEqual("urn:foo", dummy.Namespace, "#2-2");
Assert.AreEqual("Foo", dummy.Name, "#2-3");
}
public void TryParseInvalidName()
{
var r = new MyNSResolver();
r.Add("a", "urn:foo");
r.Add("#", "urn:bar");
Assert.IsFalse(XamlTypeName.TryParse("$%#___!", r, out dummy), "#1");
Assert.IsFalse(XamlTypeName.TryParse("a:#$#", r, out dummy), "#2");
Assert.IsFalse(XamlTypeName.TryParse("#:foo", r, out dummy), "#3");
}
internal Type ResolvePrefixedNameWithAdditionalWpfSemantics(string prefixedName, DependencyObject element)
{
// First, get the xmlns dictionary off of the provided Tree Element.
object dictObject = element.GetValue(System.Windows.Markup.XmlAttributeProperties.XmlnsDictionaryProperty);
var prefixDictionary = dictObject as System.Windows.Markup.XmlnsDictionary;
object mapsObject = element.GetValue(System.Windows.Markup.XmlAttributeProperties.XmlNamespaceMapsProperty);
var namespaceMaps = mapsObject as Hashtable;
// If there was no xmlns map on the given Tree Element.
// Then, as a last resort, if the prefix was "" use the Wpf Element URI.
if (prefixDictionary == null)
{
if (_wpfDefaultNamespace == null)
{
var wpfDefaultNamespace = new System.Windows.Markup.XmlnsDictionary();
wpfDefaultNamespace.Add(String.Empty, Baml2006SchemaContext.WpfNamespace);
_wpfDefaultNamespace = wpfDefaultNamespace;
}
prefixDictionary = _wpfDefaultNamespace;
}
else
{
if (namespaceMaps != null && namespaceMaps.Count > 0)
{
// This DO was loaded with a custom XamlTypeMapper. Try the custom mappings first.
Type result = System.Windows.Markup.XamlTypeMapper.GetTypeFromName(prefixedName, element);
if (result != null)
{
return(result);
}
}
}
XamlTypeName xamlTypeName;
if (XamlTypeName.TryParse(prefixedName, prefixDictionary, out xamlTypeName))
{
XamlType xamlType = GetXamlType(xamlTypeName);
if (xamlType != null)
{
return(xamlType.UnderlyingType);
}
}
return(null);
}
public void Parse()
{
if (!Read('{'))
{
throw Error("Invalid markup extension attribute. It should begin with '{{', but was {0}", value);
}
Name = ReadUntil(' ', true);
XamlTypeName xtn;
if (!XamlTypeName.TryParse(Name, nsResolver, out xtn))
{
throw Error("Failed to parse type name '{0}'", Name);
}
Type = sctx.GetXamlType(xtn);
ParseArgument();
if (!Read('}'))
{
throw Error("Expected '}}' in the markup extension attribute: '{0}'", value);
}
}
public void TryParseNullName()
{
Assert.Throws <ArgumentNullException> (() => XamlTypeName.TryParse(null, new MyNSResolver(), out dummy));
}
public void TryParseResolveFailure()
{
Assert.IsFalse(XamlTypeName.TryParse("x:Foo", new MyNSResolver(), out dummy), "#1");
}
public void TryParseAlreadyQualified()
{
Assert.IsFalse(XamlTypeName.TryParse("{urn:foo}Foo", new MyNSResolver(), out dummy), "#1");
}
public static ParsedMarkupExtensionInfo Parse(string raw, IXamlNamespaceResolver nsResolver, XamlSchemaContext sctx)
{
if (raw == null)
{
throw new ArgumentNullException("raw");
}
if (raw.Length == 0 || raw [0] != '{')
{
throw Error("Invalid markup extension attribute. It should begin with '{{', but was {0}", raw);
}
var ret = new ParsedMarkupExtensionInfo();
int idx = raw.IndexOf('}');
if (idx < 0)
{
throw Error("Expected '}}' in the markup extension attribute: '{0}'", raw);
}
raw = raw.Substring(1, idx - 1);
idx = raw.IndexOf(' ');
string name = idx < 0 ? raw : raw.Substring(0, idx);
XamlTypeName xtn;
if (!XamlTypeName.TryParse(name, nsResolver, out xtn))
{
throw Error("Failed to parse type name '{0}'", name);
}
var xt = sctx.GetXamlType(xtn);
ret.Type = xt;
if (idx < 0)
{
return(ret);
}
string [] vpairs = raw.Substring(idx + 1, raw.Length - idx - 1).Split(',');
List <string> posPrms = null;
foreach (string vpair in vpairs)
{
idx = vpair.IndexOf('=');
// FIXME: unescape string (e.g. comma)
if (idx < 0)
{
if (posPrms == null)
{
posPrms = new List <string> ();
ret.Arguments.Add(XamlLanguage.PositionalParameters, posPrms);
}
posPrms.Add(UnescapeValue(vpair.Trim()));
}
else
{
var key = vpair.Substring(0, idx).Trim();
// FIXME: is unknown member always isAttacheable = false?
var xm = xt.GetMember(key) ?? new XamlMember(key, xt, false);
ret.Arguments.Add(xm, UnescapeValue(vpair.Substring(idx + 1).Trim()));
}
}
return(ret);
}
public void TryParseNoFillEmpty()
{
Assert.IsFalse(XamlTypeName.TryParse("Foo", new MyNSResolver(true), out dummy), "#1");
}
public static ParsedMarkupExtensionInfo Parse(string raw, IXamlNamespaceResolver nsResolver, XamlSchemaContext sctx)
{
if (raw == null)
{
throw new ArgumentNullException(nameof(raw));
}
if (raw.Length == 0 || raw[0] != '{')
{
throw Error("Invalid markup extension attribute. It should begin with '{{', but was {0}", raw);
}
if (raw.Length >= 2 && raw[1] == '}')
{
throw Error("Markup extension can not begin with an '{}' escape: '{0}'", raw);
}
var ret = new ParsedMarkupExtensionInfo();
if (raw[raw.Length - 1] != '}')
{
// Any character after the final closing bracket is not accepted. Therefore, the last character should be '}'.
// Ideally, we should still ran the entire markup through the parser to get a more meaningful error.
throw Error("Expected '}}' in the markup extension attribute: '{0}'", raw);
}
var nameSeparatorIndex = raw.IndexOf(' ');
var name = nameSeparatorIndex != -1 ? raw.Substring(1, nameSeparatorIndex - 1) : raw.Substring(1, raw.Length - 2);
if (!XamlTypeName.TryParse(name, nsResolver, out var xtn))
{
throw Error("Failed to parse type name '{0}'", name);
}
var xt = sctx.GetXamlType(xtn) ?? new XamlType(xtn.Namespace, xtn.Name, null, sctx);
ret.Type = xt;
if (nameSeparatorIndex < 0)
{
return(ret);
}
var valueWithoutBinding = raw.Substring(nameSeparatorIndex + 1, raw.Length - 1 - (nameSeparatorIndex + 1));
var vpairs = SliceParameters(valueWithoutBinding, raw);
List <string> posPrms = null;
XamlMember lastMember = null;
foreach (var vpair in vpairs)
{
var idx = vpair.IndexOf('=');
// FIXME: unescape string (e.g. comma)
if (idx < 0)
{
if (vpair.ElementAtOrDefault(0) == ')')
{
if (lastMember != null)
{
if (ret.Arguments[lastMember] is string s)
{
ret.Arguments[lastMember] = s + ')';
}
}
else
{
posPrms[posPrms.Count - 1] += ')';
}
}
else
{
if (posPrms == null)
{
posPrms = new List <string>();
ret.Arguments.Add(XamlLanguage.PositionalParameters, posPrms);
}
posPrms.Add(UnescapeValue(vpair.Trim()));
}
}
else
{
var key = vpair.Substring(0, idx).Trim();
// FIXME: is unknown member always isAttacheable = false?
var xm = xt.GetMember(key) ?? new XamlMember(key, xt, false);
// Binding member values may be wrapped in quotes (single or double) e.g. 'A,B,C,D'.
// Remove those wrapping quotes from the resulting string value.
var valueString = RemoveWrappingStringQuotes(vpair.Substring(idx + 1).Trim());
var value = IsValidMarkupExtension(valueString)
? (object)Parse(valueString, nsResolver, sctx) : UnescapeValue(valueString);
ret.Arguments.Add(xm, value);
lastMember = xm;
}
}
return(ret);
}
public void TryParseNullName()
{
XamlTypeName.TryParse(null, new MyNSResolver(), out dummy);
}
public void TryParseNullResolver()
{
XamlTypeName.TryParse("Foo", null, out dummy);
}
public static ParsedMarkupExtensionInfo Parse(string raw, IXamlNamespaceResolver nsResolver, XamlSchemaContext sctx)
{
if (raw == null)
{
throw new ArgumentNullException(nameof(raw));
}
if (raw.Length == 0 || raw[0] != '{')
{
throw Error("Invalid markup extension attribute. It should begin with '{{', but was {0}", raw);
}
var ret = new ParsedMarkupExtensionInfo();
int idx = raw.LastIndexOf('}');
if (idx < 0)
{
throw Error("Expected '}}' in the markup extension attribute: '{0}'", raw);
}
raw = raw.Substring(1, idx - 1);
idx = raw.IndexOf(' ');
string name = idx < 0 ? raw : raw.Substring(0, idx);
XamlTypeName xtn;
if (!XamlTypeName.TryParse(name, nsResolver, out xtn))
{
throw Error("Failed to parse type name '{0}'", name);
}
var xt = sctx.GetXamlType(xtn) ?? new XamlType(nsResolver.GetNamespace(""), name, null, sctx);
ret.Type = xt;
if (idx < 0)
{
return(ret);
}
var valueWithoutBinding = raw.Substring(idx + 1, raw.Length - idx - 1);
var vpairs = BindingMembersRegex.Matches(valueWithoutBinding)
.Cast <Match>()
.Select(m => m.Value.Trim())
.ToList();
if (vpairs.Count == 0)
{
vpairs.Add(valueWithoutBinding);
}
List <string> posPrms = null;
XamlMember lastMember = null;
foreach (var vpair in vpairs)
{
idx = vpair.IndexOf('=');
// FIXME: unescape string (e.g. comma)
if (idx < 0)
{
if (vpair.ElementAtOrDefault(0) == ')')
{
if (lastMember != null)
{
if (ret.Arguments[lastMember] is string s)
{
ret.Arguments[lastMember] = s + ')';
}
}
else
{
posPrms[posPrms.Count - 1] += ')';
}
}
else
{
if (posPrms == null)
{
posPrms = new List <string>();
ret.Arguments.Add(XamlLanguage.PositionalParameters, posPrms);
}
posPrms.Add(UnescapeValue(vpair.Trim()));
}
}
else
{
var key = vpair.Substring(0, idx).Trim();
// FIXME: is unknown member always isAttacheable = false?
var xm = xt.GetMember(key) ?? new XamlMember(key, xt, false);
// Binding member values may be wrapped in quotes (single or double) e.g. 'A,B,C,D'.
// Remove those wrapping quotes from the resulting string value.
var valueString = RemoveWrappingStringQuotes(vpair.Substring(idx + 1).Trim());
var value = IsValidMarkupExtension(valueString)
? (object)Parse(valueString, nsResolver, sctx) : UnescapeValue(valueString);
ret.Arguments.Add(xm, value);
lastMember = xm;
}
}
return(ret);
}
public void TryParseEmptyName()
{
Assert.IsFalse(XamlTypeName.TryParse(String.Empty, new MyNSResolver(), out dummy), "#1");
}
public void TryParseNullResolver()
{
Assert.Throws <ArgumentNullException> (() => XamlTypeName.TryParse("Foo", null, out dummy));
}