feat!: full v3 support (#8)

BREAKING CHANGE: All models have changed to reflect v3.0

Author: VisualBean

Common.Build.props

@@ -2,7 +2,7 @@
   <!-- Common Properties used by all assemblies -->
   <PropertyGroup>
     <LangVersion>10</LangVersion>
-    <TargetFrameworks>netstandard2.0;net8</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1;net8</TargetFrameworks>
     <ImplicitUsings>disable</ImplicitUsings>
     <Company>ByteBard</Company>
     <PackageProjectUrl>https://github.com/ByteBardOrg/AsyncAPI.NET</PackageProjectUrl>

src/ByteBard.AsyncAPI.Readers/AsyncApiReaderSettings.cs

@@ -71,10 +71,5 @@ public ICollection<IBindingParser<IBinding>>
         /// External reference reader implementation provided by users for reading external resources.
         /// </summary>
         public IStreamLoader ExternalReferenceLoader { get; set; } = null;
-
-        /// <summary>
-        /// URL where relative references should be resolved from if.
-        /// </summary>
-        public Uri BaseUrl { get; set; }
     }
 }

src/ByteBard.AsyncAPI.Readers/AsyncApiReferenceHostDocumentResolver.cs

@@ -6,16 +6,15 @@
 	  <PackageId>ByteBard.AsyncAPI.NET.Readers</PackageId>
 	  <AssemblyName>ByteBard.AsyncAPI.Readers</AssemblyName>
 	  <RootNamespace>ByteBard.AsyncAPI.Readers</RootNamespace>
-	  <TargetFrameworks>netstandard2.0;net8</TargetFrameworks>
   </PropertyGroup>	
 
   <ItemGroup>
-    <PackageReference Include="JsonPointer.Net" Version="5.0.2" />
+    <PackageReference Include="JsonPointer.Net" Version="5.3.1" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="System.Text.Json" Version="8.0.5" Condition="'$(TargetFramework)' == 'netstandard2.0'" />
+    <PackageReference Include="System.Text.Json" Version="9.0.1" Condition="'$(TargetFramework)' == 'netstandard2.1'" />
     <PackageReference Include="YamlDotNet" Version="13.0.1" />
   </ItemGroup>
 

src/ByteBard.AsyncAPI.Readers/ByteBard.AsyncAPI.Readers.csproj

@@ -38,4 +38,4 @@ public static IAsyncApiExtension LoadExtension(string name, ParseNode node)
             return node.CreateAny();
         }
     }
-}
+}

….AsyncAPI.Readers/V2/ExtensionHelpers.cs …ard.AsyncAPI.Readers/ExtensionHelpers.cssrc/ByteBard.AsyncAPI.Readers/V2/ExtensionHelpers.cs renamed to src/ByteBard.AsyncAPI.Readers/ExtensionHelpers.cs src/ByteBard.AsyncAPI.Readers/V2/ExtensionHelpers.cs renamed to src/ByteBard.AsyncAPI.Readers/ExtensionHelpers.cs

@@ -50,6 +50,17 @@ public override List<T> CreateSimpleList<T>(Func<ValueNode, T> map)
             return this.nodeList.Select(n => map(new ValueNode(this.Context, n))).ToList();
         }
 
+        public override HashSet<T> CreateSimpleSet<T>(Func<ValueNode, T> map)
+        {
+            if (this.nodeList == null)
+            {
+                throw new AsyncApiReaderException(
+                    $"Expected list while parsing {typeof(T).Name}");
+            }
+
+            return this.nodeList.Select(n => map(new ValueNode(this.Context, n))).ToHashSet();
+        }
+
         public IEnumerator<ParseNode> GetEnumerator()
         {
             return this.nodeList.Select(n => Create(this.Context, n)).ToList().GetEnumerator();

src/ByteBard.AsyncAPI.Readers/ParseNodes/ListNode.cs

@@ -50,6 +50,42 @@ public PropertyNode this[string key]
             }
         }
 
+        public override Dictionary<string, T> CreateMap<T>(Func<string, string> keySelector, Func<MapNode, string, T> map)
+        {
+            var jsonMap = this.node;
+            if (jsonMap == null)
+            {
+                throw new AsyncApiReaderException($"Expected map while parsing {typeof(T).Name}", this.Context);
+            }
+
+            var nodes = jsonMap.Select(
+                n =>
+                {
+                    var originalKey = n.Key;
+                    var newKey = keySelector(originalKey);
+                    T value;
+                    try
+                    {
+                        this.Context.StartObject(originalKey);
+                        value = n.Value is JsonObject
+                          ? map(new MapNode(this.Context, n.Value), originalKey)
+                          : default(T);
+                    }
+                    finally
+                    {
+                        this.Context.EndObject();
+                    }
+
+                    return new
+                    {
+                        key = newKey,
+                        value,
+                    };
+                });
+
+            return nodes.ToDictionary(k => k.key, v => v.value);
+        }
+
         public override Dictionary<string, T> CreateMap<T>(Func<MapNode, T> map)
         {
             var jsonMap = this.node;
@@ -207,14 +243,23 @@ public override AsyncApiAny CreateAny()
             return new AsyncApiAny(this.node);
         }
 
-        public void ParseFields<T>(ref T parentInstance, IDictionary<string, Action<T, ParseNode>> fixedFields, IDictionary<Func<string, bool>, Action<T, string, ParseNode>> patternFields)
+        public void ParseFields<T>(T parentInstance, IDictionary<string, Action<T, ParseNode>> fixedFields, IDictionary<Func<string, bool>, Action<T, string, ParseNode>> patternFields)
         {
             foreach (var propertyNode in this)
             {
                 propertyNode.ParseField(parentInstance, fixedFields, patternFields);
             }
         }
 
+        // Parse only patternfields on top.
+        public void ParseFields<T>(T parentInstance, IDictionary<Func<string, bool>, Action<T, string, ParseNode>> patternFields)
+        {
+            foreach (var propertyNode in this)
+            {
+                propertyNode.ParseField(parentInstance, patternFields);
+            }
+        }
+
         private string ToScalarValue(JsonNode node)
         {
             var scalarNode = node is JsonValue value ? value : throw new AsyncApiException($"Expected scalar value");

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

@@ -46,6 +46,11 @@ public virtual List<T> CreateList<T>(Func<MapNode, T> map)
             throw new AsyncApiReaderException("Cannot create list from this type of node.", this.Context);
         }
 
+        public virtual Dictionary<string, T> CreateMap<T>(Func<string, string> keySelector, Func<MapNode, string, T> map)
+        {
+            throw new AsyncApiReaderException("Cannot create map from this type of node.", this.Context);
+        }
+
         public virtual Dictionary<string, T> CreateMap<T>(Func<MapNode, T> map)
         {
             throw new AsyncApiReaderException("Cannot create map from this type of node.", this.Context);
@@ -72,6 +77,11 @@ public virtual List<T> CreateSimpleList<T>(Func<ValueNode, T> map)
             throw new AsyncApiReaderException("Cannot create simple list from this type of node.", this.Context);
         }
 
+        public virtual HashSet<T> CreateSimpleSet<T>(Func<ValueNode, T> map)
+        {
+            throw new AsyncApiReaderException("Cannot create simple list from this type of node.", this.Context);
+        }
+
         public virtual Dictionary<string, T> CreateSimpleMap<T>(Func<ValueNode, T> map)
         {
             throw new AsyncApiReaderException("Cannot create simple map from this type of node.", this.Context);

src/ByteBard.AsyncAPI.Readers/ParseNodes/ParseNode.cs

@@ -22,6 +22,32 @@ public PropertyNode(ParsingContext context, string name, JsonNode node)
 
         public ParseNode Value { get; set; }
 
+        public void ParseField<T>(T parentInstance,  IDictionary<Func<string, bool>, Action<T, string, ParseNode>> patternFields)
+        {
+            var map = patternFields.Where(p => p.Key(this.Name)).Select(p => p.Value).FirstOrDefault();
+            if (map != null)
+            {
+                try
+                {
+                    this.Context.StartObject(this.Name);
+                    map(parentInstance, this.Name, this.Value);
+                }
+                catch (AsyncApiReaderException ex)
+                {
+                    this.Context.Diagnostic.Errors.Add(new AsyncApiError(ex));
+                }
+                catch (AsyncApiException ex)
+                {
+                    ex.Pointer = this.Context.GetLocation();
+                    this.Context.Diagnostic.Errors.Add(new AsyncApiError(ex));
+                }
+                finally
+                {
+                    this.Context.EndObject();
+                }
+            }
+        }
+
         public void ParseField<T>(
             T parentInstance,
             IDictionary<string, Action<T, ParseNode>> fixedFields,

src/ByteBard.AsyncAPI.Readers/ParseNodes/PropertyNode.cs

@@ -27,7 +27,6 @@ public override string GetScalarValue()
         {
             if (this.cachedScalarValue == null)
             {
-                // 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);
             }