Compare commits
5 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 7238b75bdb | |||
| db2890bf99 | |||
| c8a695034e | |||
| 0332af453a | |||
| f650d8b1ed |
31
.gitignore
vendored
31
.gitignore
vendored
@@ -1,31 +0,0 @@
|
||||
#ignorar miniaturas creadas por windows
|
||||
Thumbs.db
|
||||
#Ignorar archivos construidos por Visual Studio
|
||||
*.obj
|
||||
*.exe
|
||||
*.pdb
|
||||
*.user
|
||||
*.aps
|
||||
*.pch
|
||||
*.vspscc
|
||||
*_i.c
|
||||
*_p.c
|
||||
*.ncb
|
||||
*.suo
|
||||
*.tlb
|
||||
*.tlh
|
||||
*.bak
|
||||
*.cache
|
||||
*.ilk
|
||||
*.log
|
||||
[Bb]in
|
||||
[Dd]ebug*/
|
||||
*.lib
|
||||
*.sbr
|
||||
obj/
|
||||
[Rr]elease*/
|
||||
_ReSharper*/
|
||||
*.userprefs
|
||||
*.nupkg
|
||||
/.vs/*
|
||||
/packages/*
|
||||
21
LICENSE.txt
21
LICENSE.txt
@@ -1,21 +0,0 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2016-2021 Valeriano Alfonso Rodriguez
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
78
README.md
78
README.md
@@ -1,78 +0,0 @@
|
||||
# .Net library for JSON parsing
|
||||
|
||||
## Usage
|
||||
|
||||
### VAR.Json
|
||||
Add the resulting assembly as reference in your projects, and this line on code:
|
||||
|
||||
```csharp
|
||||
using VAR.Json;
|
||||
```
|
||||
|
||||
Parse any string with JSON content:
|
||||
```csharp
|
||||
object result = JsonParser.ParseText("{\"Test\": 1}");
|
||||
```
|
||||
|
||||
Serialize any object to JSON:
|
||||
```csharp
|
||||
string jsonText = JsonWriter.WriteObject(new List<int>{1, 2, 3, 4});
|
||||
```
|
||||
|
||||
### VAR.Json.JsonParser
|
||||
This object can be invoked with a list of types used to cast the json objects.
|
||||
|
||||
|
||||
```csharp
|
||||
|
||||
class Person
|
||||
{
|
||||
public string Name { get; set; }
|
||||
public string Surname { get; set; }
|
||||
public DateTime DateOfBirth { get; set; }
|
||||
}
|
||||
|
||||
JsonParser jsonParser = new JsonParser();
|
||||
jsonParser.KnownTypes.Add(typeof(Person));
|
||||
Person jsonText = jsonParser.Parse("{ \"Name\": \"John", \"Surname\": \"Doe\", \"DateOfBirth\": \"1970-01-01\"}") as Person;
|
||||
```
|
||||
|
||||
|
||||
## Building
|
||||
A Visual Studio solution is provided. Simply, click build on the IDE.
|
||||
|
||||
The build generates a DLL and a Nuget package.
|
||||
|
||||
## Contributing
|
||||
1. Fork it!
|
||||
2. Create your feature branch: `git checkout -b my-new-feature`
|
||||
3. Commit your changes: `git commit -am 'Add some feature'`
|
||||
4. Push to the branch: `git push origin my-new-feature`
|
||||
5. Submit a pull request :D
|
||||
|
||||
## Credits
|
||||
* Valeriano Alfonso Rodriguez.
|
||||
|
||||
## License
|
||||
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2016-2021 Valeriano Alfonso Rodriguez
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -1,478 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using Xunit;
|
||||
|
||||
namespace VAR.Json.Tests
|
||||
{
|
||||
public class JsonParser_Tests
|
||||
{
|
||||
#region Parse
|
||||
|
||||
public class SwallowObject
|
||||
{
|
||||
public string Text { get; set; }
|
||||
public int Number { get; set; }
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__SwallowObject()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
parser.KnownTypes.Add(typeof(SwallowObject));
|
||||
SwallowObject result = parser.Parse(@"{""Text"": ""AAAA"", ""Number"": 42}") as SwallowObject;
|
||||
Assert.False(parser.Tainted);
|
||||
Assert.Equal("AAAA", result.Text);
|
||||
Assert.Equal(42, result.Number);
|
||||
}
|
||||
|
||||
public class DeeperObject_L1
|
||||
{
|
||||
public string Name { get; set; }
|
||||
public SwallowObject Object { get; set; }
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__DeeperObject_L1()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
parser.KnownTypes.Add(typeof(SwallowObject));
|
||||
parser.KnownTypes.Add(typeof(DeeperObject_L1));
|
||||
DeeperObject_L1 result = parser.Parse(@"{""Name"": ""Thing"", ""Object"": {""Text"": ""AAAA"", ""Number"": 42}}") as DeeperObject_L1;
|
||||
Assert.False(parser.Tainted);
|
||||
Assert.Equal("Thing", result.Name);
|
||||
Assert.Equal("AAAA", result.Object.Text);
|
||||
Assert.Equal(42, result.Object.Number);
|
||||
}
|
||||
|
||||
public class DeeperObject_L2
|
||||
{
|
||||
public int Count { get; set; }
|
||||
public DeeperObject_L1 Object { get; set; }
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__DeeperObject_L2()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
parser.KnownTypes.Add(typeof(SwallowObject));
|
||||
parser.KnownTypes.Add(typeof(DeeperObject_L1));
|
||||
parser.KnownTypes.Add(typeof(DeeperObject_L2));
|
||||
DeeperObject_L2 result = parser.Parse(@"{""Count"": 1, ""Object"": {""Name"": ""Thing"", ""Object"": {""Text"": ""AAAA"", ""Number"": 42}}}") as DeeperObject_L2;
|
||||
Assert.False(parser.Tainted);
|
||||
Assert.Equal(1, result.Count);
|
||||
Assert.Equal("Thing", result.Object.Name);
|
||||
Assert.Equal("AAAA", result.Object.Object.Text);
|
||||
Assert.Equal(42, result.Object.Object.Number);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__SwallowObjectArray()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
parser.KnownTypes.Add(typeof(SwallowObject));
|
||||
List<SwallowObject> result = parser.Parse(@"[{""Text"": ""AAAA"", ""Number"": 42}]") as List<SwallowObject>;
|
||||
Assert.False(parser.Tainted);
|
||||
Assert.Single(result);
|
||||
Assert.Equal("AAAA", result[0].Text);
|
||||
Assert.Equal(42, result[0].Number);
|
||||
}
|
||||
|
||||
public class DeeperObjectArray_L1
|
||||
{
|
||||
public int Count { get; set; }
|
||||
public List<SwallowObject> Array { get; set; }
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__DeeperObjectArray_L1()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
parser.KnownTypes.Add(typeof(SwallowObject));
|
||||
parser.KnownTypes.Add(typeof(DeeperObjectArray_L1));
|
||||
DeeperObjectArray_L1 result = parser.Parse(@"{""Count"": 1, ""Array"": [{""Text"": ""AAAA"", ""Number"": 42}]}") as DeeperObjectArray_L1;
|
||||
Assert.False(parser.Tainted);
|
||||
Assert.Equal(1, result.Count);
|
||||
Assert.Equal("AAAA", result.Array[0].Text);
|
||||
Assert.Equal(42, result.Array[0].Number);
|
||||
}
|
||||
|
||||
public class DeeperObjectArray_L2
|
||||
{
|
||||
public string Name { get; set; }
|
||||
public List<DeeperObjectArray_L1> Objects { get; set; }
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__DeeperObjectArray_L2()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
parser.KnownTypes.Add(typeof(SwallowObject));
|
||||
parser.KnownTypes.Add(typeof(DeeperObjectArray_L1));
|
||||
parser.KnownTypes.Add(typeof(DeeperObjectArray_L2));
|
||||
DeeperObjectArray_L2 result = parser.Parse(@"{""Name"": ""Thing"", ""Objects"": [{""Count"": 1, ""Array"": [{""Text"": ""AAAA"", ""Number"": 42}]}]}") as DeeperObjectArray_L2;
|
||||
Assert.False(parser.Tainted);
|
||||
Assert.Equal("Thing", result.Name);
|
||||
Assert.Equal(1, result.Objects[0].Count);
|
||||
Assert.Equal("AAAA", result.Objects[0].Array[0].Text);
|
||||
Assert.Equal(42, result.Objects[0].Array[0].Number);
|
||||
}
|
||||
|
||||
#endregion Parse
|
||||
|
||||
#region Validity tests
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail01()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"""A JSON payload should be an object or array, not a string.""");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail02()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""Unclosed array""");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail03()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{unquoted_key: ""keys must be quoted""}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail04()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""extra comma"",]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail05()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""double extra comma"",,]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail06()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[ , ""<-- missing value""]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail07()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""Comma after the close""],");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail08()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""Extra close""]]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail09()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Extra comma"": true,}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail10()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Extra value after close"": true} ""misplaced quoted value""");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail11()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Illegal expression"": 1 + 2}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail12()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Illegal invocation"": alert()}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail13()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Numbers cannot have leading zeroes"": 013}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail14()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Numbers cannot be hex"": 0x14}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail15()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""Illegal backslash escape: \x15""]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail16()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[\naked]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail17()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""Illegal backslash escape: \017""]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail18()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[[[[[[[[[[[[[[[[[[[[""Too deep""]]]]]]]]]]]]]]]]]]]]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail19()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Missing colon"" null}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail20()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Double colon"":: null}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail21()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Comma instead of colon"", null}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail22()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""Colon instead of comma"": false]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail23()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""Bad value"", truth]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail24()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"['single quote']");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail25()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"["" tab character in string ""]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail26()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""tab\ character\ in\ string\ ""]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail27()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""line
|
||||
break""]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail28()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""line\
|
||||
break""]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail29()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[0e]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail30()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[0e+]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail31()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[0e+-1]");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail32()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{""Comma instead if closing brace"": true,");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Fail33()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[""mismatch""}");
|
||||
Assert.True(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Pass01()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[
|
||||
""JSON Test Pattern pass1"",
|
||||
{""object with 1 member"":[""array with 1 element""]},
|
||||
{},
|
||||
[],
|
||||
-42,
|
||||
true,
|
||||
false,
|
||||
null,
|
||||
{
|
||||
""integer"": 1234567890,
|
||||
""real"": -9876.543210,
|
||||
""e"": 0.123456789e-12,
|
||||
""E"": 1.234567890E+34,
|
||||
"""": 23456789012E66,
|
||||
""zero"": 0,
|
||||
""one"": 1,
|
||||
""space"": "" "",
|
||||
""quote"": ""\"""",
|
||||
""backslash"": ""\\"",
|
||||
""controls"": ""\b\f\n\r\t"",
|
||||
""slash"": ""/ & \/"",
|
||||
""alpha"": ""abcdefghijklmnopqrstuvwyz"",
|
||||
""ALPHA"": ""ABCDEFGHIJKLMNOPQRSTUVWYZ"",
|
||||
""digit"": ""0123456789"",
|
||||
""0123456789"": ""digit"",
|
||||
""special"": ""`1~!@#$%^&*()_+-={':[,]}|;.</>?"",
|
||||
""hex"": ""\u0123\u4567\u89AB\uCDEF\uabcd\uef4A"",
|
||||
""true"": true,
|
||||
""false"": false,
|
||||
""null"": null,
|
||||
""array"":[ ],
|
||||
""object"":{ },
|
||||
""address"": ""50 St. James Street"",
|
||||
""url"": ""http://www.JSON.org/"",
|
||||
""comment"": ""// /* <!-- --"",
|
||||
""# -- --> */"": "" "",
|
||||
"" s p a c e d "" :[1,2 , 3
|
||||
|
||||
,
|
||||
|
||||
4 , 5 , 6 ,7 ],""compact"":[1,2,3,4,5,6,7],
|
||||
""jsontext"": ""{\""object with 1 member\"":[\""array with 1 element\""]}"",
|
||||
""quotes"": """ \u0022 %22 0x22 034 """,
|
||||
""\/\\\""\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?""
|
||||
: ""A key can be any string""
|
||||
},
|
||||
0.5 ,98.6
|
||||
,
|
||||
99.44
|
||||
,
|
||||
|
||||
1066,
|
||||
1e1,
|
||||
0.1e1,
|
||||
1e-1,
|
||||
1e00,2e+00,2e-00
|
||||
,""rosebud""]");
|
||||
Assert.False(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Pass02()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"[[[[[[[[[[[[[[[[[[[""Not too deep""]]]]]]]]]]]]]]]]]]]");
|
||||
Assert.False(parser.Tainted);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Parse__Validity_Pass03()
|
||||
{
|
||||
JsonParser parser = new JsonParser();
|
||||
object result = parser.Parse(@"{
|
||||
""JSON Test Pattern pass3"": {
|
||||
""The outermost value"": ""must be an object or array."",
|
||||
""In this test"": ""It is an object.""
|
||||
}
|
||||
}
|
||||
");
|
||||
Assert.False(parser.Tainted);
|
||||
}
|
||||
|
||||
#endregion Validity tests
|
||||
}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net5.0</TargetFramework>
|
||||
|
||||
<IsPackable>false</IsPackable>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
|
||||
<PackageReference Include="xunit" Version="2.4.1" />
|
||||
<PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
</PackageReference>
|
||||
<PackageReference Include="coverlet.collector" Version="3.0.3">
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
</PackageReference>
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\VAR.Json\VAR.Json.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
37
VAR.Json.sln
37
VAR.Json.sln
@@ -1,37 +0,0 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 12.00
|
||||
# Visual Studio Version 16
|
||||
VisualStudioVersion = 16.0.30330.147
|
||||
MinimumVisualStudioVersion = 10.0.40219.1
|
||||
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VAR.Json", "VAR.Json\VAR.Json.csproj", "{28B3F937-145C-4FD4-A75B-A25EA4CC0428}"
|
||||
EndProject
|
||||
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Notes", "Notes", "{4C23A421-5348-48F1-8B67-A4D43E616FDE}"
|
||||
ProjectSection(SolutionItems) = preProject
|
||||
LICENSE.txt = LICENSE.txt
|
||||
README.md = README.md
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VAR.Json.Tests", "VAR.Json.Tests\VAR.Json.Tests.csproj", "{0E955F4D-49A9-40BC-94F7-7E2EDB30713B}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Any CPU = Debug|Any CPU
|
||||
Release|Any CPU = Release|Any CPU
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{28B3F937-145C-4FD4-A75B-A25EA4CC0428}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{28B3F937-145C-4FD4-A75B-A25EA4CC0428}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{28B3F937-145C-4FD4-A75B-A25EA4CC0428}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{28B3F937-145C-4FD4-A75B-A25EA4CC0428}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{0E955F4D-49A9-40BC-94F7-7E2EDB30713B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{0E955F4D-49A9-40BC-94F7-7E2EDB30713B}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{0E955F4D-49A9-40BC-94F7-7E2EDB30713B}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{0E955F4D-49A9-40BC-94F7-7E2EDB30713B}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
GlobalSection(ExtensibilityGlobals) = postSolution
|
||||
SolutionGuid = {B9700B54-1919-4B81-B123-D4D3DE74124A}
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
@@ -1,684 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Reflection;
|
||||
using System.Text;
|
||||
|
||||
namespace VAR.Json
|
||||
{
|
||||
public class JsonParser
|
||||
{
|
||||
#region Declarations
|
||||
|
||||
private const int MaxRecursiveCount = 20;
|
||||
|
||||
private ParserContext _ctx;
|
||||
private bool _tainted = false;
|
||||
|
||||
private readonly List<Type> _knownTypes = new List<Type>();
|
||||
|
||||
#endregion Declarations
|
||||
|
||||
#region Properties
|
||||
|
||||
public bool Tainted
|
||||
{
|
||||
get { return _tainted; }
|
||||
}
|
||||
|
||||
public List<Type> KnownTypes
|
||||
{
|
||||
get { return _knownTypes; }
|
||||
}
|
||||
|
||||
#endregion Properties
|
||||
|
||||
#region Private methods
|
||||
|
||||
private static readonly Dictionary<Type, PropertyInfo[]> _dictProperties = new Dictionary<Type, PropertyInfo[]>();
|
||||
|
||||
private PropertyInfo[] Type_GetProperties(Type type)
|
||||
{
|
||||
PropertyInfo[] typeProperties = null;
|
||||
if (_dictProperties.ContainsKey(type)) { typeProperties = _dictProperties[type]; }
|
||||
else
|
||||
{
|
||||
lock (_dictProperties)
|
||||
{
|
||||
if (_dictProperties.ContainsKey(type)) { typeProperties = _dictProperties[type]; }
|
||||
else
|
||||
{
|
||||
typeProperties = type.GetProperties(BindingFlags.Public | BindingFlags.OptionalParamBinding | BindingFlags.Instance);
|
||||
_dictProperties.Add(type, typeProperties);
|
||||
}
|
||||
}
|
||||
}
|
||||
return typeProperties;
|
||||
}
|
||||
|
||||
private float CompareToType(Dictionary<string, object> obj, Type type)
|
||||
{
|
||||
PropertyInfo[] typeProperties = Type_GetProperties(type);
|
||||
int count = 0;
|
||||
foreach (PropertyInfo prop in typeProperties)
|
||||
{
|
||||
if (obj.ContainsKey(prop.Name))
|
||||
{
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return ((float)count / (float)typeProperties.Length);
|
||||
}
|
||||
|
||||
private object ConvertToType(Dictionary<string, object> obj, Type type)
|
||||
{
|
||||
PropertyInfo[] typeProperties = Type_GetProperties(type);
|
||||
object newObj = ObjectActivator.CreateInstance(type);
|
||||
foreach (PropertyInfo prop in typeProperties)
|
||||
{
|
||||
if (obj.ContainsKey(prop.Name))
|
||||
{
|
||||
Type underliningType = Nullable.GetUnderlyingType(prop.PropertyType);
|
||||
Type effectiveType = underliningType ?? prop.PropertyType;
|
||||
object valueOrig = obj[prop.Name];
|
||||
object valueDest;
|
||||
if (underliningType != null && valueOrig == null)
|
||||
{
|
||||
valueDest = null;
|
||||
}
|
||||
else if (effectiveType == typeof(Guid) && valueOrig is string)
|
||||
{
|
||||
valueDest = new Guid((string)valueOrig);
|
||||
}
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
valueDest = Convert.ChangeType(obj[prop.Name], effectiveType);
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
prop.SetValue(newObj, valueDest, null);
|
||||
}
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
private object TryConvertToTypes(Dictionary<string, object> obj)
|
||||
{
|
||||
Type bestMatch = null;
|
||||
float bestMatchFactor = 0.0f;
|
||||
foreach (Type type in _knownTypes)
|
||||
{
|
||||
float matchFactor = CompareToType(obj, type);
|
||||
if (matchFactor > bestMatchFactor)
|
||||
{
|
||||
bestMatch = type;
|
||||
bestMatchFactor = matchFactor;
|
||||
}
|
||||
}
|
||||
if (bestMatch != null)
|
||||
{
|
||||
try
|
||||
{
|
||||
object newObj = ConvertToType(obj, bestMatch);
|
||||
return newObj;
|
||||
}
|
||||
catch (Exception) { } /* Nom Nom */
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
private int ParseHexShort()
|
||||
{
|
||||
int value = 0;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
char c = _ctx.Next();
|
||||
if (char.IsDigit(c))
|
||||
{
|
||||
value = (value << 4) | (c - '0');
|
||||
}
|
||||
else
|
||||
{
|
||||
c = char.ToLower(c);
|
||||
if (c >= 'a' && c <= 'f')
|
||||
{
|
||||
value = (value << 4) | ((c - 'a') + 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
private string ParseQuotedString()
|
||||
{
|
||||
StringBuilder scratch = new StringBuilder();
|
||||
char c = _ctx.SkipWhite();
|
||||
if (c == '"')
|
||||
{
|
||||
c = _ctx.Next();
|
||||
}
|
||||
do
|
||||
{
|
||||
if (c == '\\')
|
||||
{
|
||||
c = _ctx.Next();
|
||||
if (c == '"')
|
||||
{
|
||||
scratch.Append('"');
|
||||
}
|
||||
else if (c == '\\')
|
||||
{
|
||||
scratch.Append('\\');
|
||||
}
|
||||
else if (c == '/')
|
||||
{
|
||||
scratch.Append('/');
|
||||
}
|
||||
else if (c == 'b')
|
||||
{
|
||||
scratch.Append('\b');
|
||||
}
|
||||
else if (c == 'f')
|
||||
{
|
||||
scratch.Append('\f');
|
||||
}
|
||||
else if (c == 'n')
|
||||
{
|
||||
scratch.Append('\n');
|
||||
}
|
||||
else if (c == 'r')
|
||||
{
|
||||
scratch.Append('\r');
|
||||
}
|
||||
else if (c == 't')
|
||||
{
|
||||
scratch.Append('\t');
|
||||
}
|
||||
else if (c == 'u')
|
||||
{
|
||||
scratch.Append((char)ParseHexShort());
|
||||
}
|
||||
else
|
||||
{
|
||||
// StrictRules: Mark as tainted on unknown escaped character
|
||||
_tainted = true;
|
||||
}
|
||||
c = _ctx.Next();
|
||||
}
|
||||
else if (c == '"')
|
||||
{
|
||||
_ctx.Next();
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
// StrictRules: Mark as tainted on ilegal characters
|
||||
if (c == '\t' || c == '\n') { _tainted = true; }
|
||||
|
||||
scratch.Append(c);
|
||||
c = _ctx.Next();
|
||||
}
|
||||
} while (!_ctx.AtEnd());
|
||||
return scratch.ToString();
|
||||
}
|
||||
|
||||
private string ParseSingleQuotedString()
|
||||
{
|
||||
StringBuilder scratch = new StringBuilder();
|
||||
char c = _ctx.SkipWhite();
|
||||
if (c == '\'')
|
||||
{
|
||||
c = _ctx.Next();
|
||||
}
|
||||
do
|
||||
{
|
||||
if (c == '\\')
|
||||
{
|
||||
c = _ctx.Next();
|
||||
if (c == '\'')
|
||||
{
|
||||
scratch.Append('\'');
|
||||
}
|
||||
else if (c == '\\')
|
||||
{
|
||||
scratch.Append('\\');
|
||||
}
|
||||
else if (c == '/')
|
||||
{
|
||||
scratch.Append('/');
|
||||
}
|
||||
else if (c == 'b')
|
||||
{
|
||||
scratch.Append('\b');
|
||||
}
|
||||
else if (c == 'f')
|
||||
{
|
||||
scratch.Append('\f');
|
||||
}
|
||||
else if (c == 'n')
|
||||
{
|
||||
scratch.Append('\n');
|
||||
}
|
||||
else if (c == 'r')
|
||||
{
|
||||
scratch.Append('\r');
|
||||
}
|
||||
else if (c == 't')
|
||||
{
|
||||
scratch.Append('\t');
|
||||
}
|
||||
else if (c == 'u')
|
||||
{
|
||||
scratch.Append((char)ParseHexShort());
|
||||
}
|
||||
else
|
||||
{
|
||||
// StrictRules: Mark as tainted on unknown escaped character
|
||||
_tainted = true;
|
||||
}
|
||||
c = _ctx.Next();
|
||||
}
|
||||
else if (c == '\'')
|
||||
{
|
||||
_ctx.Next();
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
// StrictRules: Mark as tainted on ilegal characters
|
||||
if (c == '\t' || c == '\n') { _tainted = true; }
|
||||
|
||||
scratch.Append(c);
|
||||
c = _ctx.Next();
|
||||
}
|
||||
} while (!_ctx.AtEnd());
|
||||
return scratch.ToString();
|
||||
}
|
||||
|
||||
private string ParseString(bool mustBeQuoted = false)
|
||||
{
|
||||
char c = _ctx.SkipWhite();
|
||||
if (c == '"')
|
||||
{
|
||||
return ParseQuotedString();
|
||||
}
|
||||
if (c == '\'')
|
||||
{
|
||||
_tainted = true;
|
||||
return ParseSingleQuotedString();
|
||||
}
|
||||
if (mustBeQuoted) { _tainted = true; }
|
||||
StringBuilder scratch = new StringBuilder();
|
||||
|
||||
while (!_ctx.AtEnd()
|
||||
&& (char.IsLetter(c) || char.IsDigit(c) || c == '_'))
|
||||
{
|
||||
scratch.Append(c);
|
||||
c = _ctx.Next();
|
||||
}
|
||||
|
||||
return scratch.ToString();
|
||||
}
|
||||
|
||||
private object ParseNumber()
|
||||
{
|
||||
StringBuilder scratch = new StringBuilder();
|
||||
bool isFloat = false;
|
||||
bool isExp = false;
|
||||
int numberLenght = 0;
|
||||
int expLenght = 0;
|
||||
char c;
|
||||
c = _ctx.SkipWhite();
|
||||
|
||||
// Sign
|
||||
if (c == '-')
|
||||
{
|
||||
scratch.Append('-');
|
||||
c = _ctx.Next();
|
||||
}
|
||||
|
||||
// Integer part
|
||||
bool leadingZeroes = true;
|
||||
int leadingZeroesLenght = 0;
|
||||
while (char.IsDigit(c))
|
||||
{
|
||||
// Count leading zeroes
|
||||
if (leadingZeroes && c == '0') { leadingZeroesLenght++; }
|
||||
else { leadingZeroes = false; }
|
||||
|
||||
scratch.Append(c);
|
||||
c = _ctx.Next();
|
||||
numberLenght++;
|
||||
}
|
||||
|
||||
// StrictRules: Mark as tainted with leading zeroes
|
||||
if ((leadingZeroesLenght > 0 && leadingZeroesLenght != numberLenght) || leadingZeroesLenght > 1)
|
||||
{
|
||||
_tainted = true;
|
||||
}
|
||||
|
||||
// Decimal part
|
||||
if (c == '.')
|
||||
{
|
||||
isFloat = true;
|
||||
scratch.Append(".");
|
||||
c = _ctx.Next();
|
||||
while (char.IsDigit(c))
|
||||
{
|
||||
scratch.Append(c);
|
||||
c = _ctx.Next();
|
||||
numberLenght++;
|
||||
}
|
||||
}
|
||||
|
||||
if (numberLenght == 0)
|
||||
{
|
||||
_tainted = true;
|
||||
return null;
|
||||
}
|
||||
|
||||
// Exponential part
|
||||
if (c == 'e' || c == 'E')
|
||||
{
|
||||
isFloat = true;
|
||||
isExp = true;
|
||||
scratch.Append('E');
|
||||
c = _ctx.Next();
|
||||
if (c == '+' || c == '-')
|
||||
{
|
||||
scratch.Append(c);
|
||||
c = _ctx.Next();
|
||||
}
|
||||
while (char.IsDigit(c))
|
||||
{
|
||||
scratch.Append(c);
|
||||
c = _ctx.Next();
|
||||
numberLenght++;
|
||||
expLenght++;
|
||||
}
|
||||
}
|
||||
|
||||
if (isExp && expLenght == 0)
|
||||
{
|
||||
_tainted = true;
|
||||
return null;
|
||||
}
|
||||
|
||||
// Build number from the parsed string
|
||||
string s = scratch.ToString();
|
||||
if (isFloat)
|
||||
{
|
||||
if (numberLenght < 17)
|
||||
{
|
||||
return Convert.ToDouble(s, CultureInfo.InvariantCulture);
|
||||
}
|
||||
else
|
||||
{
|
||||
return Convert.ToDecimal(s, CultureInfo.InvariantCulture);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return Convert.ToInt32(s);
|
||||
}
|
||||
}
|
||||
|
||||
private object ParseArray(int recursiveCount = 1)
|
||||
{
|
||||
// StrictRules: Mark as tainted when MaxRecursiveCount is exceeded
|
||||
if (recursiveCount >= MaxRecursiveCount) { _tainted = true; }
|
||||
|
||||
bool correct = false;
|
||||
char c = _ctx.SkipWhite();
|
||||
List<object> array = new List<object>();
|
||||
Type arrayContentType = null;
|
||||
bool hasSameType = true;
|
||||
bool hasNulls = false;
|
||||
if (c == '[')
|
||||
{
|
||||
_ctx.Next();
|
||||
}
|
||||
bool? expectValue = null;
|
||||
do
|
||||
{
|
||||
c = _ctx.SkipWhite();
|
||||
if (c == ']')
|
||||
{
|
||||
// StrictRules: Mark as tainted when unexpected end of array
|
||||
if (expectValue == true) { _tainted = true; }
|
||||
correct = true;
|
||||
_ctx.Next();
|
||||
break;
|
||||
}
|
||||
else if (c == ',')
|
||||
{
|
||||
// StrictRules: Mark as tainted when unexpected comma on array
|
||||
if (expectValue == true || array.Count == 0) { _tainted = true; }
|
||||
|
||||
_ctx.Next();
|
||||
expectValue = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// StrictRules: Mark as tainted when unexpected value on array
|
||||
if (expectValue == false) { _tainted = true; }
|
||||
object value = ParseValue(recursiveCount + 1);
|
||||
array.Add(value);
|
||||
expectValue = false;
|
||||
|
||||
if (hasSameType)
|
||||
{
|
||||
Type valueType = value?.GetType();
|
||||
if (valueType == null) { hasNulls = true; }
|
||||
if (arrayContentType == null || arrayContentType == valueType)
|
||||
{
|
||||
arrayContentType = valueType;
|
||||
}
|
||||
else
|
||||
{
|
||||
hasSameType = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
} while (!_ctx.AtEnd());
|
||||
if (correct == false)
|
||||
{
|
||||
_tainted = true;
|
||||
}
|
||||
object result = array;
|
||||
bool isNullableType = arrayContentType?.IsClass == true;
|
||||
if (hasSameType && arrayContentType != null && (isNullableType == true || (isNullableType == false && hasNulls == false)))
|
||||
{
|
||||
var enumerableType = typeof(System.Linq.Enumerable);
|
||||
var castMethod = enumerableType.GetMethod("Cast").MakeGenericMethod(arrayContentType);
|
||||
var toListMethod = enumerableType.GetMethod("ToList").MakeGenericMethod(arrayContentType);
|
||||
IEnumerable<object> itemsToCast = array;
|
||||
var castedItems = castMethod.Invoke(null, new[] { itemsToCast });
|
||||
result = toListMethod.Invoke(null, new[] { castedItems });
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private object ParseObject(int recursiveCount = 1)
|
||||
{
|
||||
// StrictRules: Mark as tainted when MaxRecursiveCount is exceeded
|
||||
if (recursiveCount >= MaxRecursiveCount) { _tainted = true; }
|
||||
|
||||
bool correct = false;
|
||||
char c = _ctx.SkipWhite();
|
||||
Dictionary<string, object> obj = new Dictionary<string, object>();
|
||||
if (c == '{')
|
||||
{
|
||||
_ctx.Next();
|
||||
}
|
||||
string attributeName = null;
|
||||
object attributeValue;
|
||||
bool? expectedKey = null;
|
||||
bool? expectedValue = null;
|
||||
do
|
||||
{
|
||||
c = _ctx.SkipWhite();
|
||||
if (c == ':')
|
||||
{
|
||||
_ctx.Next();
|
||||
if (expectedValue == true)
|
||||
{
|
||||
attributeValue = ParseValue(recursiveCount + 1);
|
||||
obj.Add(attributeName, attributeValue);
|
||||
expectedKey = null;
|
||||
expectedValue = false;
|
||||
}
|
||||
}
|
||||
else if (c == ',')
|
||||
{
|
||||
_ctx.Next();
|
||||
_ctx.SkipWhite();
|
||||
expectedKey = true;
|
||||
expectedValue = false;
|
||||
}
|
||||
else if (c == '}')
|
||||
{
|
||||
// StrictRules: Mark as tainted on unexpected end of object
|
||||
if (expectedValue == true || expectedKey == true)
|
||||
{
|
||||
_tainted = true;
|
||||
}
|
||||
correct = true;
|
||||
_ctx.Next();
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (expectedKey != false)
|
||||
{
|
||||
attributeName = ParseString(true);
|
||||
_ctx.SkipWhite();
|
||||
expectedKey = false;
|
||||
expectedValue = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unexpected character
|
||||
_tainted = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
} while (!_ctx.AtEnd());
|
||||
if (correct == false)
|
||||
{
|
||||
_tainted = true;
|
||||
}
|
||||
object result = TryConvertToTypes(obj);
|
||||
return result;
|
||||
}
|
||||
|
||||
private object ParseValue(int recusiveCount = 1)
|
||||
{
|
||||
char c = _ctx.SkipWhite();
|
||||
object token;
|
||||
switch (c)
|
||||
{
|
||||
case '"':
|
||||
token = ParseQuotedString();
|
||||
break;
|
||||
|
||||
case '\'':
|
||||
// StrictRules: Mark as tainted when parsing single quoted strings
|
||||
_tainted = true;
|
||||
token = ParseSingleQuotedString();
|
||||
break;
|
||||
|
||||
case '{':
|
||||
token = ParseObject(recusiveCount);
|
||||
break;
|
||||
|
||||
case '[':
|
||||
token = ParseArray(recusiveCount);
|
||||
break;
|
||||
|
||||
default:
|
||||
if (char.IsDigit(c) || c == '-')
|
||||
{
|
||||
token = ParseNumber();
|
||||
}
|
||||
else
|
||||
{
|
||||
string aux = ParseString();
|
||||
if (aux.CompareTo("true") == 0)
|
||||
{
|
||||
token = true;
|
||||
}
|
||||
else if (aux.CompareTo("false") == 0)
|
||||
{
|
||||
token = false;
|
||||
}
|
||||
else if (aux.CompareTo("null") == 0)
|
||||
{
|
||||
token = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unexpected string
|
||||
if (aux.Length == 0)
|
||||
{
|
||||
_ctx.Next();
|
||||
}
|
||||
_tainted = true;
|
||||
token = null;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
return token;
|
||||
}
|
||||
|
||||
#endregion Private methods
|
||||
|
||||
#region Public methods
|
||||
|
||||
public object Parse(string text)
|
||||
{
|
||||
// Get the first object
|
||||
_ctx = new ParserContext(text);
|
||||
_tainted = false;
|
||||
_ctx.Mark();
|
||||
object obj = ParseValue();
|
||||
_ctx.SkipWhite();
|
||||
if (_ctx.AtEnd())
|
||||
{
|
||||
// StrictRules: Mark as tainted when top level is not object or array
|
||||
if (obj is string || obj is decimal || obj is int || obj is double || obj is float)
|
||||
{
|
||||
_tainted = true;
|
||||
}
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
// StrictRules: Mark as tainted when there is more content
|
||||
_tainted = true;
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
private static JsonParser _currentInstance = null;
|
||||
|
||||
public static object ParseText(string text, params Type[] knownTypes)
|
||||
{
|
||||
if (_currentInstance == null)
|
||||
{
|
||||
_currentInstance = new JsonParser();
|
||||
}
|
||||
_currentInstance.KnownTypes.Clear();
|
||||
_currentInstance.KnownTypes.AddRange(knownTypes);
|
||||
return _currentInstance.Parse(text);
|
||||
}
|
||||
|
||||
#endregion Public methods
|
||||
}
|
||||
}
|
||||
@@ -1,457 +0,0 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Reflection;
|
||||
|
||||
namespace VAR.Json
|
||||
{
|
||||
public class JsonWriterConfiguration
|
||||
{
|
||||
private bool _indent;
|
||||
public bool Indent { get { return _indent; } }
|
||||
|
||||
private bool _useTabForIndent;
|
||||
public bool UseTabForIndent { get { return _useTabForIndent; } }
|
||||
|
||||
private int _indentChars;
|
||||
public int IndentChars { get { return _indentChars; } }
|
||||
|
||||
private int _indentThresold;
|
||||
public int IndentThresold { get { return _indentThresold; } }
|
||||
|
||||
public JsonWriterConfiguration(
|
||||
bool indent = false,
|
||||
bool useTabForIndent = false,
|
||||
int indentChars = 4,
|
||||
int indentThresold = 3)
|
||||
{
|
||||
_indent = indent;
|
||||
_useTabForIndent = useTabForIndent;
|
||||
_indentChars = indentChars;
|
||||
_indentThresold = indentThresold;
|
||||
}
|
||||
|
||||
public bool Equals(JsonWriterConfiguration other)
|
||||
{
|
||||
return
|
||||
other.Indent == Indent &&
|
||||
other.UseTabForIndent == UseTabForIndent &&
|
||||
other.IndentChars == IndentChars &&
|
||||
other.IndentThresold == IndentThresold &&
|
||||
true;
|
||||
}
|
||||
|
||||
public override bool Equals(object other)
|
||||
{
|
||||
if (other is JsonWriterConfiguration)
|
||||
{
|
||||
return Equals(other as JsonWriterConfiguration);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
return _indent.GetHashCode() ^ _useTabForIndent.GetHashCode() ^ _indentChars.GetHashCode() ^ _indentThresold.GetHashCode();
|
||||
}
|
||||
}
|
||||
|
||||
public class JsonWriter
|
||||
{
|
||||
#region Declarations
|
||||
|
||||
private JsonWriterConfiguration _config = null;
|
||||
|
||||
#endregion Declarations
|
||||
|
||||
#region Creator
|
||||
|
||||
public JsonWriter(JsonWriterConfiguration config = null)
|
||||
{
|
||||
_config = config;
|
||||
if (_config == null)
|
||||
{
|
||||
_config = new JsonWriterConfiguration();
|
||||
}
|
||||
}
|
||||
|
||||
#endregion Creator
|
||||
|
||||
#region Private methods
|
||||
|
||||
private bool IsValue(object obj)
|
||||
{
|
||||
if (obj == null)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (
|
||||
(obj is float) ||
|
||||
(obj is double) ||
|
||||
(obj is short) ||
|
||||
(obj is int) ||
|
||||
(obj is long) ||
|
||||
(obj is string) ||
|
||||
(obj is bool) ||
|
||||
false)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private void WriteIndent(TextWriter textWriter, int level)
|
||||
{
|
||||
if (!_config.Indent)
|
||||
{
|
||||
return;
|
||||
}
|
||||
textWriter.Write('\n');
|
||||
if (_config.UseTabForIndent)
|
||||
{
|
||||
for (int i = 0; i < level; i++) { textWriter.Write('\t'); }
|
||||
}
|
||||
else
|
||||
{
|
||||
int n = level * _config.IndentChars;
|
||||
for (int i = 0; i < n; i++) { textWriter.Write(' '); }
|
||||
}
|
||||
}
|
||||
|
||||
private void WriteString(TextWriter textWriter, string str)
|
||||
{
|
||||
textWriter.Write('"');
|
||||
char c;
|
||||
int n = str.Length;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
c = str[i];
|
||||
if (c == '"') { textWriter.Write("\\\""); }
|
||||
else if (c == '\\') { textWriter.Write("\\\\"); }
|
||||
else if (c == '/') { textWriter.Write("\\/"); }
|
||||
else if (c == '\b') { textWriter.Write("\\b"); }
|
||||
else if (c == '\f') { textWriter.Write("\\f"); }
|
||||
else if (c == '\n') { textWriter.Write("\\n"); }
|
||||
else if (c == '\r') { textWriter.Write("\\r"); }
|
||||
else if (c == '\t') { textWriter.Write("\\t"); }
|
||||
else if (c < 32 || c >= 127) { textWriter.Write("\\u{0:X04}", (int)c); }
|
||||
else { textWriter.Write(c); }
|
||||
}
|
||||
textWriter.Write('"');
|
||||
}
|
||||
|
||||
private void WriteValue(TextWriter textWriter, object obj, List<object> parentLevels)
|
||||
{
|
||||
if (obj == null || obj is DBNull)
|
||||
{
|
||||
// NULL
|
||||
textWriter.Write("null");
|
||||
}
|
||||
else if (
|
||||
(obj is float) ||
|
||||
(obj is double) ||
|
||||
(obj is short) ||
|
||||
(obj is int) ||
|
||||
(obj is long) ||
|
||||
false)
|
||||
{
|
||||
// Numbers
|
||||
textWriter.Write(obj.ToString());
|
||||
}
|
||||
else if (obj is string)
|
||||
{
|
||||
// Strings
|
||||
WriteString(textWriter, (string)obj);
|
||||
}
|
||||
else if (obj is bool)
|
||||
{
|
||||
// Booleans
|
||||
textWriter.Write(((bool)obj) ? "true" : "false");
|
||||
}
|
||||
else if (obj is DateTime)
|
||||
{
|
||||
// DateTime
|
||||
textWriter.Write('"');
|
||||
textWriter.Write(((DateTime)obj).ToString("yyyy-MM-ddTHH:mm:ss"));
|
||||
textWriter.Write('"');
|
||||
}
|
||||
else if (obj is IDictionary)
|
||||
{
|
||||
// Objects
|
||||
WriteObject(textWriter, obj, parentLevels);
|
||||
}
|
||||
else if (obj is IEnumerable)
|
||||
{
|
||||
// Array/List
|
||||
WriteList(textWriter, obj, parentLevels);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Reflected object
|
||||
WriteReflectedObject(textWriter, obj, parentLevels);
|
||||
}
|
||||
}
|
||||
|
||||
private void WriteList(TextWriter textWriter, object obj, List<object> parentLevels)
|
||||
{
|
||||
IEnumerable list = (IEnumerable)obj;
|
||||
int n = 0;
|
||||
|
||||
// Check if it is a leaf object
|
||||
bool isLeaf = true;
|
||||
foreach (object childObj in list)
|
||||
{
|
||||
if (!IsValue(childObj))
|
||||
{
|
||||
isLeaf = false;
|
||||
}
|
||||
n++;
|
||||
}
|
||||
|
||||
// Empty
|
||||
if (n == 0)
|
||||
{
|
||||
textWriter.Write("[ ]");
|
||||
return;
|
||||
}
|
||||
|
||||
// Write array
|
||||
bool first = true;
|
||||
textWriter.Write("[ ");
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count + 1);
|
||||
}
|
||||
foreach (object childObj in list)
|
||||
{
|
||||
if (!first)
|
||||
{
|
||||
textWriter.Write(", ");
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count + 1);
|
||||
}
|
||||
}
|
||||
first = false;
|
||||
parentLevels.Add(obj);
|
||||
WriteValue(textWriter, childObj, parentLevels);
|
||||
parentLevels.Remove(obj);
|
||||
}
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count);
|
||||
}
|
||||
textWriter.Write(" ]");
|
||||
}
|
||||
|
||||
private void WriteObject(TextWriter textWriter, object obj, List<object> parentLevels)
|
||||
{
|
||||
IDictionary map = (IDictionary)obj;
|
||||
int n = map.Count;
|
||||
|
||||
// Empty
|
||||
if (map.Count == 0)
|
||||
{
|
||||
textWriter.Write("{ }");
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if it is a leaf object
|
||||
bool isLeaf = true;
|
||||
foreach (object value in map.Values)
|
||||
{
|
||||
if (!IsValue(value))
|
||||
{
|
||||
isLeaf = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Write object
|
||||
bool first = true;
|
||||
textWriter.Write("{ ");
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count + 1);
|
||||
}
|
||||
foreach (object key in map.Keys)
|
||||
{
|
||||
object value = map[key];
|
||||
if (!first)
|
||||
{
|
||||
textWriter.Write(", ");
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count + 1);
|
||||
}
|
||||
}
|
||||
first = false;
|
||||
WriteString(textWriter, Convert.ToString(key));
|
||||
textWriter.Write(": ");
|
||||
parentLevels.Add(obj);
|
||||
WriteValue(textWriter, value, parentLevels);
|
||||
parentLevels.Remove(obj);
|
||||
}
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count);
|
||||
}
|
||||
textWriter.Write(" }");
|
||||
}
|
||||
|
||||
private void WriteReflectedObject(TextWriter textWriter, object obj, List<object> parentLevels)
|
||||
{
|
||||
Type type = obj.GetType();
|
||||
PropertyInfo[] rawProperties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
|
||||
List<PropertyInfo> properties = new List<PropertyInfo>();
|
||||
foreach (PropertyInfo property in rawProperties)
|
||||
{
|
||||
if (property.CanRead == false) { continue; }
|
||||
|
||||
properties.Add(property);
|
||||
}
|
||||
int n = properties.Count;
|
||||
|
||||
// Empty
|
||||
if (n == 0)
|
||||
{
|
||||
textWriter.Write("{ }");
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if it is a leaf object
|
||||
bool isLeaf = true;
|
||||
foreach (PropertyInfo property in properties)
|
||||
{
|
||||
object value = property.GetValue(obj, null);
|
||||
if (!IsValue(value))
|
||||
{
|
||||
isLeaf = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Write object
|
||||
bool first = true;
|
||||
textWriter.Write("{ ");
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count + 1);
|
||||
}
|
||||
foreach (PropertyInfo property in properties)
|
||||
{
|
||||
object value = null;
|
||||
MethodInfo getMethod = property.GetGetMethod();
|
||||
ParameterInfo[] parameters = getMethod.GetParameters();
|
||||
if (parameters.Length == 0)
|
||||
{
|
||||
value = property.GetValue(obj, null);
|
||||
}
|
||||
if (!first)
|
||||
{
|
||||
textWriter.Write(", ");
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count + 1);
|
||||
}
|
||||
}
|
||||
first = false;
|
||||
WriteString(textWriter, property.Name);
|
||||
textWriter.Write(": ");
|
||||
parentLevels.Add(obj);
|
||||
if (value != obj && parentLevels.Contains(value) == false)
|
||||
{
|
||||
WriteValue(textWriter, value, parentLevels);
|
||||
}
|
||||
else
|
||||
{
|
||||
WriteValue(textWriter, null, parentLevels);
|
||||
}
|
||||
parentLevels.Remove(obj);
|
||||
}
|
||||
if (!isLeaf || n > _config.IndentThresold)
|
||||
{
|
||||
WriteIndent(textWriter, parentLevels.Count);
|
||||
}
|
||||
textWriter.Write(" }");
|
||||
}
|
||||
|
||||
#endregion Private methods
|
||||
|
||||
#region Public methods
|
||||
|
||||
public TextWriter Write(object obj, TextWriter textWriter)
|
||||
{
|
||||
if (textWriter == null)
|
||||
{
|
||||
textWriter = new StringWriter();
|
||||
}
|
||||
WriteValue(textWriter, obj, new List<object>());
|
||||
return textWriter;
|
||||
}
|
||||
|
||||
public string Write(object obj)
|
||||
{
|
||||
StringWriter textWriter = new StringWriter();
|
||||
WriteValue(textWriter, obj, new List<object>());
|
||||
return textWriter.ToString();
|
||||
}
|
||||
|
||||
private static Dictionary<JsonWriterConfiguration, JsonWriter> _dictInstances = new Dictionary<JsonWriterConfiguration, JsonWriter>();
|
||||
|
||||
public static string WriteObject(object obj,
|
||||
JsonWriterConfiguration config = null,
|
||||
bool indent = false,
|
||||
bool useTabForIndent = false,
|
||||
int indentChars = 4,
|
||||
int indentThresold = 3)
|
||||
{
|
||||
JsonWriter jsonWriter = null;
|
||||
|
||||
if (config != null)
|
||||
{
|
||||
if (_dictInstances.ContainsKey(config) == false)
|
||||
{
|
||||
jsonWriter = new JsonWriter(config);
|
||||
_dictInstances.Add(config, jsonWriter);
|
||||
}
|
||||
else
|
||||
{
|
||||
jsonWriter = _dictInstances[config];
|
||||
}
|
||||
return jsonWriter.Write(obj);
|
||||
}
|
||||
|
||||
foreach (KeyValuePair<JsonWriterConfiguration, JsonWriter> pair in _dictInstances)
|
||||
{
|
||||
if (
|
||||
pair.Key.Indent == indent &&
|
||||
pair.Key.UseTabForIndent == useTabForIndent &&
|
||||
pair.Key.IndentChars == indentChars &&
|
||||
pair.Key.IndentThresold == indentThresold &&
|
||||
true)
|
||||
{
|
||||
jsonWriter = pair.Value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (jsonWriter != null)
|
||||
{
|
||||
return jsonWriter.Write(obj);
|
||||
}
|
||||
|
||||
JsonWriterConfiguration jsonWriterConfiguration = new JsonWriterConfiguration(
|
||||
indent: indent,
|
||||
useTabForIndent: useTabForIndent,
|
||||
indentChars: indentChars,
|
||||
indentThresold: indentThresold);
|
||||
jsonWriter = new JsonWriter(jsonWriterConfiguration);
|
||||
_dictInstances.Add(jsonWriterConfiguration, jsonWriter);
|
||||
|
||||
return jsonWriter.Write(obj);
|
||||
}
|
||||
|
||||
#endregion Public methods
|
||||
}
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq.Expressions;
|
||||
|
||||
namespace VAR.Json
|
||||
{
|
||||
public class ObjectActivator
|
||||
{
|
||||
private static readonly Dictionary<Type, Func<object>> _creators = new Dictionary<Type, Func<object>>();
|
||||
|
||||
public static Func<object> GetLambdaNew(Type type)
|
||||
{
|
||||
if (_creators.ContainsKey(type))
|
||||
{
|
||||
return _creators[type];
|
||||
}
|
||||
|
||||
lock (_creators)
|
||||
{
|
||||
if (_creators.ContainsKey(type))
|
||||
{
|
||||
return _creators[type];
|
||||
}
|
||||
|
||||
NewExpression newExp = Expression.New(type);
|
||||
LambdaExpression lambda = Expression.Lambda(typeof(Func<object>), newExp);
|
||||
Func<object> compiledLambdaNew = (Func<object>)lambda.Compile();
|
||||
|
||||
_creators.Add(type, compiledLambdaNew);
|
||||
return _creators[type];
|
||||
}
|
||||
}
|
||||
|
||||
public static object CreateInstance(Type type)
|
||||
{
|
||||
Func<object> creator = GetLambdaNew(type);
|
||||
return creator();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,84 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace VAR.Json
|
||||
{
|
||||
public class ParserContext
|
||||
{
|
||||
#region Declarations
|
||||
|
||||
private string _text;
|
||||
private int _length;
|
||||
private int _i;
|
||||
private int _markStart;
|
||||
|
||||
#endregion Declarations
|
||||
|
||||
#region Creator
|
||||
|
||||
public ParserContext(string text)
|
||||
{
|
||||
_text = text;
|
||||
_length = text.Length;
|
||||
_i = 0;
|
||||
_markStart = 0;
|
||||
}
|
||||
|
||||
#endregion Creator
|
||||
|
||||
#region Public methods
|
||||
|
||||
public char SkipWhite()
|
||||
{
|
||||
while (_i < _length && char.IsWhiteSpace(_text[_i]))
|
||||
{
|
||||
_i++;
|
||||
}
|
||||
if (AtEnd())
|
||||
{
|
||||
return (char)0;
|
||||
}
|
||||
return _text[_i];
|
||||
}
|
||||
|
||||
public char Next()
|
||||
{
|
||||
_i++;
|
||||
if (AtEnd())
|
||||
{
|
||||
return (char)0;
|
||||
}
|
||||
return _text[_i];
|
||||
}
|
||||
|
||||
public bool AtEnd()
|
||||
{
|
||||
return _i >= _length;
|
||||
}
|
||||
|
||||
public void Mark()
|
||||
{
|
||||
_markStart = _i;
|
||||
}
|
||||
|
||||
public string GetMarked()
|
||||
{
|
||||
if (_i < _length && _markStart < _length)
|
||||
{
|
||||
return _text.Substring(_markStart, _i - _markStart);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (_markStart < _length)
|
||||
{
|
||||
return _text.Substring(_markStart, _length - _markStart);
|
||||
}
|
||||
else
|
||||
{
|
||||
return string.Empty;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endregion Public methods
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<PropertyGroup>
|
||||
<TargetFramework>netstandard2.0</TargetFramework>
|
||||
<OutputType>Library</OutputType>
|
||||
<IsPackable>true</IsPackable>
|
||||
<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup>
|
||||
<PackageId>VAR.Json</PackageId>
|
||||
<Title>VAR.Json</Title>
|
||||
<Version>1.2.2</Version>
|
||||
<Description>.Net library for JSON parsing</Description>
|
||||
<Authors>VAR</Authors>
|
||||
<Company>VAR</Company>
|
||||
<Copyright>Copyright © VAR 2016-2021</Copyright>
|
||||
<RequireLicenseAcceptance>false</RequireLicenseAcceptance>
|
||||
<PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
|
||||
<PackageProjectUrl>https://github.com/Kableado/VAR.Json</PackageProjectUrl>
|
||||
<PackageTags>JSON;JSON Library</PackageTags>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Content Include="..\LICENSE.txt" Link="LICENSE.txt" Pack="true" PackagePath=""/>
|
||||
</ItemGroup>
|
||||
<Target Name="CopyPackage" AfterTargets="Pack">
|
||||
<Copy
|
||||
SourceFiles="$(OutputPath)..\$(PackageId).$(PackageVersion).nupkg"
|
||||
DestinationFolder="Nuget\"
|
||||
/>
|
||||
</Target>
|
||||
|
||||
</Project>
|
||||
6
issues/1.yaml
Normal file
6
issues/1.yaml
Normal file
@@ -0,0 +1,6 @@
|
||||
id: 1
|
||||
title: Implementar JSONPath
|
||||
state: open
|
||||
tags: enhancement
|
||||
|
||||
|
||||
6
issues/2.yaml
Normal file
6
issues/2.yaml
Normal file
@@ -0,0 +1,6 @@
|
||||
id: 2
|
||||
title: Optimizar
|
||||
state: open
|
||||
tags: enhancement
|
||||
|
||||
|
||||
Reference in New Issue
Block a user