Move Yaml Validator into Persistence Part 2

.version/PipelineAssemblyInfo.cs

@@ -3,6 +3,8 @@
 
 // This is pipeline generated file. Do not modify. This will be replaced with the actual versions in the actual Pipeline.
 using System.Reflection;
+using System.Runtime.CompilerServices;
 [assembly: AssemblyVersion("0.0.0.0")]
 [assembly: AssemblyFileVersion("0.0.0.0")]
-[assembly: AssemblyInformationalVersion("0.0.0.0-dev-00000000")]
+[assembly: AssemblyInformationalVersion("0.0.0.0-dev-00000000")]
+[assembly: InternalsVisibleTo("Persistence.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]

src/Directory.Build.props

@@ -90,4 +90,4 @@
         <RestoreIgnoreFailedSource>true</RestoreIgnoreFailedSource>
         <RestoreOutputPath>$(BaseIntermediateOutputPath)</RestoreOutputPath>
     </PropertyGroup>
-</Project>
+</Project>

src/Persistence.Tests/YamlValidator/ValidatorFactoryTest.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
+
+namespace Persistence.Tests.YamlValidator;
+
+[TestClass]
+public class ValidatorFactoryTest
+{
+    [TestMethod]
+    public void GetValidatorTest()
+    {
+        var factory = new ValidatorFactory();
+        var validator = factory.GetValidator();
+
+        Assert.IsNotNull(validator);
+        Assert.IsInstanceOfType(validator, typeof(Validator));
+    }
+}

src/Persistence.Tests/YamlValidator/ValidatorTest.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using Json.Schema;
 using Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
 
 namespace Persistence.Tests.YamlValidator;
@@ -16,15 +15,12 @@ public class ValidatorTest
     private static readonly string _invalidPath = Path.Combine(".", "_TestData", "ValidatorTests", "InvalidYaml") +
         Path.DirectorySeparatorChar;
 
-    private readonly JsonSchema _schema;
-    private readonly Validator _yamlValidator;
+    private readonly IValidator _yamlValidator;
 
     public ValidatorTest()
     {
-        var schemaFileLoader = new SchemaLoader();
-        _schema = schemaFileLoader.Load();
-        var resultVerbosity = new VerbosityData(Constants.Verbose);
-        _yamlValidator = new Validator(resultVerbosity.EvalOptions, resultVerbosity.JsonOutputOptions);
+        var validatorFactory = new ValidatorFactory();
+        _yamlValidator = validatorFactory.GetValidator();
     }
 
     [TestMethod]
@@ -34,8 +30,8 @@ public ValidatorTest()
 
     public void TestValidationValidYaml(string filename)
     {
-        var rawYaml = Utility.ReadFileData($@"{_validPath}{filename}");
-        var result = _yamlValidator.Validate(_schema, rawYaml);
+        var rawYaml = File.ReadAllText($@"{_validPath}{filename}");
+        var result = _yamlValidator.Validate(rawYaml);
         Assert.IsTrue(result.SchemaValid);
     }
 
@@ -48,10 +44,11 @@ public void TestValidationValidYaml(string filename)
     [DataRow("EmptyArray.yaml")]
     [DataRow("Empty.yaml")]
     [DataRow("NamelessObjectNoControl.yaml")]
+    [DataRow("NotYaml.yaml")]
     public void TestValidationInvalidYaml(string filename)
     {
-        var rawYaml = Utility.ReadFileData($@"{_invalidPath}{filename}");
-        var result = _yamlValidator.Validate(_schema, rawYaml);
+        var rawYaml = File.ReadAllText($@"{_invalidPath}{filename}");
+        var result = _yamlValidator.Validate(rawYaml);
         Assert.IsFalse(result.SchemaValid);
     }
 }

src/Persistence.Tests/_TestData/ValidatorTests/InvalidYaml/NotYaml.yaml

@@ -0,0 +1,15 @@
+{ 
+ features => [
+  {
+    name => lorem ipsum,
+    points => [
+      "bullet 1",
+      "bullet 2"
+    ]
+  },
+  {
+    name => lorem ipsum 2,
+    description => lorem ipsum 3
+  }
+ ]
+}

src/Persistence/Microsoft.PowerPlatform.PowerApps.Persistence.csproj

@@ -32,7 +32,7 @@
     <PublicSign>true</PublicSign>
     <!-- Workaround for version range https://github.com/NuGet/Home/issues/11842 -->
     <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
-    <NoWarn>$(NoWarn);NU1601;CA1822</NoWarn>
+    <NoWarn>$(NoWarn);NU1601</NoWarn>
   </PropertyGroup>
 
   <ItemGroup Label="Global usings">
@@ -47,14 +47,11 @@
     <PackageReference Include="Yaml2JsonNode" Version="2.1.0" />
   </ItemGroup>
 
+  <!-- Link schemas and build them into the assembly for the YamlValidator -->
   <ItemGroup>
-    <Content Include="..\..\docs\pa.yaml-schema.json" Link="YamlValidator\schema\pa.yaml-schema.json" CopyToOutputDirectory="PreserveNewest" />
-    <Content Include="..\..\docs\subschemas\control-type-schema.json" Link="YamlValidator\schema\subschemas\control-type-schema.json" CopyToOutputDirectory="PreserveNewest" />
-    <Content Include="..\..\docs\subschemas\control-property-schema.json" Link="YamlValidator\schema\subschemas\control-property-schema.json" CopyToOutputDirectory="PreserveNewest" />
+    <EmbeddedResource Include="..\..\docs\**\*.json" >
+        <Link>YamlValidator\schema\%(RecursiveDir)%(Filename)%(Extension)</Link>
+    </EmbeddedResource>
   </ItemGroup>
 
-  <ItemGroup>
-    <InternalsVisibleTo Include="Persistence.Tests" Key="0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9" />
-  </ItemGroup>
-
-</Project>
+</Project>

src/Persistence/YamlValidator/Constants.cs

@@ -5,14 +5,11 @@ namespace Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
 
 public static class Constants
 {
-    public const string FileTypeName = "file";
-    public const string FolderTypeName = "folder";
     public const string YamlFileExtension = ".pa.yaml";
     public const string JsonFileExtension = ".json";
 
-    public const string Verbose = "verbose";
+    public const string notYamlError = "File is not YAML";
+    public const string emptyYamlError = "Empty YAML file";
 
-    // runtime constants
-    // default schema path
-    public static readonly string DefaultSchemaPath = Path.Combine(".", "schema", "pa.yaml-schema.json");
+    public const string subNamespace = "YamlValidator";
 }

src/Persistence/YamlValidator/IValidator.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
+
+public interface IValidator
+{
+    ValidatorResults Validate(string yamlString);
+}

src/Persistence/YamlValidator/IValidatorFactory.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
+
+public interface IValidatorFactory
+{
+    IValidator GetValidator();
+}

src/Persistence/YamlValidator/SchemaLoader.cs

@@ -1,28 +1,54 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Reflection;
 using Json.Schema;
 
 namespace Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
 
 public class SchemaLoader
 {
-    private const string _schemaFolderPath = "subschemas";
-    private static readonly string _schemaPath = Path.Combine(".", "YamlValidator", "schema", "pa.yaml-schema.json");
+    private const string _schemaFolderPath = "schema";
+    private const string _subschemaFolderPath = "subschemas";
 
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static",
+    Justification = "Suppress to make classes stateless")]
     public JsonSchema Load()
     {
-        var node = JsonSchema.FromFile(_schemaPath);
-        var schemaFolder = Path.GetDirectoryName(_schemaPath);
-        var subschemaPaths = Directory.GetFiles($@"{schemaFolder}{Path.DirectorySeparatorChar}{_schemaFolderPath}",
-            $"*{Constants.JsonFileExtension}");
+        var assembly = typeof(SchemaLoader).Assembly;
 
-        foreach (var path in subschemaPaths)
+        JsonSchema? node = null;
+        foreach (var file in assembly.GetManifestResourceNames())
         {
-            var subschema = JsonSchema.FromFile(path);
-            SchemaRegistry.Global.Register(subschema);
-        }
+            var fileStream = assembly.GetManifestResourceStream(file);
+            var assemblyName = Assembly.GetExecutingAssembly().GetName().Name;
+            if (fileStream == null)
+            {
+                throw new IOException($"Resource {file} could not found in assembly {assemblyName}");
+            }
+            using var streamReader = new StreamReader(fileStream);
+            var jsonSchemaString = streamReader.ReadToEnd();
+            var schema = JsonSchema.FromText(jsonSchemaString);
+
+            // assembly name is Microsoft.PowerPlatform.PowerApps.Persistence
+            // subNamespace is YamlValidator, schemas live in the linked schema folder
+            var rootFileName = $"{assemblyName}.{Constants.subNamespace}.{_schemaFolderPath}";
 
+            if (file.StartsWith($"{rootFileName}.{_subschemaFolderPath}.", StringComparison.Ordinal))
+            {
+                // these virtual uri's are used to resolve $ref's in the schema, they aren't
+                // represented like this in the dll
+                schema.BaseUri = new Uri($"file://{_schemaFolderPath}/{_subschemaFolderPath}/");
+                SchemaRegistry.Global.Register(schema);
+                continue;
+            }
+            schema.BaseUri = new Uri($"file://{_schemaFolderPath}");
+            node = schema;
+        }
+        if (node == null)
+        {
+            throw new InvalidDataException("Schema was not able to be read into memory");
+        }
         return node;
     }
 }

src/Persistence/YamlValidator/Utility.cs

@@ -7,12 +7,6 @@ namespace Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
 
 public class Utility
 {
-    public static string ReadFileData(string filePath)
-    {
-        var yamlData = File.ReadAllText(filePath);
-        return yamlData;
-    }
-
     public static YamlStream MakeYamlStream(string yamlString)
     {
         var stream = new YamlStream();

src/Persistence/YamlValidator/Validator.cs

@@ -4,40 +4,47 @@
 using Json.Schema;
 using Yaml2JsonNode;
 using System.Text.Json;
+using YamlDotNet.Core;
+using YamlDotNet.RepresentationModel;
 
 namespace Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
 
-public class Validator
+internal class Validator : IValidator
 {
     private readonly EvaluationOptions _verbosityOptions;
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private member",
+    Justification = "Suppress serializing the raw validator errors into json will be useful for future use")]
     private readonly JsonSerializerOptions _serializerOptions;
-
-    public Validator(EvaluationOptions options, JsonSerializerOptions resultSerializeOptions)
+    private readonly JsonSchema _schema;
+    public Validator(EvaluationOptions options, JsonSerializerOptions resultSerializeOptions, JsonSchema schema)
     {
         // to do: add verbosity flag and allow users to choose verbosity of evaluation
         _verbosityOptions = options;
         _serializerOptions = resultSerializeOptions;
+        _schema = schema;
     }
-
-    public ValidatorResults Validate(JsonSchema schema, string yamlFileData)
+    public ValidatorResults Validate(string yamlFileData)
     {
-        var yamlStream = Utility.MakeYamlStream(yamlFileData);
+        YamlStream yamlStream;
+        try
+        {
+            yamlStream = Utility.MakeYamlStream(yamlFileData);
+        }
+        catch (YamlException)
+        {
+            return new ValidatorResults(false, new List<ValidatorError> { new(Constants.notYamlError) });
+        }
+
         var jsonData = yamlStream.Documents.Count > 0 ? yamlStream.Documents[0].ToJsonNode() : null;
 
         // here we say that empty yaml is serialized as null json
         if (jsonData == null)
         {
-            return new ValidatorResults(false, new List<ValidatorError> { new("Empty YAML file") });
+            return new ValidatorResults(false, new List<ValidatorError> { new(Constants.emptyYamlError) });
         }
-        var results = schema.Evaluate(jsonData, _verbosityOptions);
-
-        // not used but may help if we ever need to serialize the evaluation results into json format to feed into
-        // a VSCode extension or other tool
-        var output = JsonSerializer.Serialize(results, _serializerOptions);
+        var results = _schema.Evaluate(jsonData, _verbosityOptions);
 
         var schemaValidity = results.IsValid;
-        // TBD: filter actual errors versus false positives
-        // we look for errors that are not valid, have errors, and have an instance location (i.e are not oneOf errors)
         var yamlValidatorErrors = new List<ValidatorError>();
         if (!schemaValidity)
         {
@@ -46,7 +53,10 @@ public ValidatorResults Validate(JsonSchema schema, string yamlFileData)
              node.HasErrors).ToList();
             foreach (var trace in traceList)
             {
-                yamlValidatorErrors.Add(new ValidatorError(trace));
+                var instanceLocation = trace.InstanceLocation.ToString();
+                var schemaPath = trace.EvaluationPath.ToString();
+                var errors = trace.Errors;
+                yamlValidatorErrors.Add(new ValidatorError(instanceLocation, schemaPath, errors));
             }
         }
 

src/Persistence/YamlValidator/ValidatorError.cs

@@ -1,20 +1,19 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using Json.Schema;
-
 namespace Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
+
 public class ValidatorError
 {
     public string InstanceLocation { get; }
     public string SchemaPath { get; }
     public IReadOnlyDictionary<string, string>? Errors { get; }
 
-    public ValidatorError(EvaluationResults results)
+    public ValidatorError(string instancePath, string schemaPath, IReadOnlyDictionary<string, string>? errors)
     {
-        InstanceLocation = results.InstanceLocation.ToString();
-        SchemaPath = results.EvaluationPath.ToString();
-        Errors = results.Errors;
+        InstanceLocation = instancePath;
+        SchemaPath = schemaPath;
+        Errors = errors;
     }
 
     public ValidatorError(string error)

src/Persistence/YamlValidator/ValidatorFactory.cs

@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Json.Schema;
+using System.Text.Json;
+
+namespace Microsoft.PowerPlatform.PowerApps.Persistence.YamlValidator;
+
+internal class ValidatorFactory : IValidatorFactory
+{
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static",
+        Justification = "Suppress to make classes stateless")]
+    public IValidator GetValidator()
+    {
+        // register schema in from memory into global schema registry
+        var schemaLoader = new SchemaLoader();
+        var serializedSchema = schemaLoader.Load();
+
+        var evalOptions = new EvaluationOptions
+        {
+            OutputFormat = OutputFormat.List
+        };
+
+        // pass in serailization options for validator results object to json
+        // This is unused for now but can be useful for producing raw json validation results which can be consumed elsewhere
+        var resultSerializeOptions = new JsonSerializerOptions
+        {
+            Converters = { new EvaluationResultsJsonConverter() }
+        };
+
+        return new Validator(evalOptions, resultSerializeOptions, serializedSchema);
+    }
+}

src/Persistence/YamlValidator/ValidatorResults.cs

@@ -15,6 +15,8 @@ public ValidatorResults(bool schemaValid, IReadOnlyList<ValidatorError> traversa
         TraversalResults = FilterErrors(traversalResults);
     }
 
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static",
+    Justification = "Suppress to make classes stateless")]
     //  This will filter out the false positives that are not relevant to the error output, when the validation is false
     private ReadOnlyCollection<ValidatorError> FilterErrors(IReadOnlyList<ValidatorError> traversalResults)
     {