Update error handlers and messages

zhossain-info · zhossain-info · commit 123412bfe2d0 · 2023-11-02T08:54:17.000+06:00
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Exceptions/FunctionMismatchException.cs b/JsonSchema/RelogicLabs/JsonSchema/Exceptions/FunctionMismatchException.cs
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Time/DateTimeValidator.cs b/JsonSchema/RelogicLabs/JsonSchema/Time/DateTimeValidator.cs
@@ -8,10 +8,10 @@
 
 namespace RelogicLabs.JsonSchema.Time;
 
-internal class DateTimeValidator
+internal sealed class DateTimeValidator
 {
     public const string ISO_8601_DATE = "YYYY-MM-DD";
-    public const string ISO_8601_TIME = "YYYY-MM-DD'T'hh:mm:ss.fffZZ";
+    public const string ISO_8601_TIME = "YYYY-MM-DD'T'hh:mm:ss.FZZ";
 
     private static readonly Dictionary<string, SegmentProcessor> _Processors = new();
     private readonly DateTimeLexer _dateTimeLexer;
@@ -83,8 +83,9 @@ public void ValidateDate(string input)
     public void ValidateTime(string input)
         => Validate(input, new DateTimeContext(DateTimeType.TIME_TYPE));
 
-    public bool IsValidDate(string input)
+    public bool IsValidDate(string input, out string error)
     {
+        error = string.Empty;
         try
         {
             ValidateDate(input);
@@ -93,12 +94,14 @@ public bool IsValidDate(string input)
         catch(InvalidDateTimeException ex)
         {
             DebugUtilities.Print(ex);
+            error = ex.Message;
             return false;
         }
     }
 
-    public bool IsValidTime(string input)
+    public bool IsValidTime(string input, out string error)
     {
+        error = string.Empty;
         try
         {
             ValidateTime(input);
@@ -107,6 +110,7 @@ public bool IsValidTime(string input)
         catch(InvalidDateTimeException ex)
         {
             DebugUtilities.Print(ex);
+            error = ex.Message;
             return false;
         }
     }
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Tree/FunctionManager.cs b/JsonSchema/RelogicLabs/JsonSchema/Tree/FunctionManager.cs
@@ -9,7 +9,7 @@
 
 namespace RelogicLabs.JsonSchema.Tree;
 
-internal class FunctionManager
+internal sealed class FunctionManager
 {
     private readonly HashSet<string> _includes = new();
     private readonly Dictionary<FunctionKey, List<MethodPointer>> _functions = new();
@@ -30,8 +30,8 @@ public void AddClass(string className, Context? context = null)
         // if not FunctionBase's subclass
         if(!baseclass.IsAssignableFrom(subclass))
             throw new InvalidIncludeException(MessageFormatter
-                .FormatForSchema(CLAS03, $"{subclass.FullName} needs to inherit " +
-                                         $"{baseclass.FullName}", context));
+                .FormatForSchema(CLAS03, $"{subclass.FullName} needs to inherit {
+                    baseclass.FullName}", context));
 
         FunctionBase instance = CreateInstance(subclass, context);
         try
@@ -96,7 +96,7 @@ private Dictionary<FunctionKey, List<MethodPointer>> ExtractMethods(
         return functions;
     }
 
-    private int GetParameterCount(ICollection<ParameterInfo> parameters)
+    private static int GetParameterCount(ICollection<ParameterInfo> parameters)
     {
         foreach(var p in parameters) if(IsParams(p)) return -1;
         return parameters.Count;
@@ -111,29 +111,31 @@ private static bool IsParams(ParameterInfo parameter)
     public bool InvokeFunction(JFunction function, JNode target)
     {
         var methods = GetMethods(function);
-        string? mismatchMessage = null;
+        ParameterInfo? mismatchParameter = null;
+
         foreach(var method in methods)
         {
             var _parameters = method.Parameters;
             var _arguments = function.Arguments;
             var schemaArgs = ProcessArguments(_parameters, _arguments);
             if(schemaArgs == null) continue;
-            if(!IsMatch(_parameters[0], target))
-            {
-                mismatchMessage = $"Function {function.GetOutline()} is applicable on " +
-                                  $"{GetTypeName(_parameters[0].ParameterType)} but applied " +
-                                  $"on {GetTypeName(target.GetType())} of {target}";
-                continue;
-            }
-            return method.Invoke(function, AddTarget(schemaArgs, target));
+            if(IsMatch(_parameters[0], target)) return method.Invoke(function,
+                AddTarget(schemaArgs, target));
+            mismatchParameter = _parameters[0];
         }
-        if(mismatchMessage != null) return FailWith(new FunctionMismatchException(
-            MessageFormatter.FormatForSchema(FUNC03, mismatchMessage, function.Context)));
+        if(mismatchParameter != null)
+            return FailWith(new JsonSchemaException(new ErrorDetail(FUNC03,
+                    $"Function {function.GetOutline()} is incompatible with the target data type"),
+                new ExpectedDetail(function, $"applying to a supported data type such as {
+                    GetTypeName(mismatchParameter.ParameterType)}"),
+                new ActualDetail(target, $"applied to an unsupported data type {
+                    GetTypeName(target.GetType())} of {target}")));
+
         return FailWith(new FunctionNotFoundException(MessageFormatter
             .FormatForSchema(FUNC04, function.GetOutline(), function.Context)));
     }
 
-    private List<object> AddTarget(IList<object> arguments, JNode target)
+    private static List<object> AddTarget(IList<object> arguments, JNode target)
     {
         List<object> _arguments = new(1 + arguments.Count) { target };
         _arguments.AddRange(arguments);
@@ -152,7 +154,7 @@ private List<MethodPointer> GetMethods(JFunction function)
         return methodPointers;
     }
 
-    private List<object>? ProcessArguments(IList<ParameterInfo> parameters, IList<JNode> arguments)
+    private static List<object>? ProcessArguments(IList<ParameterInfo> parameters, IList<JNode> arguments)
     {
         List<object> _arguments = new();
         for(int i = 1; i < parameters.Count; i++)
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JAlias.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JAlias.cs
@@ -16,7 +16,7 @@ public override bool Match(JNode node)
     {
         if(!Runtime.Definitions.ContainsKey(this))
             throw new DefinitionNotFoundException(MessageFormatter
-                .FormatForSchema(DEFI02, $"Definition of {Name} not found", Context));
+                .FormatForSchema(DEFI02, $"Definition of '{Name}' not found", Context));
         return Runtime.Definitions[this].Match(node);
     }
 
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JDataType.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JDataType.cs
@@ -20,7 +20,7 @@ private JDataType(Builder builder) : base(builder)
         JsonType = NonNull(builder.JsonType);
         Nested = NonNull(builder.Nested);
         Alias = builder.Alias;
-        Children = ToList(Alias);
+        Children = AsList(Alias);
     }
 
     public override bool Match(JNode node)
@@ -32,11 +32,11 @@ public override bool Match(JNode node)
     }
 
     private bool IsMatchCurrent(JNode node)
-        => MatchCurrent(node) == Success;
+        => MatchCurrent(node, out _) == Success;
 
-    private MatchReport MatchCurrent(JNode node)
+    private MatchReport MatchCurrent(JNode node, out string error)
     {
-        var result = JsonType.Match(node) ? Success : TypeError;
+        var result = JsonType.Match(node, out error) ? Success : TypeError;
         if(Alias == null || result != Success) return result;
         Runtime.Definitions.TryGetValue(Alias, out var validator);
         if(validator == null) return AliasError;
@@ -60,10 +60,11 @@ internal bool MatchForReport(JNode node)
 
     private bool MatchForReport(JNode node, bool nested)
     {
-        var result = MatchCurrent(node);
+        var result = MatchCurrent(node, out var error);
         if(ReferenceEquals(result, TypeError)) return FailWith(
             new JsonSchemaException(
-                new ErrorDetail(TypeError.GetCode(nested), DataTypeMismatch),
+                new ErrorDetail(TypeError.GetCode(nested),
+                    FormatMessage(DataTypeMismatch, error)),
                 ExpectedDetail.AsDataTypeMismatch(this),
                 ActualDetail.AsDataTypeMismatch(node)));
         if(ReferenceEquals(result, AliasError)) return FailWith(
@@ -79,6 +80,9 @@ private bool MatchForReport(JNode node, bool nested)
         return true;
     }
 
+    private static string FormatMessage(string main, string optional)
+        => string.IsNullOrEmpty(optional) ? main : $"{main} ({optional.Uncapitalize()})";
+
     public override bool Equals(object? obj)
     {
         if(ReferenceEquals(null, obj)) return false;
@@ -103,8 +107,8 @@ public string ToString(bool baseForm)
     internal new class Builder : JNode.Builder
     {
         public JsonType? JsonType { get; init; }
-        public JAlias? Alias { get; init; }
         public bool? Nested { get; init; }
+        public JAlias? Alias { get; init; }
         public override JDataType Build() => Build(new JDataType(this));
     }
 }
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JDefinition.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JDefinition.cs
@@ -12,10 +12,10 @@ private JDefinition(Builder builder) : base(builder)
     {
         Alias = NonNull(builder.Alias);
         Validator = NonNull(builder.Validator);
-        Children = ToList(Alias, Validator);
+        Children = AsList<JNode>(Alias, Validator);
     }
 
-    public override string ToString() => $"{DefineMarker} {Alias} {Validator}";
+    public override string ToString() => $"{DefineMarker} {Alias}: {Validator}";
 
     internal new class Builder : JNode.Builder
     {
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JInclude.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JInclude.cs
@@ -20,7 +20,7 @@ public override bool Equals(object? obj)
     }
 
     public override int GetHashCode() => ClassName.GetHashCode();
-    public override string ToString() => $"{IncludeMarker} {ClassName}";
+    public override string ToString() => $"{IncludeMarker}: {ClassName}";
 
     internal new class Builder : JNode.Builder
     {
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JNode.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JNode.cs
@@ -16,7 +16,7 @@ public abstract class JNode
     public Context Context { get; }
     public virtual JNode? Parent => _relations.GetValue(this);
     public virtual IEnumerable<JNode> Children
-        { get; private protected init; } = Enumerable.Empty<JNode>();
+    { get; private protected init; } = Enumerable.Empty<JNode>();
     public ParserRuleContext Parser => Context.Parser;
     public RuntimeContext Runtime => Context.Runtime;
 
@@ -26,7 +26,7 @@ private protected JNode(Builder builder)
         Context = NonNull(builder.Context);
     }
 
-    private protected virtual T Initialize<T>() where T : JNode
+    private T Initialize<T>() where T : JNode
     {
         foreach(var c in Children) _relations[c] = this;
         return (T) this;
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JObject.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JObject.cs
@@ -10,11 +10,13 @@ namespace RelogicLabs.JsonSchema.Types;
 
 public sealed class JObject : JComposite
 {
+    private IList<JNode> _components;
     public IIndexMap<string, JProperty> Properties { get; }
 
     private JObject(Builder builder) : base(builder)
     {
         Properties = NonNull(builder.Properties);
+        _components = Properties.Select(p => p.Value).ToList().AsReadOnly();
         Children = Properties.Values;
     }
 
@@ -40,16 +42,14 @@ public override bool Match(JNode node)
                         ExpectedDetail.AsPropertyNotFound(thisProp),
                         ActualDetail.AsPropertyNotFound(node, thisProp)));
         }
-        if(unresolved.Count > 0 && !Runtime.IgnoreUndefinedProperties)
+        if(unresolved.IsEmpty() || Runtime.IgnoreUndefinedProperties) return result;
+        foreach(var key in unresolved)
         {
-            foreach(var key in unresolved)
-            {
-                var property = other.Properties[key];
-                result &= FailWith(new JsonSchemaException(
-                    new ErrorDetail(PROP06, UndefinedPropertyFound),
-                    ExpectedDetail.AsUndefinedProperty(this, property),
-                    ActualDetail.AsUndefinedProperty(property)));
-            }
+            var property = other.Properties[key];
+            result &= FailWith(new JsonSchemaException(
+                new ErrorDetail(PROP06, UndefinedPropertyFound),
+                ExpectedDetail.AsUndefinedProperty(this, property),
+                ActualDetail.AsUndefinedProperty(property)));
         }
         return result;
     }
@@ -79,11 +79,10 @@ private static bool AreKeysEqual(JProperty? p1, JProperty? p2) {
         return p1.Key == p2.Key;
     }
 
-    private JProperty? GetPropAt(IIndexMap<string, JProperty> properties, int index)
+    private static JProperty? GetPropAt(IIndexMap<string, JProperty> properties, int index)
         => index >= properties.Count ? null : properties[index];
 
-    public override IList<JNode> GetComponents() => Properties.Select(p => p.Value)
-        .ToList().AsReadOnly();
+    public override IList<JNode> GetComponents() => _components;
 
     public override bool Equals(object? obj)
     {
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JRoot.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JRoot.cs
@@ -24,7 +24,9 @@ private JRoot(Builder builder) : base(builder)
         Pragmas = builder.Pragmas;
         Definitions = builder.Definitions;
         Value = NonNull(builder.Value);
-        Children = ToList(ToList(Title, Version), Includes, Pragmas, Definitions, ToList(Value));
+        Children = new List<JNode>().AddToList(Title, Version)
+            .AddToList(Includes, Pragmas, Definitions)
+            .AddToList(Value).AsReadOnly();
     }
 
     public override bool Match(JNode node)
@@ -46,7 +48,7 @@ public override string ToString()
         return builder.ToString().Trim();
     }
 
-    private void AppendTo(StringBuilder builder, string? text)
+    private static void AppendTo(StringBuilder builder, string? text)
     {
         if(text is null || text.Length == 0) return;
         builder.Append(text).Append(NewLine);
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JTitle.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JTitle.cs
@@ -10,7 +10,7 @@ public sealed class JTitle : JDirective
     private JTitle(Builder builder) : base(builder)
         => Title = NonNull(builder.Title);
 
-    public override string ToString() => $"{TitleMarker} {Title}";
+    public override string ToString() => $"{TitleMarker}: {Title}";
 
     internal new class Builder : JNode.Builder
     {
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JValidator.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JValidator.cs
@@ -21,7 +21,8 @@ private JValidator(Builder builder) : base(builder)
         Functions = NonNull(builder.Functions);
         DataTypes = NonNull(builder.DataTypes);
         Optional = NonNull(builder.Optional);
-        Children = ToList(ToList(Value), Functions, DataTypes);
+        Children = new List<JNode>().AddToList(Value)
+            .AddToList(Functions, DataTypes).AsReadOnly();
     }
 
     public override bool Match(JNode node)
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JVersion.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JVersion.cs
@@ -10,7 +10,7 @@ public sealed class JVersion : JDirective
     private JVersion(Builder builder) : base(builder)
         => Version = NonNull(builder.Version);
 
-    public override string ToString() => $"{VersionMarker} {Version}";
+    public override string ToString() => $"{VersionMarker}: {Version}";
 
     internal new class Builder : JNode.Builder
     {
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Types/JsonType.cs b/JsonSchema/RelogicLabs/JsonSchema/Types/JsonType.cs
@@ -55,11 +55,12 @@ private JsonType(string name, Type type)
     }
 
     public override string ToString() => Name;
-    public bool Match(JNode node)
+    public bool Match(JNode node, out string error)
     {
+        error = string.Empty;
         if(!Type.IsInstanceOfType(node)) return false;
-        if(this == DATE) return _Iso8601Date.IsValidDate((JString) node);
-        if(this == TIME) return _Iso8601Time.IsValidTime((JString) node);
+        if(this == DATE) return _Iso8601Date.IsValidDate((JString) node, out error);
+        if(this == TIME) return _Iso8601Time.IsValidTime((JString) node, out error);
         return true;
     }
 }
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Utilities/CollectionExtensions.cs b/JsonSchema/RelogicLabs/JsonSchema/Utilities/CollectionExtensions.cs
@@ -83,4 +83,18 @@ public static IEnumerable<JNode> ContainsValues(
 
     public static TV? GetValue<TK, TV>(this IDictionary<TK, TV> dict, TK key)
         => dict.TryGetValue(key, out var value) ? value : default;
+
+    public static List<T> AddToList<T>(this List<T> source, params IEnumerable<T>?[] collection)
+    {
+        foreach(var e in collection) if(!ReferenceEquals(e, null)) source.AddRange(e);
+        return source;
+    }
+
+    public static List<T> AddToList<T>(this List<T> source, params T?[] collection)
+    {
+        foreach(var e in collection) if(!ReferenceEquals(e, null)) source.Add(e);
+        return source;
+    }
+
+    public static bool IsEmpty<T>(this IEnumerable<T> source) => !source.Any();
 }
diff --git a/JsonSchema/RelogicLabs/JsonSchema/Utilities/CommonUtilities.cs b/JsonSchema/RelogicLabs/JsonSchema/Utilities/CommonUtilities.cs

Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,10 @@`
`8`	`8`
`9`	`9`	`namespace RelogicLabs.JsonSchema.Time;`
`10`	`10`
`11`		`-internal class DateTimeValidator`
	`11`	`+internal sealed class DateTimeValidator`
`12`	`12`	`{`
`13`	`13`	`public const string ISO_8601_DATE = "YYYY-MM-DD";`
`14`		`- public const string ISO_8601_TIME = "YYYY-MM-DD'T'hh:mm:ss.fffZZ";`
	`14`	`+ public const string ISO_8601_TIME = "YYYY-MM-DD'T'hh:mm:ss.FZZ";`
`15`	`15`
`16`	`16`	`private static readonly Dictionary<string, SegmentProcessor> _Processors = new();`
`17`	`17`	`private readonly DateTimeLexer _dateTimeLexer;`
`@@ -83,8 +83,9 @@ public void ValidateDate(string input)`
`83`	`83`	`public void ValidateTime(string input)`
`84`	`84`	`=> Validate(input, new DateTimeContext(DateTimeType.TIME_TYPE));`
`85`	`85`
`86`		`- public bool IsValidDate(string input)`
	`86`	`+ public bool IsValidDate(string input, out string error)`
`87`	`87`	`{`
	`88`	`+ error = string.Empty;`
`88`	`89`	`try`
`89`	`90`	`{`
`90`	`91`	`ValidateDate(input);`
`@@ -93,12 +94,14 @@ public bool IsValidDate(string input)`
`93`	`94`	`catch(InvalidDateTimeException ex)`
`94`	`95`	`{`
`95`	`96`	`DebugUtilities.Print(ex);`
	`97`	`+ error = ex.Message;`
`96`	`98`	`return false;`
`97`	`99`	`}`
`98`	`100`	`}`
`99`	`101`
`100`		`- public bool IsValidTime(string input)`
	`102`	`+ public bool IsValidTime(string input, out string error)`
`101`	`103`	`{`
	`104`	`+ error = string.Empty;`
`102`	`105`	`try`
`103`	`106`	`{`
`104`	`107`	`ValidateTime(input);`
`@@ -107,6 +110,7 @@ public bool IsValidTime(string input)`
`107`	`110`	`catch(InvalidDateTimeException ex)`
`108`	`111`	`{`
`109`	`112`	`DebugUtilities.Print(ex);`
	`113`	`+ error = ex.Message;`
`110`	`114`	`return false;`
`111`	`115`	`}`
`112`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public override bool Match(JNode node)`
`16`	`16`	`{`
`17`	`17`	`if(!Runtime.Definitions.ContainsKey(this))`
`18`	`18`	`throw new DefinitionNotFoundException(MessageFormatter`
`19`		`- .FormatForSchema(DEFI02, $"Definition of {Name} not found", Context));`
	`19`	`+ .FormatForSchema(DEFI02, $"Definition of '{Name}' not found", Context));`
`20`	`20`	`return Runtime.Definitions[this].Match(node);`
`21`	`21`	`}`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ private JDataType(Builder builder) : base(builder)`
`20`	`20`	`JsonType = NonNull(builder.JsonType);`
`21`	`21`	`Nested = NonNull(builder.Nested);`
`22`	`22`	`Alias = builder.Alias;`
`23`		`- Children = ToList(Alias);`
	`23`	`+ Children = AsList(Alias);`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public override bool Match(JNode node)`
`@@ -32,11 +32,11 @@ public override bool Match(JNode node)`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`private bool IsMatchCurrent(JNode node)`
`35`		`- => MatchCurrent(node) == Success;`
	`35`	`+ => MatchCurrent(node, out _) == Success;`
`36`	`36`
`37`		`- private MatchReport MatchCurrent(JNode node)`
	`37`	`+ private MatchReport MatchCurrent(JNode node, out string error)`
`38`	`38`	`{`
`39`		`- var result = JsonType.Match(node) ? Success : TypeError;`
	`39`	`+ var result = JsonType.Match(node, out error) ? Success : TypeError;`
`40`	`40`	`if(Alias == null \|\| result != Success) return result;`
`41`	`41`	`Runtime.Definitions.TryGetValue(Alias, out var validator);`
`42`	`42`	`if(validator == null) return AliasError;`
`@@ -60,10 +60,11 @@ internal bool MatchForReport(JNode node)`
`60`	`60`
`61`	`61`	`private bool MatchForReport(JNode node, bool nested)`
`62`	`62`	`{`
`63`		`- var result = MatchCurrent(node);`
	`63`	`+ var result = MatchCurrent(node, out var error);`
`64`	`64`	`if(ReferenceEquals(result, TypeError)) return FailWith(`
`65`	`65`	`new JsonSchemaException(`
`66`		`- new ErrorDetail(TypeError.GetCode(nested), DataTypeMismatch),`
	`66`	`+ new ErrorDetail(TypeError.GetCode(nested),`
	`67`	`+ FormatMessage(DataTypeMismatch, error)),`
`67`	`68`	`ExpectedDetail.AsDataTypeMismatch(this),`
`68`	`69`	`ActualDetail.AsDataTypeMismatch(node)));`
`69`	`70`	`if(ReferenceEquals(result, AliasError)) return FailWith(`
`@@ -79,6 +80,9 @@ private bool MatchForReport(JNode node, bool nested)`
`79`	`80`	`return true;`
`80`	`81`	`}`
`81`	`82`
	`83`	`+ private static string FormatMessage(string main, string optional)`
	`84`	`+ => string.IsNullOrEmpty(optional) ? main : $"{main} ({optional.Uncapitalize()})";`
	`85`	`+`
`82`	`86`	`public override bool Equals(object? obj)`
`83`	`87`	`{`
`84`	`88`	`if(ReferenceEquals(null, obj)) return false;`
`@@ -103,8 +107,8 @@ public string ToString(bool baseForm)`
`103`	`107`	`internal new class Builder : JNode.Builder`
`104`	`108`	`{`
`105`	`109`	`public JsonType? JsonType { get; init; }`
`106`		`- public JAlias? Alias { get; init; }`
`107`	`110`	`public bool? Nested { get; init; }`
	`111`	`+ public JAlias? Alias { get; init; }`
`108`	`112`	`public override JDataType Build() => Build(new JDataType(this));`
`109`	`113`	`}`
`110`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,10 +12,10 @@ private JDefinition(Builder builder) : base(builder)`
`12`	`12`	`{`
`13`	`13`	`Alias = NonNull(builder.Alias);`
`14`	`14`	`Validator = NonNull(builder.Validator);`
`15`		`- Children = ToList(Alias, Validator);`
	`15`	`+ Children = AsList<JNode>(Alias, Validator);`
`16`	`16`	`}`
`17`	`17`
`18`		`- public override string ToString() => $"{DefineMarker} {Alias} {Validator}";`
	`18`	`+ public override string ToString() => $"{DefineMarker} {Alias}: {Validator}";`
`19`	`19`
`20`	`20`	`internal new class Builder : JNode.Builder`
`21`	`21`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public override bool Equals(object? obj)`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`public override int GetHashCode() => ClassName.GetHashCode();`
`23`		`- public override string ToString() => $"{IncludeMarker} {ClassName}";`
	`23`	`+ public override string ToString() => $"{IncludeMarker}: {ClassName}";`
`24`	`24`
`25`	`25`	`internal new class Builder : JNode.Builder`
`26`	`26`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,13 @@ namespace RelogicLabs.JsonSchema.Types;`
`10`	`10`
`11`	`11`	`public sealed class JObject : JComposite`
`12`	`12`	`{`
	`13`	`+ private IList<JNode> _components;`
`13`	`14`	`public IIndexMap<string, JProperty> Properties { get; }`
`14`	`15`
`15`	`16`	`private JObject(Builder builder) : base(builder)`
`16`	`17`	`{`
`17`	`18`	`Properties = NonNull(builder.Properties);`
	`19`	`+ _components = Properties.Select(p => p.Value).ToList().AsReadOnly();`
`18`	`20`	`Children = Properties.Values;`
`19`	`21`	`}`
`20`	`22`
`@@ -40,16 +42,14 @@ public override bool Match(JNode node)`
`40`	`42`	`ExpectedDetail.AsPropertyNotFound(thisProp),`
`41`	`43`	`ActualDetail.AsPropertyNotFound(node, thisProp)));`
`42`	`44`	`}`
`43`		`- if(unresolved.Count > 0 && !Runtime.IgnoreUndefinedProperties)`
	`45`	`+ if(unresolved.IsEmpty() \|\| Runtime.IgnoreUndefinedProperties) return result;`
	`46`	`+ foreach(var key in unresolved)`
`44`	`47`	`{`
`45`		`- foreach(var key in unresolved)`
`46`		`- {`
`47`		`- var property = other.Properties[key];`
`48`		`- result &= FailWith(new JsonSchemaException(`
`49`		`- new ErrorDetail(PROP06, UndefinedPropertyFound),`
`50`		`- ExpectedDetail.AsUndefinedProperty(this, property),`
`51`		`- ActualDetail.AsUndefinedProperty(property)));`
`52`		`- }`
	`48`	`+ var property = other.Properties[key];`
	`49`	`+ result &= FailWith(new JsonSchemaException(`
	`50`	`+ new ErrorDetail(PROP06, UndefinedPropertyFound),`
	`51`	`+ ExpectedDetail.AsUndefinedProperty(this, property),`
	`52`	`+ ActualDetail.AsUndefinedProperty(property)));`
`53`	`53`	`}`
`54`	`54`	`return result;`
`55`	`55`	`}`
`@@ -79,11 +79,10 @@ private static bool AreKeysEqual(JProperty? p1, JProperty? p2) {`
`79`	`79`	`return p1.Key == p2.Key;`
`80`	`80`	`}`
`81`	`81`
`82`		`- private JProperty? GetPropAt(IIndexMap<string, JProperty> properties, int index)`
	`82`	`+ private static JProperty? GetPropAt(IIndexMap<string, JProperty> properties, int index)`
`83`	`83`	`=> index >= properties.Count ? null : properties[index];`
`84`	`84`
`85`		`- public override IList<JNode> GetComponents() => Properties.Select(p => p.Value)`
`86`		`- .ToList().AsReadOnly();`
	`85`	`+ public override IList<JNode> GetComponents() => _components;`
`87`	`86`
`88`	`87`	`public override bool Equals(object? obj)`
`89`	`88`	`{`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,9 @@ private JRoot(Builder builder) : base(builder)`
`24`	`24`	`Pragmas = builder.Pragmas;`
`25`	`25`	`Definitions = builder.Definitions;`
`26`	`26`	`Value = NonNull(builder.Value);`
`27`		`- Children = ToList(ToList(Title, Version), Includes, Pragmas, Definitions, ToList(Value));`
	`27`	`+ Children = new List<JNode>().AddToList(Title, Version)`
	`28`	`+ .AddToList(Includes, Pragmas, Definitions)`
	`29`	`+ .AddToList(Value).AsReadOnly();`
`28`	`30`	`}`
`29`	`31`
`30`	`32`	`public override bool Match(JNode node)`
`@@ -46,7 +48,7 @@ public override string ToString()`
`46`	`48`	`return builder.ToString().Trim();`
`47`	`49`	`}`
`48`	`50`
`49`		`- private void AppendTo(StringBuilder builder, string? text)`
	`51`	`+ private static void AppendTo(StringBuilder builder, string? text)`
`50`	`52`	`{`
`51`	`53`	`if(text is null \|\| text.Length == 0) return;`
`52`	`54`	`builder.Append(text).Append(NewLine);`