static void Main(string[] args)
{
string jsonString = "";
string s;
while ((s = Console.ReadLine()) != null)
{
jsonString += s;
}
var o = JsonDocument.Parse(jsonString).RootElement;
var selector = args[0];
JsonPath path = null;
try
{
path = JsonPath.Parse(selector);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(2);
}
try
{
var results = path.Evaluate(o);
Console.WriteLine(results.Matches.Select(m => m.Value).AsJsonElement().ToJsonString());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Environment.Exit(1);
}
}
private static void CompareEval(JsonPath expected, string text)
{
var data = new JsonArray
{
1,
new JsonObject
{
["bool"] = false,
["int"] = 20,
["string"] = "value",
},
"hello",
true,
5,
new JsonArray {
1, 2, 3
}
};
var actual = JsonPath.Parse(text);
var expectedResult = expected.Evaluate(data);
var actualResult = actual.Evaluate(data);
Assert.AreEqual(expectedResult, actualResult);
}
public void CanParseChainedPropertySelectors(string jsonpathExpression, string[] expectedPropertyNames)
{
JsonPath jsonPath = new JsonPath(typeof(Dummy), jsonpathExpression);
Assert.Equal(jsonPath.Root.Nodes
.Cast <JsonPathPropertySelectorNode>()
.Select(s => s.PropertyName).ToArray(),
expectedPropertyNames);
string value;
var dummy1 = new Dummy();
var dummy2 = new Dummy {
Other = dummy1
};
dummy1.Property = "dummy1 value";
value = (string)JsonPath.Evaluate(dummy2, jsonpathExpression);
Assert.True(value == dummy2.Other.Property);
dummy2.Property = "dummy2 value";
value = (string)JsonPath.Evaluate(dummy2, jsonpathExpression);
Assert.True(value == dummy2.Other.Property);
}
public void CanParseSinglePropertySelector(string jsonpathExpression, string expectedPropertyName)
{
JsonPath jsonPath = new JsonPath(typeof(Dummy), jsonpathExpression);
Assert.True(jsonPath.Root.Nodes.Single() is JsonPathPropertySelectorNode propertySelectorNode &&
propertySelectorNode.PropertyName == expectedPropertyName);
string value;
var dummy1 = new Dummy();
value = (string)JsonPath.Evaluate(dummy1, jsonpathExpression);
Assert.True(value == dummy1.Property);
dummy1.Property = "dummy1 value";
value = (string)JsonPath.Evaluate(dummy1, jsonpathExpression);
Assert.True(value == dummy1.Property);
var dummy2 = new Dummy();
value = (string)JsonPath.Evaluate(dummy2, jsonpathExpression);
Assert.True(value == dummy2.Property);
dummy2.Property = "dummy2 value";
value = (string)JsonPath.Evaluate(dummy2, jsonpathExpression);
Assert.True(value == dummy2.Property);
}
public JsonElement Evaluate(JsonElement element)
{
if (_value.HasValue)
{
return(_value.Value);
}
if (_path != null)
{
var result = _path.Evaluate(element);
// don't set _value; need to always eval
return(result.Matches.Count == 1
? result.Matches[0].Value
: default);
public void Run(ComplianceTestCase testCase)
{
if (_notSupported.Contains(testCase.Selector))
{
Assert.Inconclusive("This case will not be supported.");
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine(testCase);
Console.WriteLine();
JsonPath path = null;
PathResult actual = null;
var time = Debugger.IsAttached ? int.MaxValue : 100;
using var cts = new CancellationTokenSource(time);
Task.Run(() =>
{
if (!JsonPath.TryParse(testCase.Selector, out path))
{
return;
}
if (testCase.Document.ValueKind == JsonValueKind.Undefined)
{
return;
}
actual = path.Evaluate(testCase.Document);
}, cts.Token).Wait(cts.Token);
if (path != null && testCase.InvalidSelector)
{
Assert.Inconclusive($"{testCase.Selector} is not a valid path but was parsed without error.");
}
if (actual == null)
{
if (testCase.InvalidSelector)
{
return;
}
Assert.Fail($"Could not parse path: {testCase.Selector}");
}
var actualValues = actual.Matches.Select(m => m.Value).AsJsonElement();
Console.WriteLine($"Actual (values): {actualValues}");
Console.WriteLine();
Console.WriteLine($"Actual: {JsonSerializer.Serialize(actual)}");
if (testCase.InvalidSelector)
{
Assert.Fail($"{testCase.Selector} is not a valid path.");
}
var expected = testCase.Result.AsJsonElement();
Assert.IsTrue(expected.IsEquivalentTo(actualValues));
}
