Пример #1
0
        public void ParseTest()
        {
            var json = "{";

            Assert.Catch(typeof(JsonParseException), () => JsonParser.Parse(json));
        }
Пример #2
0
 public static ListTreeNode <JsonValue> ParseAsJson(this string json)
 {
     return(JsonParser.Parse(json));
 }
Пример #3
0
 public static ListTreeNode <JsonValue> ParseAsJson(this byte[] bytes)
 {
     return(JsonParser.Parse(new Utf8String(bytes)));
 }
Пример #4
0
 public static ListTreeNode <JsonValue> ParseAsJson(this ArraySegment <byte> bytes)
 {
     return(JsonParser.Parse(new Utf8String(bytes)));
 }
Пример #5
0
        public void Parse(IFileSystemAccessor fs, ListTreeNode <JsonValue> root, string Key)
        {
            m_context.Push(Key);

            var compositionType = default(CompositionType);
            var composition     = new List <JsonSchema>();

            foreach (var kv in root.ObjectItems())
            {
                switch (kv.Key.GetString())
                {
                case "$schema":
                    Schema = kv.Value.GetString();
                    break;

                case "$ref":
                {
                    var refFs = fs.Get(kv.Value.GetString());

                    // parse JSON
                    var json    = refFs.ReadAllText();
                    var refRoot = JsonParser.Parse(json);

                    Parse(refFs, refRoot, "$ref");
                }
                break;

                    #region Annotation
                case "title":
                    Title = kv.Value.GetString();
                    break;

                case "description":
                    Description = kv.Value.GetString();
                    break;

                case "default":
                    Default = kv.Value;
                    break;
                    #endregion

                    #region Validation
                // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
                case "type":
                    if (Validator == null)
                    {
                        Validator = JsonSchemaValidatorFactory.Create(kv.Value.GetString());
                    }
                    break;

                case "enum":
                    Validator = JsonEnumValidator.Create(kv.Value);
                    break;

                case "const":
                    break;
                    #endregion

                    #region Composite
                // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.7
                case "oneOf":
                    break;

                case "not":
                    break;

                case "anyOf":     // composition
                case "allOf":     // composition
                {
                    compositionType = (CompositionType)Enum.Parse(typeof(CompositionType), kv.Key.GetString(), true);
                    foreach (var item in kv.Value.ArrayItems())
                    {
                        if (item.ContainsKey(s_ref))
                        {
                            var sub = JsonSchema.ParseFromPath(fs.Get(item[s_ref].GetString()));
                            composition.Add(sub);
                        }
                        else
                        {
                            var sub = new JsonSchema();
                            sub.Parse(fs, item, compositionType.ToString());
                            composition.Add(sub);
                        }
                    }
                    Composite(compositionType, composition);
                }
                break;
                    #endregion

                // http://json-schema.org/latest/json-schema-validation.html#rfc.section.7
                case "format":
                    break;

                    #region Gltf
                case "gltf_detailedDescription":
                    break;

                case "gltf_webgl":
                    break;

                case "gltf_uriType":
                    break;
                    #endregion

                default:
                {
                    if (Validator != null)
                    {
                        if (Validator.FromJsonSchema(fs, kv.Key.GetString(), kv.Value))
                        {
                            continue;
                        }
                    }
                    throw new NotImplementedException(string.Format("unknown key: {0}", kv.Key));
                }
                }
            }
            m_context.Pop();

            if (Validator == null)
            {
                SkipComparison = true;
            }
        }