clean up file

MaggieKimani1 · MaggieKimani1 · commit f76fddf2a1b5 · 2024-07-30T12:57:37.000+03:00
diff --git a/src/Microsoft.OpenApi/Reader/V2/OpenApiSchemaDeserializer.cs b/src/Microsoft.OpenApi/Reader/V2/OpenApiSchemaDeserializer.cs
@@ -3,7 +3,6 @@
 
 using System.Collections.Generic;
 using System.Globalization;
-using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Reader.ParseNodes;
@@ -17,116 +16,116 @@ namespace Microsoft.OpenApi.Reader.V2
     /// </summary>
     internal static partial class OpenApiV2Deserializer
     {
-        private static readonly FixedFieldMap<OpenApiSchema> _schemaFixedFields = new()
+        private static readonly FixedFieldMap<OpenApiSchema> _openApiSchemaFixedFields = new()
         {
             {
                 "title",
-                (o, n) => o.Title = n.GetScalarValue()
+                (o, n, _) => o.Title = n.GetScalarValue()
             },
             {
                 "multipleOf",
-                (o, n) => o.MultipleOf = decimal.Parse(n.GetScalarValue(), NumberStyles.Float, CultureInfo.InvariantCulture)
+                (o, n, _) => o.MultipleOf = decimal.Parse(n.GetScalarValue(), NumberStyles.Float, CultureInfo.InvariantCulture)
             },
             {
                 "maximum",
-                (o, n) => o.Maximum = ParserHelper.ParseDecimalWithFallbackOnOverflow(n.GetScalarValue(), decimal.MaxValue)
+                (o, n,_) => o.Maximum = ParserHelper.ParseDecimalWithFallbackOnOverflow(n.GetScalarValue(), decimal.MaxValue)
             },
             {
                 "exclusiveMaximum",
-                (o, n) => o.ExclusiveMaximum = bool.Parse(n.GetScalarValue())
+                (o, n, _) => o.ExclusiveMaximum = bool.Parse(n.GetScalarValue())
             },
             {
                 "minimum",
-                (o, n) => o.Minimum = ParserHelper.ParseDecimalWithFallbackOnOverflow(n.GetScalarValue(), decimal.MinValue)
+                (o, n, _) => o.Minimum = ParserHelper.ParseDecimalWithFallbackOnOverflow(n.GetScalarValue(), decimal.MinValue)
             },
             {
                 "exclusiveMinimum",
-                (o, n) => o.ExclusiveMinimum = bool.Parse(n.GetScalarValue())
+                (o, n, _) => o.ExclusiveMinimum = bool.Parse(n.GetScalarValue())
             },
             {
                 "maxLength",
-                (o, n) => o.MaxLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
+                (o, n, _) => o.MaxLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
             },
             {
                 "minLength",
-                (o, n) => o.MinLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
+                (o, n, _) => o.MinLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
             },
             {
                 "pattern",
-                (o, n) => o.Pattern = n.GetScalarValue()
+                (o, n, _) => o.Pattern = n.GetScalarValue()
             },
             {
                 "maxItems",
-                (o, n) => o.MaxItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
+                (o, n, _) => o.MaxItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
             },
             {
                 "minItems",
-                (o, n) => o.MinItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
+                (o, n, _) => o.MinItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
             },
             {
                 "uniqueItems",
-                (o, n) => o.UniqueItems = bool.Parse(n.GetScalarValue())
+                (o, n, _) => o.UniqueItems = bool.Parse(n.GetScalarValue())
             },
             {
                 "maxProperties",
-                (o, n) => o.MaxProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
+                (o, n, _) => o.MaxProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
             },
             {
                 "minProperties",
-                (o, n) => o.MinProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
+                (o, n, _) => o.MinProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)
             },
             {
                 "required",
-                (o, n) => o.Required = new HashSet<string>(n.CreateSimpleList(n2 => n2.GetScalarValue()))
+                (o, n, _) => o.Required = new HashSet<string>(n.CreateSimpleList((n2, p) => n2.GetScalarValue()))
             },
             {
                 "enum",
-                (o, n) => o.Enum = n.CreateListOfAny()
+                (o, n, _) => o.Enum = n.CreateListOfAny()
             },
 
             {
                 "type",
-                (o, n) => o.Type = n.GetScalarValue()
+                (o, n, _) => o.Type = n.GetScalarValue()
             },
             {
                 "allOf",
-                (o, n) => o.AllOf = n.CreateList(LoadSchema)
+                (o, n, t) => o.AllOf = n.CreateList(LoadOpenApiSchema, t)
             },
             {
                 "items",
-                (o, n) => o.Items = LoadSchema(n)
+                (o, n, _) => o.Items = LoadOpenApiSchema(n)
             },
             {
                 "properties",
-                (o, n) => o.Properties = n.CreateMap(LoadSchema)
+                (o, n, t) => o.Properties = n.CreateMap(LoadOpenApiSchema, t)
             },
             {
-                "additionalProperties", (o, n) =>
+                "additionalProperties", (o, n, _) =>
                 {
                     if (n is ValueNode)
                     {
                         o.AdditionalPropertiesAllowed = bool.Parse(n.GetScalarValue());
                     }
                     else
                     {
-                        o.AdditionalProperties = LoadSchema(n);
+                        o.AdditionalProperties = LoadOpenApiSchema(n);
                     }
                 }
             },
             {
                 "description",
-                (o, n) => o.Description = n.GetScalarValue()
+                (o, n, _) => o.Description = n.GetScalarValue()
             },
             {
                 "format",
-                (o, n) => o.Format = n.GetScalarValue()
+                (o, n, _) => o.Format = n.GetScalarValue()
             },
             {
                 "default",
-                (o, n) => o.Default = n.CreateAny()
+                (o, n, _) => o.Default = n.CreateAny()
             },
             {
-                "discriminator", (o, n) =>
+                "discriminator", (o, n, _) =>
                 {
                     o.Discriminator = new()
                     {
@@ -136,28 +135,28 @@ internal static partial class OpenApiV2Deserializer
             },
             {
                 "readOnly",
-                (o, n) => o.ReadOnly = bool.Parse(n.GetScalarValue())
+                (o, n, _) => o.ReadOnly = bool.Parse(n.GetScalarValue())
             },
             {
                 "xml",
-                (o, n) => o.Xml = LoadXml(n)
+                (o, n, _) => o.Xml = LoadXml(n)
             },
             {
                 "externalDocs",
-                (o, n) => o.ExternalDocs = LoadExternalDocs(n)
+                (o, n, _) => o.ExternalDocs = LoadExternalDocs(n)
             },
             {
                 "example",
-                (o, n) => o.Example = n.CreateAny()
+                (o, n, _) => o.Example = n.CreateAny()
             },
         };
 
-        private static readonly PatternFieldMap<OpenApiSchema> _schemaPatternFields = new PatternFieldMap<OpenApiSchema>
+        private static readonly PatternFieldMap<OpenApiSchema> _openApiSchemaPatternFields = new PatternFieldMap<OpenApiSchema>
         {
-            {s => s.StartsWith("x-"), (o, p, n) => o.AddExtension(p, LoadExtension(p, n))}
+            {s => s.StartsWith("x-"), (o, p, n, _) => o.AddExtension(p, LoadExtension(p, n))}
         };
 
-        public static OpenApiSchema LoadSchema(ParseNode node)
+        public static OpenApiSchema LoadOpenApiSchema(ParseNode node, OpenApiDocument hostDocument = null)
         {
             var mapNode = node.CheckMapNode("schema");
 
@@ -171,19 +170,10 @@ public static OpenApiSchema LoadSchema(ParseNode node)
  
             foreach (var propertyNode in mapNode)
             {
-                propertyNode.ParseField(schema, _schemaFixedFields, _schemaPatternFields);
+                propertyNode.ParseField(schema, _openApiSchemaFixedFields, _openApiSchemaPatternFields);
             }
 
             return schema;
         }
-
-        private static Dictionary<string, IOpenApiExtension> LoadExtensions(string value, IOpenApiExtension extension)
-        {
-            var extensions = new Dictionary<string, IOpenApiExtension>
-            {
-                { value, extension }
-            };
-            return extensions;
-        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.Globalization;`
`6`		`-using Microsoft.OpenApi.Interfaces;`
`7`	`6`	`using Microsoft.OpenApi.Models;`
`8`	`7`	`using Microsoft.OpenApi.Extensions;`
`9`	`8`	`using Microsoft.OpenApi.Reader.ParseNodes;`
`@@ -17,116 +16,116 @@ namespace Microsoft.OpenApi.Reader.V2`
`17`	`16`	`/// </summary>`
`18`	`17`	`internal static partial class OpenApiV2Deserializer`
`19`	`18`	`{`
`20`		`- private static readonly FixedFieldMap<OpenApiSchema> _schemaFixedFields = new()`
	`19`	`+ private static readonly FixedFieldMap<OpenApiSchema> _openApiSchemaFixedFields = new()`
`21`	`20`	`{`
`22`	`21`	`{`
`23`	`22`	`"title",`
`24`		`- (o, n) => o.Title = n.GetScalarValue()`
	`23`	`+ (o, n, _) => o.Title = n.GetScalarValue()`
`25`	`24`	`},`
`26`	`25`	`{`
`27`	`26`	`"multipleOf",`
`28`		`- (o, n) => o.MultipleOf = decimal.Parse(n.GetScalarValue(), NumberStyles.Float, CultureInfo.InvariantCulture)`
	`27`	`+ (o, n, _) => o.MultipleOf = decimal.Parse(n.GetScalarValue(), NumberStyles.Float, CultureInfo.InvariantCulture)`
`29`	`28`	`},`
`30`	`29`	`{`
`31`	`30`	`"maximum",`
`32`		`- (o, n) => o.Maximum = ParserHelper.ParseDecimalWithFallbackOnOverflow(n.GetScalarValue(), decimal.MaxValue)`
	`31`	`+ (o, n,_) => o.Maximum = ParserHelper.ParseDecimalWithFallbackOnOverflow(n.GetScalarValue(), decimal.MaxValue)`
`33`	`32`	`},`
`34`	`33`	`{`
`35`	`34`	`"exclusiveMaximum",`
`36`		`- (o, n) => o.ExclusiveMaximum = bool.Parse(n.GetScalarValue())`
	`35`	`+ (o, n, _) => o.ExclusiveMaximum = bool.Parse(n.GetScalarValue())`
`37`	`36`	`},`
`38`	`37`	`{`
`39`	`38`	`"minimum",`
`40`		`- (o, n) => o.Minimum = ParserHelper.ParseDecimalWithFallbackOnOverflow(n.GetScalarValue(), decimal.MinValue)`
	`39`	`+ (o, n, _) => o.Minimum = ParserHelper.ParseDecimalWithFallbackOnOverflow(n.GetScalarValue(), decimal.MinValue)`
`41`	`40`	`},`
`42`	`41`	`{`
`43`	`42`	`"exclusiveMinimum",`
`44`		`- (o, n) => o.ExclusiveMinimum = bool.Parse(n.GetScalarValue())`
	`43`	`+ (o, n, _) => o.ExclusiveMinimum = bool.Parse(n.GetScalarValue())`
`45`	`44`	`},`
`46`	`45`	`{`
`47`	`46`	`"maxLength",`
`48`		`- (o, n) => o.MaxLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
	`47`	`+ (o, n, _) => o.MaxLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
`49`	`48`	`},`
`50`	`49`	`{`
`51`	`50`	`"minLength",`
`52`		`- (o, n) => o.MinLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
	`51`	`+ (o, n, _) => o.MinLength = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
`53`	`52`	`},`
`54`	`53`	`{`
`55`	`54`	`"pattern",`
`56`		`- (o, n) => o.Pattern = n.GetScalarValue()`
	`55`	`+ (o, n, _) => o.Pattern = n.GetScalarValue()`
`57`	`56`	`},`
`58`	`57`	`{`
`59`	`58`	`"maxItems",`
`60`		`- (o, n) => o.MaxItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
	`59`	`+ (o, n, _) => o.MaxItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
`61`	`60`	`},`
`62`	`61`	`{`
`63`	`62`	`"minItems",`
`64`		`- (o, n) => o.MinItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
	`63`	`+ (o, n, _) => o.MinItems = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
`65`	`64`	`},`
`66`	`65`	`{`
`67`	`66`	`"uniqueItems",`
`68`		`- (o, n) => o.UniqueItems = bool.Parse(n.GetScalarValue())`
	`67`	`+ (o, n, _) => o.UniqueItems = bool.Parse(n.GetScalarValue())`
`69`	`68`	`},`
`70`	`69`	`{`
`71`	`70`	`"maxProperties",`
`72`		`- (o, n) => o.MaxProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
	`71`	`+ (o, n, _) => o.MaxProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
`73`	`72`	`},`
`74`	`73`	`{`
`75`	`74`	`"minProperties",`
`76`		`- (o, n) => o.MinProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
	`75`	`+ (o, n, _) => o.MinProperties = int.Parse(n.GetScalarValue(), CultureInfo.InvariantCulture)`
`77`	`76`	`},`
`78`	`77`	`{`
`79`	`78`	`"required",`
`80`		`- (o, n) => o.Required = new HashSet<string>(n.CreateSimpleList(n2 => n2.GetScalarValue()))`
	`79`	`+ (o, n, _) => o.Required = new HashSet<string>(n.CreateSimpleList((n2, p) => n2.GetScalarValue()))`
`81`	`80`	`},`
`82`	`81`	`{`
`83`	`82`	`"enum",`
`84`		`- (o, n) => o.Enum = n.CreateListOfAny()`
	`83`	`+ (o, n, _) => o.Enum = n.CreateListOfAny()`
`85`	`84`	`},`
`86`	`85`
`87`	`86`	`{`
`88`	`87`	`"type",`
`89`		`- (o, n) => o.Type = n.GetScalarValue()`
	`88`	`+ (o, n, _) => o.Type = n.GetScalarValue()`
`90`	`89`	`},`
`91`	`90`	`{`
`92`	`91`	`"allOf",`
`93`		`- (o, n) => o.AllOf = n.CreateList(LoadSchema)`
	`92`	`+ (o, n, t) => o.AllOf = n.CreateList(LoadOpenApiSchema, t)`
`94`	`93`	`},`
`95`	`94`	`{`
`96`	`95`	`"items",`
`97`		`- (o, n) => o.Items = LoadSchema(n)`
	`96`	`+ (o, n, _) => o.Items = LoadOpenApiSchema(n)`
`98`	`97`	`},`
`99`	`98`	`{`
`100`	`99`	`"properties",`
`101`		`- (o, n) => o.Properties = n.CreateMap(LoadSchema)`
	`100`	`+ (o, n, t) => o.Properties = n.CreateMap(LoadOpenApiSchema, t)`
`102`	`101`	`},`
`103`	`102`	`{`
`104`		`- "additionalProperties", (o, n) =>`
	`103`	`+ "additionalProperties", (o, n, _) =>`
`105`	`104`	`{`
`106`	`105`	`if (n is ValueNode)`
`107`	`106`	`{`
`108`	`107`	`o.AdditionalPropertiesAllowed = bool.Parse(n.GetScalarValue());`
`109`	`108`	`}`
`110`	`109`	`else`
`111`	`110`	`{`
`112`		`- o.AdditionalProperties = LoadSchema(n);`
	`111`	`+ o.AdditionalProperties = LoadOpenApiSchema(n);`
`113`	`112`	`}`
`114`	`113`	`}`
`115`	`114`	`},`
`116`	`115`	`{`
`117`	`116`	`"description",`
`118`		`- (o, n) => o.Description = n.GetScalarValue()`
	`117`	`+ (o, n, _) => o.Description = n.GetScalarValue()`
`119`	`118`	`},`
`120`	`119`	`{`
`121`	`120`	`"format",`
`122`		`- (o, n) => o.Format = n.GetScalarValue()`
	`121`	`+ (o, n, _) => o.Format = n.GetScalarValue()`
`123`	`122`	`},`
`124`	`123`	`{`
`125`	`124`	`"default",`
`126`		`- (o, n) => o.Default = n.CreateAny()`
	`125`	`+ (o, n, _) => o.Default = n.CreateAny()`
`127`	`126`	`},`
`128`	`127`	`{`
`129`		`- "discriminator", (o, n) =>`
	`128`	`+ "discriminator", (o, n, _) =>`
`130`	`129`	`{`
`131`	`130`	`o.Discriminator = new()`
`132`	`131`	`{`
`@@ -136,28 +135,28 @@ internal static partial class OpenApiV2Deserializer`
`136`	`135`	`},`
`137`	`136`	`{`
`138`	`137`	`"readOnly",`
`139`		`- (o, n) => o.ReadOnly = bool.Parse(n.GetScalarValue())`
	`138`	`+ (o, n, _) => o.ReadOnly = bool.Parse(n.GetScalarValue())`
`140`	`139`	`},`
`141`	`140`	`{`
`142`	`141`	`"xml",`
`143`		`- (o, n) => o.Xml = LoadXml(n)`
	`142`	`+ (o, n, _) => o.Xml = LoadXml(n)`
`144`	`143`	`},`
`145`	`144`	`{`
`146`	`145`	`"externalDocs",`
`147`		`- (o, n) => o.ExternalDocs = LoadExternalDocs(n)`
	`146`	`+ (o, n, _) => o.ExternalDocs = LoadExternalDocs(n)`
`148`	`147`	`},`
`149`	`148`	`{`
`150`	`149`	`"example",`
`151`		`- (o, n) => o.Example = n.CreateAny()`
	`150`	`+ (o, n, _) => o.Example = n.CreateAny()`
`152`	`151`	`},`
`153`	`152`	`};`
`154`	`153`
`155`		`- private static readonly PatternFieldMap<OpenApiSchema> _schemaPatternFields = new PatternFieldMap<OpenApiSchema>`
	`154`	`+ private static readonly PatternFieldMap<OpenApiSchema> _openApiSchemaPatternFields = new PatternFieldMap<OpenApiSchema>`
`156`	`155`	`{`
`157`		`- {s => s.StartsWith("x-"), (o, p, n) => o.AddExtension(p, LoadExtension(p, n))}`
	`156`	`+ {s => s.StartsWith("x-"), (o, p, n, _) => o.AddExtension(p, LoadExtension(p, n))}`
`158`	`157`	`};`
`159`	`158`
`160`		`- public static OpenApiSchema LoadSchema(ParseNode node)`
	`159`	`+ public static OpenApiSchema LoadOpenApiSchema(ParseNode node, OpenApiDocument hostDocument = null)`
`161`	`160`	`{`
`162`	`161`	`var mapNode = node.CheckMapNode("schema");`
`163`	`162`
`@@ -171,19 +170,10 @@ public static OpenApiSchema LoadSchema(ParseNode node)`
`171`	`170`
`172`	`171`	`foreach (var propertyNode in mapNode)`
`173`	`172`	`{`
`174`		`- propertyNode.ParseField(schema, _schemaFixedFields, _schemaPatternFields);`
	`173`	`+ propertyNode.ParseField(schema, _openApiSchemaFixedFields, _openApiSchemaPatternFields);`
`175`	`174`	`}`
`176`	`175`
`177`	`176`	`return schema;`
`178`	`177`	`}`
`179`		`-`
`180`		`- private static Dictionary<string, IOpenApiExtension> LoadExtensions(string value, IOpenApiExtension extension)`
`181`		`- {`
`182`		`- var extensions = new Dictionary<string, IOpenApiExtension>`
`183`		`- {`
`184`		`- { value, extension }`
`185`		`- };`
`186`		`- return extensions;`
`187`		`- }`
`188`	`178`	`}`
`189`	`179`	`}`