public void AlternateKeyDelimiters()
{
JsonReader reader = CreateReader("{ 'm1' = 'v1', 'm2' => 'v2' }");
reader.ReadToken(JsonTokenClass.Object);
Assert.AreEqual("m1", reader.ReadMember());
Assert.AreEqual("v1", reader.ReadString());
Assert.AreEqual("m2", reader.ReadMember());
Assert.AreEqual("v2", reader.ReadString());
Assert.AreSame(JsonTokenClass.EndObject, reader.TokenClass);
}
public void MemberValuesMayBeDelimitedBySemiColon()
{
JsonReader reader = CreateReader("{ 'm1' = 'v1'; 'm2' => 'v2' }");
reader.ReadToken(JsonTokenClass.Object);
Assert.AreEqual("m1", reader.ReadMember());
Assert.AreEqual("v1", reader.ReadString());
Assert.AreEqual("m2", reader.ReadMember());
Assert.AreEqual("v2", reader.ReadString());
Assert.AreSame(JsonTokenClass.EndObject, reader.TokenClass);
}
public void TailReadingWithNoBufferedMembers()
{
JsonReader tail = CreateHelper(@"{ y: 456, x: 123, z: 789 }").GetTailReader();
Assert.AreEqual("y", tail.ReadMember());
Assert.AreEqual(456, tail.ReadNumber().ToInt32());
Assert.AreEqual("x", tail.ReadMember());
Assert.AreEqual(123, tail.ReadNumber().ToInt32());
Assert.AreEqual("z", tail.ReadMember());
Assert.AreEqual(789, tail.ReadNumber().ToInt32());
tail.ReadToken(JsonTokenClass.EndObject);
Assert.IsFalse(tail.Read());
}
protected virtual void Import(ImportContext context, JsonReader reader)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
// FIXME: Consider making this method exception-safe.
// Right now this is a problem because of reliance on
// DictionaryBase.
Clear();
reader.ReadToken(JsonTokenClass.Object);
while (reader.TokenClass != JsonTokenClass.EndObject)
{
Put(reader.ReadMember(), context.Import(reader));
}
reader.Read();
}
/// <summary>
/// Writes the next value from the given <see cref="JsonReader"/>
/// into this writer's output. If the reader is positioned
/// at the root of JSON data, then the entire data will be
/// written.
/// </summary>
public virtual void WriteFromReader(JsonReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (!reader.MoveToContent())
{
return;
}
if (reader.TokenClass == JsonTokenClass.String)
{
WriteString(reader.Text);
}
else if (reader.TokenClass == JsonTokenClass.Number)
{
WriteNumber(reader.Text);
}
else if (reader.TokenClass == JsonTokenClass.Boolean)
{
WriteBoolean(reader.Text == JsonBoolean.TrueText);
}
else if (reader.TokenClass == JsonTokenClass.Null)
{
WriteNull();
}
else if (reader.TokenClass == JsonTokenClass.Array)
{
WriteStartArray();
reader.Read();
while (reader.TokenClass != JsonTokenClass.EndArray)
{
WriteFromReader(reader);
}
WriteEndArray();
}
else if (reader.TokenClass == JsonTokenClass.Object)
{
reader.Read();
WriteStartObject();
while (reader.TokenClass != JsonTokenClass.EndObject)
{
WriteMember(reader.ReadMember());
WriteFromReader(reader);
}
WriteEndObject();
}
else
{
throw new JsonException(string.Format("{0} not expected.", reader.TokenClass));
}
reader.Read();
}
public void ExtraCommaAfterLastObjectMemberAllowded()
{
JsonReader reader = CreateReader("{ 'member':'value',}");
reader.ReadToken(JsonTokenClass.Object);
Assert.AreEqual("member", reader.ReadMember());
Assert.AreEqual("value", reader.ReadString());
Assert.AreSame(JsonTokenClass.EndObject, reader.TokenClass);
}
public void NullMemberNameHarmless()
{
JsonReader reader = CreateReader("{null:null}");
reader.MoveToContent();
reader.ReadToken(JsonTokenClass.Object);
Assert.AreEqual("null", reader.ReadMember());
reader.ReadNull();
Assert.AreSame(JsonTokenClass.EndObject, reader.TokenClass);
Assert.IsFalse(reader.Read());
}
public void TailMemberAfterUnorderedReader()
{
FreeJsonMemberReadingHelper helper = CreateHelper(@"
{ y: 456, x: 123, z: 789, comment: tail }");
Assert.AreEqual(123, helper.ReadMember("x").ReadNumber().ToInt32());
Assert.AreEqual(456, helper.ReadMember("y").ReadNumber().ToInt32());
Assert.AreEqual(789, helper.ReadMember("z").ReadNumber().ToInt32());
JsonReader reader = helper.BaseReader;
Assert.AreEqual("comment", reader.ReadMember());
Assert.AreEqual("tail", reader.ReadString());
}
public void ImportNonObjectMember()
{
Surrogate surrogate = new Surrogate(new object());
ImportContext context = new ImportContext();
surrogate.Import(context, "foo", JsonText.CreateReader("bar"));
JsonReader tail = surrogate.CreateObject(context).TailReader;
tail.ReadToken(JsonTokenClass.Object);
Assert.AreEqual("foo", tail.ReadMember());
Assert.AreEqual("bar", tail.ReadString());
tail.ReadToken(JsonTokenClass.EndObject);
}
public void Export()
{
JsonObject o = new JsonObject();
o.Put("Number", 123);
o.Put("String", "Hello World");
o.Put("Boolean", true);
JsonRecorder writer = new JsonRecorder();
o.Export(writer);
JsonReader reader = writer.CreatePlayer();
reader.ReadToken(JsonTokenClass.Object);
string[] members = (string[])o.GetNamesArray().ToArray(typeof(string));
Assert.AreEqual(members[0], reader.ReadMember());
Assert.AreEqual(o[members[0]], reader.ReadNumber().ToInt32());
Assert.AreEqual(members[1], reader.ReadMember());
Assert.AreEqual(o[members[1]], reader.ReadString());
Assert.AreEqual(members[2], reader.ReadMember());
Assert.AreEqual(o[members[2]], reader.ReadBoolean());
Assert.AreEqual(JsonTokenClass.EndObject, reader.TokenClass);
}
public void AutoCompletion()
{
JsonRecorder writer = new JsonRecorder();
writer.WriteStartArray();
writer.WriteStartObject();
writer.WriteMember("outer");
writer.WriteStartObject();
writer.WriteMember("inner");
writer.AutoComplete();
JsonReader reader = writer.CreatePlayer();
reader.ReadToken(JsonTokenClass.Array);
reader.ReadToken(JsonTokenClass.Object);
Assert.AreEqual("outer", reader.ReadMember());
reader.ReadToken(JsonTokenClass.Object);
Assert.AreEqual("inner", reader.ReadMember());
reader.ReadNull();
reader.ReadToken(JsonTokenClass.EndObject);
reader.ReadToken(JsonTokenClass.EndObject);
reader.ReadToken(JsonTokenClass.EndArray);
Assert.IsTrue(reader.EOF);
}
protected virtual void Import(ImportContext context, JsonReader reader)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (reader == null)
{
throw new ArgumentNullException("reader");
}
Clear();
reader.ReadToken(JsonTokenClass.Object);
while (reader.TokenClass != JsonTokenClass.EndObject)
{
Put(reader.ReadMember(), context.Import(reader));
}
reader.Read();
}
public void TailReading()
{
FreeJsonMemberReadingHelper helper = CreateHelper(@"
{ y: 456,
x: 123,
z: 789,
obj1: { foo: bar },
comment: null,
arr: [ 123, 456, 789 ],
obj2: { a: 1, b: 2, }, }");
Assert.AreEqual(123, helper.ReadMember("x").ReadNumber().ToInt32());
helper.ReadMember("comment").ReadNull();
JsonReader reader = helper.BaseReader;
Assert.AreEqual(JsonTokenClass.Member, reader.TokenClass);
Assert.AreEqual("arr", reader.Text);
JsonReader tail = helper.GetTailReader();
Assert.AreEqual("y", tail.ReadMember());
Assert.AreEqual(456, tail.ReadNumber().ToInt32());
Assert.AreEqual("z", tail.ReadMember());
Assert.AreEqual(789, tail.ReadNumber().ToInt32());
Assert.AreEqual("obj1", tail.ReadMember());
tail.ReadToken(JsonTokenClass.Object);
Assert.AreEqual("foo", tail.ReadMember());
Assert.AreEqual("bar", tail.ReadString());
tail.ReadToken(JsonTokenClass.EndObject);
Assert.AreEqual("arr", tail.ReadMember());
tail.ReadToken(JsonTokenClass.Array);
Assert.AreEqual(123, tail.ReadNumber().ToInt32());
Assert.AreEqual(456, tail.ReadNumber().ToInt32());
Assert.AreEqual(789, tail.ReadNumber().ToInt32());
tail.ReadToken(JsonTokenClass.EndArray);
Assert.AreEqual("obj2", tail.ReadMember());
tail.StepOut();
Assert.IsFalse(reader.Read());
}
/// <summary>
/// Attempts to locate a member with a given (case-sensitive) name
/// and returns a <see cref="JsonReader"/> that can be used to read
/// the value. Otherwise it returns <c>null</c>.
/// </summary>
/// <remarks>
/// The caller should not use the returned <see cref="JsonReader"/>
/// instance for any other purpose but reading the value. It is
/// possible that this method will return the same instance as
/// <see cref="BaseReader"/> or a separate instance.
/// </remarks>
public JsonReader TryReadMember(string name)
{
//
// Is the member already buffered? If yes then return a reader
// on its buffered value.
//
JsonBuffer value = TryPopBufferedMember(name);
if (!value.IsEmpty)
{
return(value.CreateReader());
}
//
// Use the base reader from here on if it has not already been
// exhausted...
//
if (_ended)
{
return(null);
}
JsonReader reader = BaseReader;
if (!_started)
{
_started = true;
if (!reader.MoveToContent())
{
throw new JsonException(string.Format(
@"Unexpected EOF while attempting to look for member named '{0}'.",
name));
}
JsonTokenClass clazz = reader.TokenClass;
if (clazz != JsonTokenClass.Object &&
clazz != JsonTokenClass.Member)
{
throw new JsonException(string.Format(
@"Found {0} where a JSON Object or Member was expected.", clazz));
}
}
//
// If the base reader is sitting on the start of an object then
// move into it. This case should only arise on the first read
// into a JSON object.
//
if (reader.TokenClass == JsonTokenClass.Object)
{
reader.Read();
}
//
// Go over the entire JSON object until its end.
//
while (reader.TokenClass != JsonTokenClass.EndObject)
{
//
// Read the next member and if it matches what's being
// sought then simply return the base reader that
// should be aligned on the value.
//
string actualName = reader.ReadMember();
if (string.CompareOrdinal(actualName, name) == 0)
{
return(reader);
}
//
// Not the sought member so buffer it to be served
// later when it is sought or as part of the tail.
//
NamedJsonBufferList members = _members;
if (members == null)
{
members = _members = new NamedJsonBufferList(4);
}
members.Add(new NamedJsonBuffer(actualName, JsonBuffer.From(reader)));
}
_ended = true;
//
// Member not found.
//
return(null);
}
private static object ReadParameters(Method method, JsonReader reader, ImportContext importContext)
{
Debug.Assert(method != null);
Debug.Assert(reader != null);
Debug.Assert(importContext != null);
reader.MoveToContent();
Parameter[] parameters = method.GetParameters();
if (reader.TokenClass == JsonTokenClass.Array)
{
reader.Read();
ArrayList argList = new ArrayList(parameters.Length);
// TODO: This loop could bomb when more args are supplied that parameters available.
for (int i = 0; i < parameters.Length && reader.TokenClass != JsonTokenClass.EndArray; i++)
argList.Add(importContext.Import(parameters[i].ParameterType, reader));
reader.StepOut();
return argList.ToArray();
}
else if (reader.TokenClass == JsonTokenClass.Object)
{
reader.Read();
JsonObject argByName = new JsonObject();
while (reader.TokenClass != JsonTokenClass.EndObject)
{
// TODO: Imporve this lookup.
// FIXME: Does not work when argument is positional.
Type parameterType = AnyType.Value;
string name = reader.ReadMember();
foreach (Parameter parameter in parameters)
{
if (parameter.Name.Equals(name))
{
parameterType = parameter.ParameterType;
break;
}
}
argByName.Put(name, importContext.Import(parameterType, reader));
}
reader.Read();
return argByName;
}
else
{
return importContext.Import(reader);
}
}
/// <remarks>
/// This method is not exception-safe. If an error occurs while
/// reading then the object may be partially imported.
/// </remarks>
public virtual void Import(JsonReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
// FIXME: Consider making this method exception-safe.
// Right now this is a problem because of reliance on
// DictionaryBase.
Clear();
reader.ReadToken(JsonTokenClass.Object);
while (reader.TokenClass != JsonTokenClass.EndObject)
Put(reader.ReadMember(), reader.ReadValue());
reader.Read();
}
/// <summary>
/// Writes the next value from the given <see cref="JsonReader"/>
/// into this writer's output. If the reader is positioned
/// at the root of JSON data, then the entire data will be
/// written.
/// </summary>
public virtual void WriteFromReader(JsonReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (!reader.MoveToContent())
return;
if (reader.TokenClass == JsonTokenClass.String)
{
WriteString(reader.Text);
}
else if (reader.TokenClass == JsonTokenClass.Number)
{
WriteNumber(reader.Text);
}
else if (reader.TokenClass == JsonTokenClass.Boolean)
{
WriteBoolean(reader.Text == JsonBoolean.TrueText);
}
else if (reader.TokenClass == JsonTokenClass.Null)
{
WriteNull();
}
else if (reader.TokenClass == JsonTokenClass.Array)
{
WriteStartArray();
reader.Read();
while (reader.TokenClass != JsonTokenClass.EndArray)
WriteFromReader(reader);
WriteEndArray();
}
else if (reader.TokenClass == JsonTokenClass.Object)
{
reader.Read();
WriteStartObject();
while (reader.TokenClass != JsonTokenClass.EndObject)
{
WriteMember(reader.ReadMember());
WriteFromReader(reader);
}
WriteEndObject();
}
else
{
throw new JsonException(string.Format("{0} not expected.", reader.TokenClass));
}
reader.Read();
}
public void WriteValueFromReader(JsonReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (!reader.MoveToContent())
return;
switch (reader.Token)
{
case JsonToken.String: WriteString(reader.Text); break;
case JsonToken.Number: WriteNumber(reader.Text); break;
case JsonToken.Boolean : WriteBoolean(reader.Text == JsonReader.FalseText); break;
case JsonToken.Null : WriteNull(); break;
case JsonToken.Object :
{
WriteStartObject();
reader.ReadMember();
do
{
WriteMember(reader.Text);
reader.Read();
WriteValueFromReader(reader);
}
while (reader.Token != JsonToken.EndObject);
WriteEndObject();
break;
}
case JsonToken.Array :
{
WriteStartArray();
reader.Read();
while (reader.Token != JsonToken.EndArray)
WriteValueFromReader(reader);
WriteEndArray();
break;
}
default : throw new JsonException(string.Format("{0} not expected.", reader.Token));
}
reader.Read();
}
void IJsonImportable.Import(ImportContext context, JsonReader reader)
{
reader.MoveToContent();
if (reader.TokenClass != JsonTokenClass.Object)
{
reader.Skip();
return;
}
reader.Read(/* object */);
do
{
var brushName = reader.ReadMember().ToLowerInvariant();
var color = reader.ReadString();
var foreground = EnumHelper.TryParse<ConsoleColor>(color, true) ?? DefaultBrush.Foreground;
switch (brushName)
{
case "arr":
case "array":
Array = Array.ResetForeground(foreground);
break;
case "obj":
case "object":
Object = Object.ResetForeground(foreground);
break;
case "mem":
case "member":
Member = Member.ResetForeground(foreground);
break;
case "str":
case "string":
String = String.ResetForeground(foreground);
break;
case "num":
case "number":
Number = Number.ResetForeground(foreground);
break;
case "bit":
case "boolean":
Boolean = Boolean.ResetForeground(foreground);
break;
case "nil":
case "null":
Null = Null.ResetForeground(foreground);
break;
default:
continue;
}
}
while (reader.TokenClass != JsonTokenClass.EndObject);
reader.Read( /* end object */);
}
