add option to generate separate files

Author: shuebner

XmlSchemaClassGenerator.SourceGenerator.Tests/Samples/simple_schema.xsd

@@ -19,6 +19,13 @@
             <xs:restriction base="xs:string"/>
           </xs:simpleType>
         </xs:element>
+        <xs:element name="ComplexChild1">
+          <xs:complexType id="SomeComplexType">
+            <xs:all>
+              <xs:element name="Child11"></xs:element>
+            </xs:all>
+          </xs:complexType>
+        </xs:element>
       </xs:all>
     </xs:complexType>
   </xs:element>

XmlSchemaClassGenerator.SourceGenerator.Tests/SimpleSchemaTests.cs

@@ -1,4 +1,3 @@
-using System;
 using Xunit;
 
 namespace XmlSchemaClassGenerator.SourceGenerator.Tests
@@ -11,7 +10,11 @@ public void Compiles()
             new Sample.Generated.MyRootElement
             {
                 Child1 = true,
-                Child2 = "foo"
+                Child2 = "foo",
+                ComplexChild1 = new Sample.Generated.MyRootElementComplexChild1
+                {
+                    Child11 = null
+                }
             };
         }
     }

XmlSchemaClassGenerator.SourceGenerator.Tests/XmlSchemaClassGenerator.SourceGenerator.Tests.csproj

@@ -31,6 +31,7 @@
 
   <PropertyGroup>
     <xscgen_Namespace>Sample.Generated</xscgen_Namespace>
+    <xscgen_SeparateFiles>true</xscgen_SeparateFiles>
   </PropertyGroup>
 
   <ItemGroup>

XmlSchemaClassGenerator.SourceGenerator/XmlSchemaClassGenerator.SourceGenerator.props

@@ -1,5 +1,6 @@
 <Project>
   <ItemGroup>
     <CompilerVisibleProperty Include="xscgen_Namespace" />
+    <CompilerVisibleProperty Include="xscgen_SeparateFiles" />
   </ItemGroup>
 </Project>

XmlSchemaClassGenerator.SourceGenerator/XsdSourceGenerator.cs

@@ -5,6 +5,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
 using System.Xml;
 using System.Xml.Schema;
 
@@ -15,30 +17,75 @@ public class XsdSourceGenerator : ISourceGenerator
     {
         internal class MemoryOutputWriter : OutputWriter
         {
-            public string Content { get; set; }
+            private readonly bool separateFiles;
+
+            public ICollection<(string Name, string Content)> Contents { get; private set; } = new List<(string, string)>();
+
+            public MemoryOutputWriter(bool separateFiles)
+            {
+                this.separateFiles = separateFiles;
+            }
 
             public override void Write(CodeNamespace cn)
             {
                 var cu = new CodeCompileUnit();
                 cu.Namespaces.Add(cn);
 
-                using (var writer = new StringWriter())
+                if (separateFiles)
+                {
+                    WriteSeparateFiles(cn);
+                }
+                else
+                {
+                    using (var writer = new StringWriter())
+                    {
+                        Write(writer, cu);
+                        Contents.Add(("Pocos", writer.ToString()));
+                    }
+                }
+            }
+
+            private void WriteSeparateFiles(CodeNamespace cn)
+            {
+                var validName = ValidateName(cn.Name);
+                var ccu = new CodeCompileUnit();
+                var cns = new CodeNamespace(validName);
+
+                cns.Imports.AddRange(cn.Imports.Cast<CodeNamespaceImport>().ToArray());
+                cns.Comments.AddRange(cn.Comments);
+                ccu.Namespaces.Add(cns);
+
+                foreach (CodeTypeDeclaration ctd in cn.Types)
                 {
-                    Write(writer, cu);
-                    Content = writer.ToString();
+                    var contentName = ctd.Name;
+                    cns.Types.Clear();
+                    cns.Types.Add(ctd);
+                    using (var writer = new StringWriter())
+                    {
+                        Write(writer, ccu);
+                        Contents.Add((contentName, writer.ToString()));
+                    }
                 }
             }
+
+            static readonly Regex InvalidCharacters = new Regex($"[{string.Join("", Path.GetInvalidFileNameChars())}]", RegexOptions.Compiled);
+
+            private string ValidateName(string name) => InvalidCharacters.Replace(name, "_");
         }
 
         public void Execute(GeneratorExecutionContext context)
         {
 #if DEBUG
             if (!Debugger.IsAttached)
             {
-                //Debugger.Launch();
+                // Debugger.Launch();
             }
 #endif
             var configurations = GetConfigurations(context);
+            bool generateSeparateFiles =
+                context.AnalyzerConfigOptions.GlobalOptions.TryGetValue("build_property.xscgen_separatefiles", out var generateSeparateFilesStr) &&
+                bool.TryParse(generateSeparateFilesStr, out var parsedGenerateSeparateFiles) &&
+                parsedGenerateSeparateFiles;
 
             foreach (var (schemaFile, @namespace) in configurations)
             {
@@ -50,10 +97,15 @@ public void Execute(GeneratorExecutionContext context)
 
                 var generator = new Generator();
                 generator.NamespaceProvider.Add(new NamespaceKey(), @namespace);
-                MemoryOutputWriter memoryOutputWriter = new MemoryOutputWriter();
+                generator.SeparateClasses = generateSeparateFiles;
+                MemoryOutputWriter memoryOutputWriter = new MemoryOutputWriter(generateSeparateFiles);
                 generator.OutputWriter = memoryOutputWriter;
                 generator.Generate(schemaSet);
-                context.AddSource("Pocos", memoryOutputWriter.Content);
+
+                foreach (var (name, content) in memoryOutputWriter.Contents)
+                {
+                    context.AddSource(name, content);
+                }
             }
         }
 
@@ -64,7 +116,7 @@ public void Initialize(GeneratorInitializationContext context)
 
         static IEnumerable<(AdditionalText SchemaFile, string Namespace)> GetConfigurations(GeneratorExecutionContext context)
         {
-            if (!context.AnalyzerConfigOptions.GlobalOptions.TryGetValue("build_property.xscgen_Namespace", out var @namespace))
+            if (!context.AnalyzerConfigOptions.GlobalOptions.TryGetValue("build_property.xscgen_namespace", out var @namespace))
             {
                 @namespace = "Generated";
             }