feat: add cultureinfo to reader/writer settings.

src/LEGO.AsyncAPI.Readers/AsyncApiJsonDocumentReader.cs

@@ -22,9 +22,9 @@ internal class AsyncApiJsonDocumentReader : IAsyncApiReader<JsonNode, AsyncApiDi
         private readonly AsyncApiReaderSettings settings;
 
         /// <summary>
-        /// Create stream reader with custom settings if desired.
+        /// Initializes a new instance of the <see cref="AsyncApiJsonDocumentReader"/> class.
         /// </summary>
-        /// <param name="settings"></param>
+        /// <param name="settings">The settings used to read json.</param>
         public AsyncApiJsonDocumentReader(AsyncApiReaderSettings settings = null)
         {
             this.settings = settings ?? new AsyncApiReaderSettings();
@@ -39,7 +39,7 @@ public AsyncApiJsonDocumentReader(AsyncApiReaderSettings settings = null)
         public AsyncApiDocument Read(JsonNode input, out AsyncApiDiagnostic diagnostic)
         {
             diagnostic = new AsyncApiDiagnostic();
-            var context = new ParsingContext(diagnostic)
+            var context = new ParsingContext(diagnostic, this.settings)
             {
                 ExtensionParsers = this.settings.ExtensionParsers,
                 ServerBindingParsers = this.settings.Bindings.OfType<IBindingParser<IServerBinding>>().ToDictionary(b => b.BindingKey, b => b),
@@ -80,7 +80,7 @@ public AsyncApiDocument Read(JsonNode input, out AsyncApiDiagnostic diagnostic)
         public async Task<ReadResult> ReadAsync(JsonNode input, CancellationToken cancellationToken = default)
         {
             var diagnostic = new AsyncApiDiagnostic();
-            var context = new ParsingContext(diagnostic)
+            var context = new ParsingContext(diagnostic, this.settings)
             {
                 ExtensionParsers = this.settings.ExtensionParsers,
             };
@@ -130,7 +130,7 @@ public T ReadFragment<T>(JsonNode input, AsyncApiVersion version, out AsyncApiDi
             where T : IAsyncApiElement
         {
             diagnostic = new AsyncApiDiagnostic();
-            var context = new ParsingContext(diagnostic)
+            var context = new ParsingContext(diagnostic, this.settings)
             {
                 ExtensionParsers = this.settings.ExtensionParsers,
                 ServerBindingParsers = this.settings.Bindings.OfType<IBindingParser<IServerBinding>>().ToDictionary(b => b.BindingKey, b => b),

src/LEGO.AsyncAPI.Readers/AsyncApiReaderSettings.cs

@@ -26,7 +26,7 @@ public enum ReferenceResolutionSetting
     /// <summary>
     /// Configuration settings to control how AsyncApi documents are parsed.
     /// </summary>
-    public class AsyncApiReaderSettings
+    public class AsyncApiReaderSettings : AsyncApiSettings
     {
         /// <summary>
         /// Indicates how references in the source document should be handled.

src/LEGO.AsyncAPI.Readers/AsyncApiTextReader.cs

@@ -4,6 +4,7 @@ namespace LEGO.AsyncAPI.Readers
 {
     using System.IO;
     using System.Linq;
+    using System.Runtime.CompilerServices;
     using System.Text.Json;
     using System.Text.Json.Nodes;
     using System.Threading;
@@ -42,7 +43,7 @@ public AsyncApiDocument Read(TextReader input, out AsyncApiDiagnostic diagnostic
             // Parse the YAML/JSON text in the TextReader into the YamlDocument
             try
             {
-                jsonNode = LoadYamlDocument(input);
+                jsonNode = LoadYamlDocument(input, this.settings);
             }
             catch (JsonException ex)
             {
@@ -69,7 +70,7 @@ public async Task<ReadResult> ReadAsync(TextReader input, CancellationToken canc
             // Parse the YAML/JSON text in the TextReader into the YamlDocument
             try
             {
-                jsonNode = LoadYamlDocument(input);
+                jsonNode = LoadYamlDocument(input, this.settings);
             }
             catch (JsonException ex)
             {
@@ -100,7 +101,7 @@ public T ReadFragment<T>(TextReader input, AsyncApiVersion version, out AsyncApi
             // Parse the YAML/JSON
             try
             {
-                jsonNode = LoadYamlDocument(input);
+                jsonNode = LoadYamlDocument(input, this.settings);
             }
             catch (JsonException ex)
             {
@@ -118,11 +119,11 @@ public T ReadFragment<T>(TextReader input, AsyncApiVersion version, out AsyncApi
         /// </summary>
         /// <param name="input">Stream containing YAML formatted text.</param>
         /// <returns>Instance of a YamlDocument.</returns>
-        static JsonNode LoadYamlDocument(TextReader input)
+        static JsonNode LoadYamlDocument(TextReader input, AsyncApiReaderSettings settings)
         {
             var yamlStream = new YamlStream();
             yamlStream.Load(input);
-            return yamlStream.Documents.First().ToJsonNode();
+            return yamlStream.Documents.First().ToJsonNode(settings);
         }
     }
 }

src/LEGO.AsyncAPI.Readers/Exceptions/AsyncApiUnsupportedSpecVersionException.cs

@@ -11,23 +11,25 @@ namespace LEGO.AsyncAPI.Readers.Exceptions
     [Serializable]
     public class AsyncApiUnsupportedSpecVersionException : Exception
     {
-        const string MessagePattern = "AsyncApi specification version '{0}' is not supported.";
+        private const string MessagePattern = "AsyncApi specification version '{0}' is not supported.";
 
         /// <summary>
-        /// Initializes the <see cref="AsyncApiUnsupportedSpecVersionException"/> class with a specification version.
+        /// Initializes a new instance of the <see cref="AsyncApiUnsupportedSpecVersionException"/> class.
         /// </summary>
         /// <param name="specificationVersion">Version that caused this exception to be thrown.</param>
+        /// <param name="settings">The settings used for reading and writing.</param>
         public AsyncApiUnsupportedSpecVersionException(string specificationVersion)
             : base(string.Format(CultureInfo.InvariantCulture, MessagePattern, specificationVersion))
         {
             this.SpecificationVersion = specificationVersion;
         }
 
         /// <summary>
-        /// Initializes the <see cref="AsyncApiUnsupportedSpecVersionException"/> class with a specification version and
+        /// Initializes a new instance of the <see cref="AsyncApiUnsupportedSpecVersionException"/> class.
         /// inner exception.
         /// </summary>
         /// <param name="specificationVersion">Version that caused this exception to be thrown.</param>
+        /// <param name="settings">The setting used for reading and writing</param>
         /// <param name="innerException">Inner exception that caused this exception to be thrown.</param>
         public AsyncApiUnsupportedSpecVersionException(string specificationVersion, Exception innerException)
             : base(string.Format(CultureInfo.InvariantCulture, MessagePattern, specificationVersion), innerException)

src/LEGO.AsyncAPI.Readers/ParseNodes/MapNode.cs

@@ -8,6 +8,7 @@ namespace LEGO.AsyncAPI.Readers.ParseNodes
     using System.Linq;
     using System.Text.Json;
     using System.Text.Json.Nodes;
+    using LEGO.AsyncAPI.Exceptions;
     using LEGO.AsyncAPI.Models;
     using LEGO.AsyncAPI.Models.Interfaces;
     using LEGO.AsyncAPI.Readers.Exceptions;
@@ -18,7 +19,7 @@ public class MapNode : ParseNode, IEnumerable<PropertyNode>
         private readonly List<PropertyNode> nodes;
 
         public MapNode(ParsingContext context, string jsonString)
-            : this(context, JsonHelper.ParseJsonString(jsonString))
+            : this(context, JsonNode.Parse(jsonString))
         {
         }
 
@@ -196,7 +197,7 @@ public string GetReferencePointer()
                 return null;
             }
 
-            return refNode.GetScalarValue();
+            return this.ToScalarValue(refNode);
         }
 
         public string GetScalarValue(ValueNode key)
@@ -205,12 +206,18 @@ public string GetScalarValue(ValueNode key)
                 ? jsonValue
                 : throw new AsyncApiReaderException($"Expected scalar value while parsing {key.GetScalarValue()}", this.Context);
 
-            return scalarNode.GetScalarValue();
+            return this.ToScalarValue(scalarNode);
         }
 
         public override AsyncApiAny CreateAny()
         {
             return new AsyncApiAny(this.node);
         }
+
+        private string ToScalarValue(JsonNode node)
+        {
+            var scalarNode = node is JsonValue value ? value : throw new AsyncApiException($"Expected scalar value");
+            return Convert.ToString(scalarNode.GetValue<object>(), this.Context.Settings.CultureInfo);
+        }
     }
 }

src/LEGO.AsyncAPI.Readers/ParseNodes/ValueNode.cs

@@ -2,8 +2,10 @@
 
 namespace LEGO.AsyncAPI.Readers.ParseNodes
 {
+    using LEGO.AsyncAPI.Exceptions;
     using LEGO.AsyncAPI.Models;
     using LEGO.AsyncAPI.Readers.Exceptions;
+    using System;
     using System.Text.Json.Nodes;
 
     public class ValueNode : ParseNode
@@ -26,7 +28,9 @@ public override string GetScalarValue()
         {
             if (this.cachedScalarValue == null)
             {
-                this.cachedScalarValue = this.node.GetScalarValue();
+                // TODO: Update this property to use the .ToString() or JsonReader. 
+                var scalarNode = this.node is JsonValue value ? value : throw new AsyncApiException($"Expected scalar value");
+                this.cachedScalarValue = Convert.ToString(scalarNode.GetValue<object>(), this.Context.Settings.CultureInfo);
             }
 
             return this.cachedScalarValue;

src/LEGO.AsyncAPI.Readers/ParsingContext.cs

@@ -39,9 +39,30 @@ internal Dictionary<string, Func<AsyncApiAny, IAsyncApiExtension>> ExtensionPars
 
         public AsyncApiDiagnostic Diagnostic { get; }
 
+        /// <summary>
+        /// Gets the settings used fore reading json.  
+        /// </summary>
+        public AsyncApiReaderSettings Settings { get; }
+
+        ///// <summary>
+        ///// Initializes a new instance of the <see cref="ParsingContext"/> class.
+        ///// </summary>
+        /// <param name="diagnostic">The diagnostics.</param>
+        [Obsolete($"Please use the overloaded version that takes in an instance of {nameof(AsyncApiReaderSettings)} isntead.")]
         public ParsingContext(AsyncApiDiagnostic diagnostic)
+            : this(diagnostic, new AsyncApiReaderSettings())
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ParsingContext"/> class.
+        /// </summary>
+        /// <param name="diagnostic">The diagnostics.</param>
+        /// <param name="settings">The settings used to read json.</param>
+        public ParsingContext(AsyncApiDiagnostic diagnostic, AsyncApiReaderSettings settings)
         {
             this.Diagnostic = diagnostic;
+            this.Settings = settings;
         }
 
         internal AsyncApiDocument Parse(JsonNode jsonNode)

src/LEGO.AsyncAPI.Readers/V2/AsyncApiSchemaDeserializer.cs

@@ -50,14 +50,14 @@ public class JsonSchemaDeserializer
                 "multipleOf",
                 (a, n) =>
                 {
-                    a.MultipleOf = double.Parse(n.GetScalarValue(), NumberStyles.Float, CultureInfo.InvariantCulture);
+                    a.MultipleOf = double.Parse(n.GetScalarValue(), NumberStyles.Float, n.Context.Settings.CultureInfo);
                 }
             },
             {
                 "maximum",
                 (a, n) =>
                 {
-                    a.Maximum = double.Parse(n.GetScalarValue(), NumberStyles.Float, CultureInfo.InvariantCulture);
+                    a.Maximum = double.Parse(n.GetScalarValue(), NumberStyles.Float, n.Context.Settings.CultureInfo);
                 }
             },
             {
@@ -67,37 +67,37 @@ public class JsonSchemaDeserializer
                 "minimum",
                 (a, n) =>
                 {
-                    a.Minimum = double.Parse(n.GetScalarValue(), NumberStyles.Float, CultureInfo.InvariantCulture);
+                    a.Minimum = double.Parse(n.GetScalarValue(), NumberStyles.Float, n.Context.Settings.CultureInfo);
                 }
             },
             {
                 "exclusiveMinimum", (a, n) => { a.ExclusiveMinimum = bool.Parse(n.GetScalarValue()); }
             },
             {
-                "maxLength", (a, n) => { a.MaxLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture); }
+                "maxLength", (a, n) => { a.MaxLength = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
             },
             {
-                "minLength", (a, n) => { a.MinLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture); }
+                "minLength", (a, n) => { a.MinLength = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
             },
             {
                 "pattern", (a, n) => { a.Pattern = n.GetScalarValue(); }
             },
             {
-                "maxItems", (a, n) => { a.MaxItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture); }
+                "maxItems", (a, n) => { a.MaxItems = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
             },
             {
-                "minItems", (a, n) => { a.MinItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture); }
+                "minItems", (a, n) => { a.MinItems = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
             },
             {
                 "uniqueItems", (a, n) => { a.UniqueItems = bool.Parse(n.GetScalarValue()); }
             },
             {
                 "maxProperties",
-                (a, n) => { a.MaxProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture); }
+                (a, n) => { a.MaxProperties = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
             },
             {
                 "minProperties",
-                (a, n) => { a.MinProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture); }
+                (a, n) => { a.MinProperties = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
             },
             {
                 "enum", (a, n) => { a.Enum = n.CreateListOfAny(); }

src/LEGO.AsyncAPI.Readers/YamlConverter.cs

@@ -10,55 +10,55 @@ namespace LEGO.AsyncAPI.Readers
 
     internal static class YamlConverter
     {
-        public static JsonNode ToJsonNode(this YamlDocument yamlDocument)
+        public static JsonNode ToJsonNode(this YamlDocument yamlDocument, AsyncApiReaderSettings settings)
         {
-            return yamlDocument.RootNode.ToJsonNode();
+            return yamlDocument.RootNode.ToJsonNode(settings);
         }
 
-        public static JsonObject ToJsonObject(this YamlMappingNode yamlMappingNode)
+        public static JsonObject ToJsonObject(this YamlMappingNode yamlMappingNode, AsyncApiReaderSettings settings)
         {
             var node = new JsonObject();
             foreach (var keyValuePair in yamlMappingNode)
             {
                 var key = ((YamlScalarNode)keyValuePair.Key).Value!;
-                node[key] = keyValuePair.Value.ToJsonNode();
+                node[key] = keyValuePair.Value.ToJsonNode(settings);
             }
 
             return node;
         }
 
-        public static JsonArray ToJsonArray(this YamlSequenceNode yaml)
+        public static JsonArray ToJsonArray(this YamlSequenceNode yaml, AsyncApiReaderSettings settings)
         {
             var node = new JsonArray();
             foreach (var value in yaml)
             {
-                node.Add(value.ToJsonNode());
+                node.Add(value.ToJsonNode(settings));
             }
 
             return node;
         }
 
-        public static JsonNode ToJsonNode(this YamlNode yaml)
+        public static JsonNode ToJsonNode(this YamlNode yaml, AsyncApiReaderSettings settings)
         {
             return yaml switch
             {
-                YamlMappingNode map => map.ToJsonObject(),
-                YamlSequenceNode seq => seq.ToJsonArray(),
-                YamlScalarNode scalar => scalar.ToJsonValue(),
+                YamlMappingNode map => map.ToJsonObject(settings),
+                YamlSequenceNode seq => seq.ToJsonArray(settings),
+                YamlScalarNode scalar => scalar.ToJsonValue(settings),
                 _ => throw new NotSupportedException("This yaml isn't convertible to JSON"),
             };
         }
 
-        private static JsonValue ToJsonValue(this YamlScalarNode yaml)
+        private static JsonValue ToJsonValue(this YamlScalarNode yaml, AsyncApiReaderSettings settings)
         {
             switch (yaml.Style)
             {
                 case ScalarStyle.Plain:
-                    return decimal.TryParse(yaml.Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var d)
+                    return decimal.TryParse(yaml.Value, NumberStyles.Float, settings.CultureInfo, out var d)
                         ? JsonValue.Create(d)
                         : bool.TryParse(yaml.Value, out var b)
                             ? JsonValue.Create(b)
-                            : JsonValue.Create(yaml.Value)!;
+                            : JsonValue.Create(yaml.Value) !;
                 case ScalarStyle.SingleQuoted:
                 case ScalarStyle.DoubleQuoted:
                 case ScalarStyle.Literal: