Refactoring to simplify interactions around ParsingContext

Author: darrelmiller

src/Microsoft.OpenApi.Readers/OpenApiStreamReader.cs

@@ -19,62 +19,42 @@ namespace Microsoft.OpenApi.Readers
     /// </summary>
     public class OpenApiStreamReader : IOpenApiReader<Stream, OpenApiDiagnostic>
     {
-        /// <summary>
-        /// Gets the version of the Open API document.
-        /// </summary>
-        private static string GetVersion(RootNode rootNode)
-        {
-            var versionNode = rootNode.Find(new JsonPointer("/openapi"));
-
-            if (versionNode != null)
-            {
-                return versionNode.GetScalarValue();
-            }
-
-            versionNode = rootNode.Find(new JsonPointer("/swagger"));
-
-            return versionNode?.GetScalarValue();
-        }
+       
 
         /// <summary>
         /// Reads the stream input and parses it into an Open API document.
         /// </summary>
         public OpenApiDocument Read(Stream input, out OpenApiDiagnostic diagnostic)
         {
-            RootNode rootNode;
-            var context = new ParsingContext();
+            ParsingContext context;
             diagnostic = new OpenApiDiagnostic();
 
             try
             {
-                using (var streamReader = new StreamReader(input))
-                {
-                    var yamlStream = new YamlStream();
-                    yamlStream.Load(streamReader);
+                YamlDocument yamlDocument = LoadYamlDocument(input);
+                context = new ParsingContext();
+                return context.Parse(yamlDocument, diagnostic);
 
-                    var yamlDocument = yamlStream.Documents.First();
-                    rootNode = new RootNode(context, diagnostic, yamlDocument);
-                }
             }
             catch (SyntaxErrorException ex)
             {
                 diagnostic.Errors.Add(new OpenApiError(string.Empty, ex.Message));
 
                 return new OpenApiDocument();
             }
+           
+        }
 
-            var inputVersion = GetVersion(rootNode);
-
-            switch (inputVersion)
+        internal static YamlDocument LoadYamlDocument(Stream input)
+        {
+            YamlDocument yamlDocument;
+            using (var streamReader = new StreamReader(input))
             {
-                case "2.0":
-                    context.ReferenceService = new OpenApiV2ReferenceService(rootNode);
-                    return OpenApiV2Deserializer.LoadOpenApi(rootNode);
-
-                default:
-                    context.ReferenceService = new OpenApiV3ReferenceService(rootNode);
-                    return OpenApiV3Deserializer.LoadOpenApi(rootNode);
+                var yamlStream = new YamlStream();
+                yamlStream.Load(streamReader);
+                yamlDocument = yamlStream.Documents.First();
             }
+            return yamlDocument;
         }
     }
 }

src/Microsoft.OpenApi.Readers/ParseNodes/RootNode.cs

@@ -18,6 +18,7 @@ public RootNode(
             YamlDocument yamlDocument) : base(context, diagnostic)
         {
             _yamlDocument = yamlDocument;
+            context.RootNode = this;
         }
 
         public ParseNode Find(JsonPointer referencePointer)

src/Microsoft.OpenApi.Readers/ParsingContext.cs

@@ -1,35 +1,130 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. 
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers.ParseNodes;
 using Microsoft.OpenApi.Readers.ReferenceServices;
+using SharpYaml.Serialization;
 
 namespace Microsoft.OpenApi.Readers
 {
     /// <summary>
-    /// Parsing context.
+    /// The Parsing Context holds temporary state needed whilst parsing an OpenAPI Document
     /// </summary>
     public class ParsingContext
     {
         private readonly Stack<string> _currentLocation = new Stack<string>();
+        private readonly Dictionary<string, IOpenApiReferenceable> _referenceStore = new Dictionary<string, IOpenApiReferenceable>();
+        private readonly Dictionary<string, object> _tempStorage = new Dictionary<string, object>();
+        private readonly List<OpenApiTag> _tags = new List<OpenApiTag>();
+        private IOpenApiVersionService _versionService;
+        private RootNode _rootNode;
 
-        private readonly Dictionary<string, IOpenApiReferenceable> _referenceStore =
-            new Dictionary<string, IOpenApiReferenceable>();
 
-        private readonly Dictionary<string, object> _tempStorage = new Dictionary<string, object>();
+        /// <summary>
+        /// Initiates the parsing process.  Not thread safe and should only be called once on a parsing context
+        /// </summary>
+        /// <param name="yamlDocument"></param>
+        /// <param name="diagnostic"></param>
+        /// <returns>An OpenApiDocument populated based on the passed yamlDocument </returns>
+        internal OpenApiDocument Parse(YamlDocument yamlDocument, OpenApiDiagnostic diagnostic)
+        {
+            _rootNode = new RootNode(this, diagnostic, yamlDocument);
+
+            var inputVersion = GetVersion(_rootNode);
+
+            OpenApiDocument doc;
+            switch (inputVersion)
+            {
+                case "2.0":
+                    this.ReferenceService = new OpenApiV2VersionService();
+                    doc = this.ReferenceService.LoadOpenApi(_rootNode);
+                    break;
+
+                default:
+                    this.ReferenceService = new OpenApiV3VersionService();
+                    doc = this.ReferenceService.LoadOpenApi(_rootNode);
+                    break;
+            }
+
+            return doc;
+        }
+
+        internal RootNode RootNode { get
+            {
+                return _rootNode;
+            }
+            set
+            {
+                {
+                    _rootNode = value;
+                    
+                }
+            }
+        }
+
+        internal List<OpenApiTag> Tags
+        {
+            get
+            {
+                return _tags;
+            }
+        }
 
         /// <summary>
-        /// Reference service.
+        /// Gets the version of the Open API document.
         /// </summary>
-        internal IOpenApiReferenceService ReferenceService { get; set; }
+        private static string GetVersion(RootNode rootNode)
+        {
+            var versionNode = rootNode.Find(new JsonPointer("/openapi"));
+
+            if (versionNode != null)
+            {
+                return versionNode.GetScalarValue();
+            }
+
+            versionNode = rootNode.Find(new JsonPointer("/swagger"));
+
+            return versionNode?.GetScalarValue();
+        }
+
+        private void ComputeTags(List<OpenApiTag> tags, Func<MapNode,OpenApiTag> loadTag )
+        {
+            // Precompute the tags array so that each tag reference does not require a new deserialization.
+            var tagListPointer = new JsonPointer("#/tags");
+
+            var tagListNode = _rootNode.Find(tagListPointer);
+
+            if (tagListNode != null && tagListNode is ListNode)
+            {
+                var tagListNodeAsListNode = (ListNode)tagListNode;
+                tags.AddRange(tagListNodeAsListNode.CreateList(loadTag));
+            }
+        }
+
+
+
 
         /// <summary>
-        /// End the current object.
+        /// Reference service.
         /// </summary>
-        public void EndObject()
+        internal IOpenApiVersionService ReferenceService { get {
+                return _versionService;
+            }
+            set {
+                _versionService = value;
+                ComputeTags(_tags, ReferenceService.TagLoader);
+            }
+        }
+
+                /// <summary>
+                /// End the current object.
+                /// </summary>
+                public void EndObject()
         {
             _currentLocation.Pop();
         }
@@ -60,7 +155,7 @@ public IOpenApiReferenceable GetReferencedObject(
 
             var reference = ReferenceService.ConvertToOpenApiReference(referenceString, referenceType);
 
-            var isReferencedObjectFound = ReferenceService.TryLoadReference(reference, out referencedObject);
+            var isReferencedObjectFound = ReferenceService.TryLoadReference(this, reference, out referencedObject);
 
             if (isReferencedObjectFound)
             {

src/Microsoft.OpenApi.Readers/ReferenceServices/IOpenApiReferenceService.cs renamed to src/Microsoft.OpenApi.Readers/ReferenceServices/IOpenApiVersionService.cs

@@ -3,17 +3,20 @@
 
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers.ParseNodes;
+using System;
 
 namespace Microsoft.OpenApi.Readers.ReferenceServices
 {
     /// <summary>
-    /// Interface for Open API Reference parse.
+    /// Interface to a version specific parsing implementations.
     /// </summary>
-    public interface IOpenApiReferenceService
+    internal interface IOpenApiVersionService
     {
         /// <summary>
         /// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="OpenApiReference"/> object
         /// </summary>
+        /// <param name="context"></param>
         /// <param name="reference">The <see cref="OpenApiReference"/> object.</param>
         /// <param name="referencedObject">The object that is being referenced.</param>
         /// <returns>
@@ -22,7 +25,7 @@ public interface IOpenApiReferenceService
         /// a new tag will be returned in the outer parameter and the return value will be false.
         /// If reference is null, no object will be returned and the return value will be false.
         /// </returns>
-        bool TryLoadReference(OpenApiReference reference, out IOpenApiReferenceable referencedObject);
+        bool TryLoadReference(ParsingContext context, OpenApiReference reference, out IOpenApiReferenceable referencedObject);
 
         /// <summary>
         /// Parse the string to a <see cref="OpenApiReference"/> object.
@@ -31,5 +34,13 @@ public interface IOpenApiReferenceService
         /// <param name="type">The type of the reference.</param>
         /// <returns>The <see cref="OpenApiReference"/> object or null.</returns>
         OpenApiReference ConvertToOpenApiReference(string reference, ReferenceType? type);
+
+
+        /// <summary>
+        /// Function that converts MapNodes into Tag objects in a version specific way
+        /// </summary>
+        Func<MapNode, OpenApiTag> TagLoader { get; }
+
+        OpenApiDocument LoadOpenApi(RootNode rootNode);
     }
 }

src/Microsoft.OpenApi.Readers/ReferenceServices/OpenApiV2ReferenceService.cs renamed to src/Microsoft.OpenApi.Readers/ReferenceServices/OpenApiV2VersionService.cs

@@ -9,43 +9,22 @@
 using Microsoft.OpenApi.Readers.ParseNodes;
 using Microsoft.OpenApi.Readers.Properties;
 using Microsoft.OpenApi.Readers.V2;
-using Microsoft.OpenApi.Readers.V3;
+
 
 namespace Microsoft.OpenApi.Readers.ReferenceServices
 {
     /// <summary>
-    /// The reference service for the Open API V2.0.
+    /// The version specific implementations for OpenAPI V2.0.
     /// </summary>
-    internal class OpenApiV2ReferenceService : IOpenApiReferenceService
+    internal class OpenApiV2VersionService : IOpenApiVersionService
     {
-        private readonly RootNode _rootNode;
-
-        private readonly List<OpenApiTag> _tags = new List<OpenApiTag>();
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="OpenApiV2ReferenceService"/> class.
-        /// </summary>
-        /// <param name="rootNode">The root node.</param>
-        public OpenApiV2ReferenceService(RootNode rootNode)
-        {
-            _rootNode = rootNode ?? throw new ArgumentNullException(nameof(rootNode));
-
-            // Precompute the tags array so that each tag reference does not require a new deserialization.
-            var tagListPointer = new JsonPointer("#/tags");
+        public Func<MapNode, OpenApiTag> TagLoader { get  { return OpenApiV2Deserializer.LoadTag; } }
 
-            var tagListNode = _rootNode.Find(tagListPointer);
-
-            if (tagListNode != null && tagListNode is ListNode)
-            {
-                var tagListNodeAsListNode = (ListNode)tagListNode;
-                _tags.AddRange(tagListNodeAsListNode.CreateList(OpenApiV3Deserializer.LoadTag));
-            }
-        }
 
         /// <summary>
         /// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="OpenApiReference"/> object
         /// </summary>
-        public bool TryLoadReference(OpenApiReference reference, out IOpenApiReferenceable referencedObject)
+        public bool TryLoadReference(ParsingContext context, OpenApiReference reference, out IOpenApiReferenceable referencedObject)
         {
             referencedObject = null;
 
@@ -68,7 +47,7 @@ public bool TryLoadReference(OpenApiReference reference, out IOpenApiReferenceab
             // Special case for Tag
             if (reference.Type == ReferenceType.Tag)
             {
-                foreach (var tag in _tags)
+                foreach (var tag in context.Tags)
                 {
                     if (tag.Name == reference.Id)
                     {
@@ -84,7 +63,7 @@ public bool TryLoadReference(OpenApiReference reference, out IOpenApiReferenceab
             var jsonPointer =
                 new JsonPointer("#/" + GetReferenceTypeV2Name(reference.Type.Value) + "/" + reference.Id);
 
-            var node = _rootNode.Find(jsonPointer);
+            var node = context.RootNode.Find(jsonPointer);
 
             switch (reference.Type)
             {
@@ -115,7 +94,7 @@ public bool TryLoadReference(OpenApiReference reference, out IOpenApiReferenceab
             return true;
         }
 
-        private OpenApiReference ParseLocalReference(string localReference)
+        private static OpenApiReference ParseLocalReference(string localReference)
         {
             if (string.IsNullOrWhiteSpace(localReference))
             {
@@ -243,5 +222,10 @@ public OpenApiReference ConvertToOpenApiReference(string reference, ReferenceTyp
 
             throw new OpenApiException(string.Format(SRResource.ReferenceHasInvalidFormat, reference));
         }
+
+        public OpenApiDocument LoadOpenApi(RootNode rootNode)
+        {
+            return OpenApiV2Deserializer.LoadOpenApi(rootNode);
+        }
     }
 }