Update and optimize pragma handlers

Author: zhossain-info

JsonSchema/RelogicLabs/JsonSchema/Tree/PragmaDescriptor.cs

@@ -9,7 +9,7 @@ internal abstract class PragmaDescriptor
     public static readonly PragmaProfile<bool> IgnoreUndefinedProperties
         = new(nameof(IgnoreUndefinedProperties), typeof(JBoolean), false);
     public static readonly PragmaProfile<double> FloatingPointTolerance
-        = new(nameof(FloatingPointTolerance), typeof(JNumber), 1E-7);
+        = new(nameof(FloatingPointTolerance), typeof(JNumber), 1E-10);
     public static readonly PragmaProfile<bool> IgnoreObjectPropertyOrder
         = new(nameof(IgnoreObjectPropertyOrder), typeof(JBoolean), true);
 

JsonSchema/RelogicLabs/JsonSchema/Tree/PragmaManager.cs

@@ -0,0 +1,60 @@
+using RelogicLabs.JsonSchema.Exceptions;
+using RelogicLabs.JsonSchema.Message;
+using RelogicLabs.JsonSchema.Types;
+using static RelogicLabs.JsonSchema.Message.ErrorCode;
+
+namespace RelogicLabs.JsonSchema.Tree;
+
+internal class PragmaManager
+{
+    public const string IGNORE_UNDEFINED_PROPERTIES = "IgnoreUndefinedProperties";
+    public const string FLOATING_POINT_TOLERANCE = "FloatingPointTolerance";
+    public const string IGNORE_OBJECT_PROPERTY_ORDER = "IgnoreObjectPropertyOrder";
+
+    private readonly Dictionary<string, JPragma> _pragmas = new();
+
+    public bool IgnoreUndefinedProperties { get; private set; }
+        = PragmaDescriptor.IgnoreUndefinedProperties.DefaultValue;
+    public double FloatingPointTolerance { get; private set; }
+        = PragmaDescriptor.FloatingPointTolerance.DefaultValue;
+    public bool IgnoreObjectPropertyOrder { get; private set; }
+        = PragmaDescriptor.IgnoreObjectPropertyOrder.DefaultValue;
+
+    public JPragma AddPragma(JPragma pragma) {
+        if(_pragmas.ContainsKey(pragma.Name))
+            throw new DuplicatePragmaException(MessageFormatter.FormatForSchema(
+                PRAG03, $"Duplication found for {pragma.GetOutline()}", pragma.Context));
+        _pragmas.Add(pragma.Name, pragma);
+        SetPragmaValue(pragma.Name, pragma.Value);
+        return pragma;
+    }
+
+    private void SetPragmaValue(string name, JPrimitive value) {
+        switch(name) {
+            case IGNORE_UNDEFINED_PROPERTIES:
+                IgnoreUndefinedProperties = ((IPragmaValue<bool>) value).Value;
+                break;
+            case FLOATING_POINT_TOLERANCE:
+                FloatingPointTolerance = ((IPragmaValue<double>) value).Value;
+                break;
+            case IGNORE_OBJECT_PROPERTY_ORDER:
+                IgnoreObjectPropertyOrder = ((IPragmaValue<bool>) value).Value;
+                break;
+        }
+    }
+
+    public T GetPragmaValue<T>(string name)
+    {
+        var entry = PragmaDescriptor.From(name);
+        _pragmas.TryGetValue(entry!.Name, out var pragma);
+        return pragma == null
+            ? ((PragmaProfile<T>) entry).DefaultValue
+            : ((IPragmaValue<T>) pragma.Value).Value;
+    }
+
+    public JPragma? GetPragma(string name) {
+        var entry = PragmaDescriptor.From(name);
+        _pragmas.TryGetValue(entry!.Name, out var pragma);
+        return pragma;
+    }
+}

JsonSchema/RelogicLabs/JsonSchema/Tree/RuntimeContext.cs

@@ -8,54 +8,38 @@ namespace RelogicLabs.JsonSchema.Tree;
 public class RuntimeContext
 {
     private readonly FunctionManager _functionManager;
-    
+    private readonly PragmaManager _pragmaManager;
+
     internal MessageFormatter MessageFormatter { get; set; }
     public bool ThrowException { get; set; }
-    public Dictionary<string, JPragma> Pragmas { get; }
     public Dictionary<JAlias, JValidator> Definitions { get; }
     public Queue<Exception> Exceptions { get; }
-    
-    public bool IgnoreUndefinedProperties 
-        => GetPragmaValue<bool>(nameof(IgnoreUndefinedProperties));
-    public double FloatingPointTolerance 
-        => GetPragmaValue<double>(nameof(FloatingPointTolerance));
-    public bool IgnoreObjectPropertyOrder 
-        => GetPragmaValue<bool>(nameof(IgnoreObjectPropertyOrder));
+
+    public bool IgnoreUndefinedProperties => _pragmaManager.IgnoreUndefinedProperties;
+    public double FloatingPointTolerance => _pragmaManager.FloatingPointTolerance;
+    public bool IgnoreObjectPropertyOrder => _pragmaManager.IgnoreObjectPropertyOrder;
+
 
     internal RuntimeContext(MessageFormatter messageFormatter, bool throwException)
     {
         _functionManager = new FunctionManager(this);
+        _pragmaManager = new PragmaManager();
         MessageFormatter = messageFormatter;
         ThrowException = throwException;
-        Pragmas = new Dictionary<string, JPragma>();
         Definitions = new Dictionary<JAlias, JValidator>();
         Exceptions = new Queue<Exception>();
     }
-    
-    private T GetPragmaValue<T>(string name)
-    {
-        var entry = PragmaDescriptor.From(name);
-        Pragmas.TryGetValue(entry!.Name, out var pragma);
-        return pragma == null ? ((PragmaProfile<T>) entry).DefaultValue 
-            : ((IPragmaValue<T>) pragma.Value).Value;
-    }
-    
-    public JPragma AddPragma(JPragma pragma)
-    {
-        if(Pragmas.ContainsKey(pragma.Name)) 
-            throw new DuplicatePragmaException(MessageFormatter.FormatForSchema(
-                PRAG03, $"Duplication found for {pragma.GetOutline()}", pragma.Context));
-        Pragmas.Add(pragma.Name, pragma);
-        return pragma;
-    }
+
+    public JPragma AddPragma(JPragma pragma) => _pragmaManager.AddPragma(pragma);
+    public T GetPragmaValue<T>(string name) => _pragmaManager.GetPragmaValue<T>(name);
 
     public JInclude AddClass(JInclude include)
     {
         AddClass(include.ClassName, include.Context);
         return include;
     }
 
-    public void AddClass(string className, Context? context = null) 
+    public void AddClass(string className, Context? context = null)
         => _functionManager.AddClass(className, context);
 
     public bool InvokeFunction(JFunction function, JNode target)
@@ -66,15 +50,15 @@ public JDefinition AddDefinition(JDefinition definition)
         if(Definitions.TryGetValue(definition.Alias, out var previous))
             throw new DuplicateDefinitionException(MessageFormatter.FormatForSchema(
                 DEFI01, $"Duplicate definition of {definition.Alias
-                } is found and already defined as {previous.GetOutline()}", 
+                } is found and already defined as {previous.GetOutline()}",
                 definition.Context));
         Definitions.Add(definition.Alias, definition.Validator);
         return definition;
     }
-    
-    internal bool AreEqual(double value1, double value2) 
+
+    internal bool AreEqual(double value1, double value2)
         => Math.Abs(value1 - value2) < FloatingPointTolerance;
-    
+
     internal bool FailWith(Exception exception)
     {
         if(ThrowException) throw exception;

JsonSchema/RelogicLabs/JsonSchema/Types/JBoolean.cs

@@ -32,5 +32,6 @@ public override bool Equals(object? obj)
 
     public override JsonType Type => JsonType.BOOLEAN;
     public override int GetHashCode() => Value.GetHashCode();
+    public static implicit operator bool(JBoolean @bool) => @bool.Value;
     public override string ToString() => Value.ToString().ToLower();
 }