public void Format_ArrayMultiItem_ReturnsExpectedArray()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("array")),
MarkupGrammar.TokenElementBegin(new DataName("item")),
MarkupGrammar.TokenPrimitive(0),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementVoid(new DataName("item")),
MarkupGrammar.TokenElementBegin(new DataName("item")),
MarkupGrammar.TokenPrimitive(false),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("item")),
MarkupGrammar.TokenPrimitive(true),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var expected = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(0),
ModelGrammar.TokenNull,
ModelGrammar.TokenFalse,
ModelGrammar.TokenTrue,
ModelGrammar.TokenArrayEnd
};
var transformer = new XmlReader.XmlInTransformer(new DataReaderSettings());
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_DifferentPrefixSameNamespace_ReturnsSequence()
{
var input = new[]
{
MarkupGrammar.TokenElementVoid(new DataName("foo", String.Empty, "http://example.org")),
MarkupGrammar.TokenAttribute(new DataName("key", "blah", "http://example.org")),
MarkupGrammar.TokenPrimitive("value")
};
var expected = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("foo"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("blah:key"),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenProperty("xmlns"),
ModelGrammar.TokenPrimitive("http://example.org"),
ModelGrammar.TokenProperty("xmlns:blah"),
ModelGrammar.TokenPrimitive("http://example.org"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayEnd
};
var converter = new JsonMLReader.JsonMLInTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
private void EmitTag(List <Token <MarkupTokenType> > output, DataName elementName, IDictionary <DataName, Token <ModelTokenType> > attributes, MarkupTokenType tagType)
{
if (this.pendingNewLine)
{
if (this.Settings.PrettyPrint)
{
this.depth++;
this.EmitNewLine(output);
}
this.pendingNewLine = false;
}
PrefixScopeChain.Scope scope = new PrefixScopeChain.Scope();
scope.TagName = elementName;
if (!this.ScopeChain.ContainsNamespace(elementName.NamespaceUri))
{
scope[elementName.Prefix] = elementName.NamespaceUri;
}
this.ScopeChain.Push(scope);
switch (tagType)
{
case MarkupTokenType.ElementVoid:
{
output.Add(MarkupGrammar.TokenElementVoid(elementName));
break;
}
case MarkupTokenType.ElementEnd:
{
output.Add(MarkupGrammar.TokenElementEnd);
break;
}
default:
case MarkupTokenType.ElementBegin:
{
output.Add(MarkupGrammar.TokenElementBegin(elementName));
break;
}
}
if (attributes != null)
{
foreach (var attr in attributes)
{
output.Add(MarkupGrammar.TokenAttribute(attr.Key));
output.Add(attr.Value.ChangeType(MarkupTokenType.Primitive));
}
attributes.Clear();
}
}
public void GetTokens_SingleVoidTag_ReturnsSequence()
{
const string input = @"<root />";
var expected = new[]
{
MarkupGrammar.TokenElementVoid(new DataName("root"))
};
var tokenizer = new XmlReader.XmlTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_DifferentPrefixSameNamespace_ReturnsSequence()
{
const string input = @"<foo xmlns=""http://example.org"" xmlns:blah=""http://example.org"" blah:key=""value"" />";
var expected = new[]
{
MarkupGrammar.TokenElementVoid(new DataName("foo", String.Empty, "http://example.org")),
MarkupGrammar.TokenAttribute(new DataName("key", "blah", "http://example.org")),
MarkupGrammar.TokenPrimitive("value")
};
var tokenizer = new XmlReader.XmlTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_SingleVoidTag_ReturnsSequence()
{
var input = new[]
{
MarkupGrammar.TokenElementVoid(new DataName("root"))
};
var expected = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("root"),
ModelGrammar.TokenArrayEnd
};
var converter = new JsonMLReader.JsonMLInTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_MultipleAttributes_ReturnsMarkup()
{
var input = new[]
{
MarkupGrammar.TokenElementVoid(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("no-value")),
MarkupGrammar.TokenPrimitive(String.Empty),
MarkupGrammar.TokenAttribute(new DataName("whitespace")),
MarkupGrammar.TokenPrimitive(" this contains whitespace "),
MarkupGrammar.TokenAttribute(new DataName("anyQuotedText")),
MarkupGrammar.TokenPrimitive("/\\\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?")
};
const string expected = @"<root no-value="""" whitespace="" this contains whitespace "" anyQuotedText=""/\" + "\uCAFE\uBABE\uAB98\uFCDE\uBCDA\uEF4A\n\r\t" + @"`1~!@#$%^&*()_+-=[]{}|;:',./<>?"" />";
var formatter = new XmlWriter.XmlFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Format_ArrayOneItem_ReturnsExpectedArray()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenNull,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("array")),
MarkupGrammar.TokenElementVoid(new DataName("item")),
MarkupGrammar.TokenElementEnd
};
var transformer = new XmlWriter.XmlOutTransformer(new DataWriterSettings());
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_MultipleAttributesCanonicalForm_ReturnsCanonicalMarkup()
{
var input = new[]
{
MarkupGrammar.TokenElementVoid(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("whitespace")),
MarkupGrammar.TokenPrimitive(" this contains whitespace "),
MarkupGrammar.TokenAttribute(new DataName("no-value")),
MarkupGrammar.TokenPrimitive(String.Empty),
MarkupGrammar.TokenAttribute(new DataName("anyQuotedText")),
MarkupGrammar.TokenPrimitive("/\\\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?")
};
const string expected = @"<root anyQuotedText=""/\" + "\uCAFE\uBABE\uAB98\uFCDE\uBCDA\uEF4A" + @"

	`1~!@#$%^&*()_+-=[]{}|;:',./<>?"" no-value whitespace="" this contains whitespace ""></root>";
var formatter = new HtmlFormatter(new DataWriterSettings())
{
CanonicalForm = true
};
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
/// <summary>
/// Gets a token sequence from the XmlReader
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public IEnumerable <Token <MarkupTokenType> > GetTokens(System.Xml.XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
while (true)
{
// have to isolate try-catch away from yields
try
{
if (!reader.Read())
{
((IDisposable)reader).Dispose();
break;
}
}
catch (System.Xml.XmlException ex)
{
throw new DeserializationException(ex.Message, ex.LinePosition, ex.LineNumber, -1, ex);
}
catch (Exception ex)
{
throw new DeserializationException(ex.Message, -1, ex);
}
switch (reader.NodeType)
{
case System.Xml.XmlNodeType.Element:
{
DataName tagName = new DataName(reader.LocalName, reader.Prefix, reader.NamespaceURI);
bool isVoidTag = reader.IsEmptyElement;
IDictionary <DataName, string> attributes;
if (reader.HasAttributes)
{
attributes = new CanonicalList();
while (reader.MoveToNextAttribute())
{
if (String.IsNullOrEmpty(reader.Prefix) && reader.LocalName == "xmlns" ||
reader.Prefix == "xmlns")
{
continue;
}
attributes[new DataName(reader.LocalName, reader.Prefix, reader.NamespaceURI)] = reader.Value;
}
}
else
{
attributes = null;
}
if (isVoidTag)
{
yield return(MarkupGrammar.TokenElementVoid(tagName));
}
else
{
yield return(MarkupGrammar.TokenElementBegin(tagName));
}
if (attributes != null)
{
foreach (var attribute in attributes)
{
yield return(MarkupGrammar.TokenAttribute(attribute.Key));
yield return(MarkupGrammar.TokenPrimitive(attribute.Value));
}
}
break;
}
case System.Xml.XmlNodeType.EndElement:
{
yield return(MarkupGrammar.TokenElementEnd);
break;
}
case System.Xml.XmlNodeType.Attribute:
{
yield return(MarkupGrammar.TokenAttribute(new DataName(reader.Name, reader.Prefix, reader.NamespaceURI, true)));
yield return(MarkupGrammar.TokenPrimitive(reader.Value));
break;
}
case System.Xml.XmlNodeType.Text:
{
yield return(MarkupGrammar.TokenPrimitive(reader.Value));
break;
}
case System.Xml.XmlNodeType.SignificantWhitespace:
case System.Xml.XmlNodeType.Whitespace:
{
yield return(MarkupGrammar.TokenPrimitive(reader.Value));
break;
}
case System.Xml.XmlNodeType.CDATA:
{
yield return(MarkupGrammar.TokenPrimitive(reader.Value));
break;
}
case System.Xml.XmlNodeType.Entity:
case System.Xml.XmlNodeType.EntityReference:
case System.Xml.XmlNodeType.EndEntity:
{
break;
}
case System.Xml.XmlNodeType.ProcessingInstruction:
case System.Xml.XmlNodeType.XmlDeclaration:
{
yield return(MarkupGrammar.TokenUnparsed("?", "?", reader.Name + " " + reader.Value));
break;
}
case System.Xml.XmlNodeType.Comment:
{
yield return(MarkupGrammar.TokenUnparsed("!--", "--", reader.Value));
break;
}
case System.Xml.XmlNodeType.DocumentType:
{
yield return(MarkupGrammar.TokenUnparsed("!DOCTYPE ", "", reader.Value));
break;
}
case System.Xml.XmlNodeType.Notation:
{
yield return(MarkupGrammar.TokenUnparsed("!NOTATION ", "", reader.Value));
break;
}
case System.Xml.XmlNodeType.None:
{
((IDisposable)reader).Dispose();
yield break;
}
case System.Xml.XmlNodeType.Document:
case System.Xml.XmlNodeType.DocumentFragment:
default:
{
continue;
}
}
}
;
}
